Project import
diff --git a/FreeRTOSV7.2.0/FreeRTOS/License/license.txt b/FreeRTOSV7.2.0/FreeRTOS/License/license.txt
new file mode 100644
index 0000000..2e32746
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/License/license.txt
@@ -0,0 +1,440 @@
+The FreeRTOS.org source code is licensed by the *modified* GNU General Public

+License (GPL), text provided below.  A special exception 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 any proprietary 

+components.  See the licensing section of http://www.FreeRTOS.org for full 

+details.  The exception text is also included at the bottom of this file.

+

+The FreeRTOS download also includes demo application source code, some of 

+which is provided by third parties AND IS LICENSED SEPARATELY FROM FREERTOS.

+

+For the avoidance of any doubt refer to the comment included at the top

+of each source and header file for license and copyright information.

+

+This is a list of files for which Real Time Engineers Ltd are not the 

+copyright owner and are NOT COVERED BY THE GPL.

+

+

+1) Various header files provided by silicon manufacturers and tool vendors

+   that define processor specific memory addresses and utility macros.

+   Permission has been granted by the various copyright holders for these

+   files to be included in the FreeRTOS download.  Users must ensure license

+   conditions are adhered to for any use other than compilation of the 

+   FreeRTOS demo applications.

+

+2) The uIP TCP/IP stack the copyright of which is held by Adam Dunkels.

+   Users must ensure the open source license conditions stated at the top 

+   of each uIP source file is understood and adhered to.

+

+3) The lwIP TCP/IP stack the copyright of which is held by the Swedish 

+   Institute of Computer Science.  Users must ensure the open source license 

+   conditions stated at the top  of each lwIP source file is understood and 

+   adhered to.

+

+4) Various peripheral driver source files and binaries provided by silicon

+   manufacturers and tool vendors.  Permission has been granted by the

+   various copyright holders for these files to be included in the FreeRTOS

+   download.  Users must ensure license conditions are adhered to for any

+   use other than compilation of the FreeRTOS demo applications.

+

+5) The files contained within FreeRTOS\Demo\WizNET_DEMO_TERN_186\tern_code,

+   which are slightly modified versions of code provided by and copyright to

+   Tern Inc.

+

+Errors and omissions should be reported to Richard Barry, contact details for

+whom can be obtained from http://www.FreeRTOS.org.

+

+

+

+

+

+The GPL license text follows.

+

+A special exception 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 any proprietary components.  See the licensing section

+of http://www.FreeRTOS.org for full details.  The exception text is also

+included at the bottom of this file.

+

+--------------------------------------------------------------------

+

+

+

+		    GNU GENERAL PUBLIC LICENSE

+		       Version 2, June 1991

+

+ Copyright (C) 1989, 1991 Free Software Foundation, Inc.

+                       59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

+ Everyone is permitted to copy and distribute verbatim copies

+ of this license document, but changing it is not allowed.

+

+			    Preamble

+

+  The licenses for most software are designed to take away your

+freedom to share and change it.  By contrast, the GNU General Public

+License is intended to guarantee your freedom to share and change free

+software--to make sure the software is free for all its users.  This

+General Public License applies to most of the Free Software

+Foundation's software and to any other program whose authors commit to

+using it.  (Some other Free Software Foundation software is covered by

+the GNU Library General Public License instead.)  You can apply it to

+your programs, too.

+

+  When we speak of free software, we are referring to freedom, not

+price.  Our General Public Licenses are designed to make sure that you

+have the freedom to distribute copies of free software (and charge for

+this service if you wish), that you receive source code or can get it

+if you want it, that you can change the software or use pieces of it

+in new free programs; and that you know you can do these things.

+

+  To protect your rights, we need to make restrictions that forbid

+anyone to deny you these rights or to ask you to surrender the rights.

+These restrictions translate to certain responsibilities for you if you

+distribute copies of the software, or if you modify it.

+

+  For example, if you distribute copies of such a program, whether

+gratis or for a fee, you must give the recipients all the rights that

+you have.  You must make sure that they, too, receive or can get the

+source code.  And you must show them these terms so they know their

+rights.

+

+  We protect your rights with two steps: (1) copyright the software, and

+(2) offer you this license which gives you legal permission to copy,

+distribute and/or modify the software.

+

+  Also, for each author's protection and ours, we want to make certain

+that everyone understands that there is no warranty for this free

+software.  If the software is modified by someone else and passed on, we

+want its recipients to know that what they have is not the original, so

+that any problems introduced by others will not reflect on the original

+authors' reputations.

+

+  Finally, any free program is threatened constantly by software

+patents.  We wish to avoid the danger that redistributors of a free

+program will individually obtain patent licenses, in effect making the

+program proprietary.  To prevent this, we have made it clear that any

+patent must be licensed for everyone's free use or not licensed at all.

+

+  The precise terms and conditions for copying, distribution and

+modification follow.

+

+		    GNU GENERAL PUBLIC LICENSE

+   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION

+

+  0. This License applies to any program or other work which contains

+a notice placed by the copyright holder saying it may be distributed

+under the terms of this General Public License.  The "Program", below,

+refers to any such program or work, and a "work based on the Program"

+means either the Program or any derivative work under copyright law:

+that is to say, a work containing the Program or a portion of it,

+either verbatim or with modifications and/or translated into another

+language.  (Hereinafter, translation is included without limitation in

+the term "modification".)  Each licensee is addressed as "you".

+

+Activities other than copying, distribution and modification are not

+covered by this License; they are outside its scope.  The act of

+running the Program is not restricted, and the output from the Program

+is covered only if its contents constitute a work based on the

+Program (independent of having been made by running the Program).

+Whether that is true depends on what the Program does.

+

+  1. You may copy and distribute verbatim copies of the Program's

+source code as you receive it, in any medium, provided that you

+conspicuously and appropriately publish on each copy an appropriate

+copyright notice and disclaimer of warranty; keep intact all the

+notices that refer to this License and to the absence of any warranty;

+and give any other recipients of the Program a copy of this License

+along with the Program.

+

+You may charge a fee for the physical act of transferring a copy, and

+you may at your option offer warranty protection in exchange for a fee.

+

+  2. You may modify your copy or copies of the Program or any portion

+of it, thus forming a work based on the Program, and copy and

+distribute such modifications or work under the terms of Section 1

+above, provided that you also meet all of these conditions:

+

+    a) You must cause the modified files to carry prominent notices

+    stating that you changed the files and the date of any change.

+

+    b) You must cause any work that you distribute or publish, that in

+    whole or in part contains or is derived from the Program or any

+    part thereof, to be licensed as a whole at no charge to all third

+    parties under the terms of this License.

+

+    c) If the modified program normally reads commands interactively

+    when run, you must cause it, when started running for such

+    interactive use in the most ordinary way, to print or display an

+    announcement including an appropriate copyright notice and a

+    notice that there is no warranty (or else, saying that you provide

+    a warranty) and that users may redistribute the program under

+    these conditions, and telling the user how to view a copy of this

+    License.  (Exception: if the Program itself is interactive but

+    does not normally print such an announcement, your work based on

+    the Program is not required to print an announcement.)

+

+These requirements apply to the modified work as a whole.  If

+identifiable sections of that work are not derived from the Program,

+and can be reasonably considered independent and separate works in

+themselves, then this License, and its terms, do not apply to those

+sections when you distribute them as separate works.  But when you

+distribute the same sections as part of a whole which is a work based

+on the Program, the distribution of the whole must be on the terms of

+this License, whose permissions for other licensees extend to the

+entire whole, and thus to each and every part regardless of who wrote it.

+

+Thus, it is not the intent of this section to claim rights or contest

+your rights to work written entirely by you; rather, the intent is to

+exercise the right to control the distribution of derivative or

+collective works based on the Program.

+

+In addition, mere aggregation of another work not based on the Program

+with the Program (or with a work based on the Program) on a volume of

+a storage or distribution medium does not bring the other work under

+the scope of this License.

+

+  3. You may copy and distribute the Program (or a work based on it,

+under Section 2) in object code or executable form under the terms of

+Sections 1 and 2 above provided that you also do one of the following:

+

+    a) Accompany it with the complete corresponding machine-readable

+    source code, which must be distributed under the terms of Sections

+    1 and 2 above on a medium customarily used for software interchange; or,

+

+    b) Accompany it with a written offer, valid for at least three

+    years, to give any third party, for a charge no more than your

+    cost of physically performing source distribution, a complete

+    machine-readable copy of the corresponding source code, to be

+    distributed under the terms of Sections 1 and 2 above on a medium

+    customarily used for software interchange; or,

+

+    c) Accompany it with the information you received as to the offer

+    to distribute corresponding source code.  (This alternative is

+    allowed only for noncommercial distribution and only if you

+    received the program in object code or executable form with such

+    an offer, in accord with Subsection b above.)

+

+The source code for a work means the preferred form of the work for

+making modifications to it.  For an executable work, complete source

+code means all the source code for all modules it contains, plus any

+associated interface definition files, plus the scripts used to

+control compilation and installation of the executable.  However, as a

+special exception, the source code distributed need not include

+anything that is normally distributed (in either source or binary

+form) with the major components (compiler, kernel, and so on) of the

+operating system on which the executable runs, unless that component

+itself accompanies the executable.

+

+If distribution of executable or object code is made by offering

+access to copy from a designated place, then offering equivalent

+access to copy the source code from the same place counts as

+distribution of the source code, even though third parties are not

+compelled to copy the source along with the object code.

+

+  4. You may not copy, modify, sublicense, or distribute the Program

+except as expressly provided under this License.  Any attempt

+otherwise to copy, modify, sublicense or distribute the Program is

+void, and will automatically terminate your rights under this License.

+However, parties who have received copies, or rights, from you under

+this License will not have their licenses terminated so long as such

+parties remain in full compliance.

+

+  5. You are not required to accept this License, since you have not

+signed it.  However, nothing else grants you permission to modify or

+distribute the Program or its derivative works.  These actions are

+prohibited by law if you do not accept this License.  Therefore, by

+modifying or distributing the Program (or any work based on the

+Program), you indicate your acceptance of this License to do so, and

+all its terms and conditions for copying, distributing or modifying

+the Program or works based on it.

+

+  6. Each time you redistribute the Program (or any work based on the

+Program), the recipient automatically receives a license from the

+original licensor to copy, distribute or modify the Program subject to

+these terms and conditions.  You may not impose any further

+restrictions on the recipients' exercise of the rights granted herein.

+You are not responsible for enforcing compliance by third parties to

+this License.

+

+  7. If, as a consequence of a court judgment or allegation of patent

+infringement or for any other reason (not limited to patent issues),

+conditions are imposed on you (whether by court order, agreement or

+otherwise) that contradict the conditions of this License, they do not

+excuse you from the conditions of this License.  If you cannot

+distribute so as to satisfy simultaneously your obligations under this

+License and any other pertinent obligations, then as a consequence you

+may not distribute the Program at all.  For example, if a patent

+license would not permit royalty-free redistribution of the Program by

+all those who receive copies directly or indirectly through you, then

+the only way you could satisfy both it and this License would be to

+refrain entirely from distribution of the Program.

+

+If any portion of this section is held invalid or unenforceable under

+any particular circumstance, the balance of the section is intended to

+apply and the section as a whole is intended to apply in other

+circumstances.

+

+It is not the purpose of this section to induce you to infringe any

+patents or other property right claims or to contest validity of any

+such claims; this section has the sole purpose of protecting the

+integrity of the free software distribution system, which is

+implemented by public license practices.  Many people have made

+generous contributions to the wide range of software distributed

+through that system in reliance on consistent application of that

+system; it is up to the author/donor to decide if he or she is willing

+to distribute software through any other system and a licensee cannot

+impose that choice.

+

+This section is intended to make thoroughly clear what is believed to

+be a consequence of the rest of this License.

+

+  8. If the distribution and/or use of the Program is restricted in

+certain countries either by patents or by copyrighted interfaces, the

+original copyright holder who places the Program under this License

+may add an explicit geographical distribution limitation excluding

+those countries, so that distribution is permitted only in or among

+countries not thus excluded.  In such case, this License incorporates

+the limitation as if written in the body of this License.

+

+  9. The Free Software Foundation may publish revised and/or new versions

+of the General Public License from time to time.  Such new versions will

+be similar in spirit to the present version, but may differ in detail to

+address new problems or concerns.

+

+Each version is given a distinguishing version number.  If the Program

+specifies a version number of this License which applies to it and "any

+later version", you have the option of following the terms and conditions

+either of that version or of any later version published by the Free

+Software Foundation.  If the Program does not specify a version number of

+this License, you may choose any version ever published by the Free Software

+Foundation.

+

+  10. If you wish to incorporate parts of the Program into other free

+programs whose distribution conditions are different, write to the author

+to ask for permission.  For software which is copyrighted by the Free

+Software Foundation, write to the Free Software Foundation; we sometimes

+make exceptions for this.  Our decision will be guided by the two goals

+of preserving the free status of all derivatives of our free software and

+of promoting the sharing and reuse of software generally.

+

+			    NO WARRANTY

+

+  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY

+FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW.  EXCEPT WHEN

+OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES

+PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED

+OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

+MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.  THE ENTIRE RISK AS

+TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU.  SHOULD THE

+PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING,

+REPAIR OR CORRECTION.

+

+  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING

+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR

+REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES,

+INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING

+OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED

+TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY

+YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER

+PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE

+POSSIBILITY OF SUCH DAMAGES.

+

+		     END OF TERMS AND CONDITIONS

+

+	    How to Apply These Terms to Your New Programs

+

+  If you develop a new program, and you want it to be of the greatest

+possible use to the public, the best way to achieve this is to make it

+free software which everyone can redistribute and change under these terms.

+

+  To do so, attach the following notices to the program.  It is safest

+to attach them to the start of each source file to most effectively

+convey the exclusion of warranty; and each file should have at least

+the "copyright" line and a pointer to where the full notice is found.

+

+    <one line to give the program's name and a brief idea of what it does.>

+    Copyright (C) <year>  <name of author>

+

+    This program 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.

+

+    This program 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 this program; if not, write to the Free Software

+    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

+

+

+Also add information on how to contact you by electronic and paper mail.

+

+If the program is interactive, make it output a short notice like this

+when it starts in an interactive mode:

+

+    Gnomovision version 69, Copyright (C) year name of author

+    Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'.

+    This is free software, and you are welcome to redistribute it

+    under certain conditions; type `show c' for details.

+

+The hypothetical commands `show w' and `show c' should show the appropriate

+parts of the General Public License.  Of course, the commands you use may

+be called something other than `show w' and `show c'; they could even be

+mouse-clicks or menu items--whatever suits your program.

+

+You should also get your employer (if you work as a programmer) or your

+school, if any, to sign a "copyright disclaimer" for the program, if

+necessary.  Here is a sample; alter the names:

+

+  Yoyodyne, Inc., hereby disclaims all copyright interest in the program

+  `Gnomovision' (which makes passes at compilers) written by James Hacker.

+

+  <signature of Ty Coon>, 1 April 1989

+  Ty Coon, President of Vice

+

+This General Public License does not permit incorporating your program into

+proprietary programs.  If your program is a subroutine library, you may

+consider it more useful to permit linking proprietary applications with the

+library.  If this is what you want to do, use the GNU Library General

+Public License instead of this License.

+

+----------------------------------------------------------------------------

+

+The FreeRTOS GPL Exception Text:

+

+Any FreeRTOS source code, whether modified or in it's original release form, 

+or whether in whole or in part, can only be distributed by you under the terms 

+of the GNU General Public License plus this exception. An independent module is 

+a module which is not derived from or based on FreeRTOS.

+

+Clause 1:

+

+Linking FreeRTOS statically or dynamically with other modules is making a 

+combined work based on FreeRTOS. Thus, the terms and conditions of the GNU 

+General Public License cover the whole combination.

+

+As a special exception, the copyright holder of FreeRTOS gives you permission 

+to link FreeRTOS with independent modules that communicate with FreeRTOS 

+solely through the FreeRTOS API interface, regardless of the license terms of 

+these independent modules, and to copy and distribute the resulting combined 

+work under terms of your choice, provided that

+

+  + Every copy of the combined work is accompanied by a written statement that 

+  details to the recipient the version of FreeRTOS used and an offer by yourself 

+  to provide the FreeRTOS source code (including any modifications you may have 

+  made) should the recipient request it.

+

+  + The combined work is not itself an RTOS, scheduler, kernel or related product.

+

+  + The independent modules add significant and primary functionality to FreeRTOS 

+  and do not merely extend the existing functionality already present in FreeRTOS.

+

+Clause 2:

+

+FreeRTOS may not be used for any competitive or comparative purpose, including the 

+publication of any form of run time or compile time metric, without the express 

+permission of Real Time Engineers Ltd. (this is the norm within the industry and 

+is intended to ensure information accuracy).

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/croutine.c b/FreeRTOSV7.2.0/FreeRTOS/Source/croutine.c
new file mode 100644
index 0000000..0d62ca0
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/croutine.c
@@ -0,0 +1,387 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+#include "FreeRTOS.h"

+#include "task.h"

+#include "croutine.h"

+

+/*

+ * Some kernel aware debuggers require data to be viewed to be global, rather

+ * than file scope.

+ */

+#ifdef portREMOVE_STATIC_QUALIFIER

+	#define static

+#endif

+

+

+/* Lists for ready and blocked co-routines. --------------------*/

+static xList pxReadyCoRoutineLists[ configMAX_CO_ROUTINE_PRIORITIES ];	/*< Prioritised ready co-routines. */

+static xList xDelayedCoRoutineList1;									/*< Delayed co-routines. */

+static xList xDelayedCoRoutineList2;									/*< Delayed co-routines (two lists are used - one for delays that have overflowed the current tick count. */

+static xList * pxDelayedCoRoutineList;									/*< Points to the delayed co-routine list currently being used. */

+static xList * pxOverflowDelayedCoRoutineList;							/*< Points to the delayed co-routine list currently being used to hold co-routines that have overflowed the current tick count. */

+static xList xPendingReadyCoRoutineList;											/*< Holds co-routines that have been readied by an external event.  They cannot be added directly to the ready lists as the ready lists cannot be accessed by interrupts. */

+

+/* Other file private variables. --------------------------------*/

+corCRCB * pxCurrentCoRoutine = NULL;

+static unsigned portBASE_TYPE uxTopCoRoutineReadyPriority = 0;

+static portTickType xCoRoutineTickCount = 0, xLastTickCount = 0, xPassedTicks = 0;

+

+/* The initial state of the co-routine when it is created. */

+#define corINITIAL_STATE	( 0 )

+

+/*

+ * Place the co-routine represented by pxCRCB into the appropriate ready queue

+ * for the priority.  It is inserted at the end of the list.

+ *

+ * This macro accesses the co-routine ready lists and therefore must not be

+ * used from within an ISR.

+ */

+#define prvAddCoRoutineToReadyQueue( pxCRCB )																		\

+{																													\

+	if( pxCRCB->uxPriority > uxTopCoRoutineReadyPriority )															\

+	{																												\

+		uxTopCoRoutineReadyPriority = pxCRCB->uxPriority;															\

+	}																												\

+	vListInsertEnd( ( xList * ) &( pxReadyCoRoutineLists[ pxCRCB->uxPriority ] ), &( pxCRCB->xGenericListItem ) );	\

+}	

+

+/*

+ * Utility to ready all the lists used by the scheduler.  This is called

+ * automatically upon the creation of the first co-routine.

+ */

+static void prvInitialiseCoRoutineLists( void );

+

+/*

+ * Co-routines that are readied by an interrupt cannot be placed directly into

+ * the ready lists (there is no mutual exclusion).  Instead they are placed in

+ * in the pending ready list in order that they can later be moved to the ready

+ * list by the co-routine scheduler.

+ */

+static void prvCheckPendingReadyList( void );

+

+/*

+ * Macro that looks at the list of co-routines that are currently delayed to

+ * see if any require waking.

+ *

+ * Co-routines are stored in the queue in the order of their wake time -

+ * meaning once one co-routine has been found whose timer has not expired

+ * we need not look any further down the list.

+ */

+static void prvCheckDelayedList( void );

+

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

+

+signed portBASE_TYPE xCoRoutineCreate( crCOROUTINE_CODE pxCoRoutineCode, unsigned portBASE_TYPE uxPriority, unsigned portBASE_TYPE uxIndex )

+{

+signed portBASE_TYPE xReturn;

+corCRCB *pxCoRoutine;

+

+	/* Allocate the memory that will store the co-routine control block. */

+	pxCoRoutine = ( corCRCB * ) pvPortMalloc( sizeof( corCRCB ) );

+	if( pxCoRoutine )

+	{

+		/* If pxCurrentCoRoutine is NULL then this is the first co-routine to

+		be created and the co-routine data structures need initialising. */

+		if( pxCurrentCoRoutine == NULL )

+		{

+			pxCurrentCoRoutine = pxCoRoutine;

+			prvInitialiseCoRoutineLists();

+		}

+

+		/* Check the priority is within limits. */

+		if( uxPriority >= configMAX_CO_ROUTINE_PRIORITIES )

+		{

+			uxPriority = configMAX_CO_ROUTINE_PRIORITIES - 1;

+		}

+

+		/* Fill out the co-routine control block from the function parameters. */

+		pxCoRoutine->uxState = corINITIAL_STATE;

+		pxCoRoutine->uxPriority = uxPriority;

+		pxCoRoutine->uxIndex = uxIndex;

+		pxCoRoutine->pxCoRoutineFunction = pxCoRoutineCode;

+

+		/* Initialise all the other co-routine control block parameters. */

+		vListInitialiseItem( &( pxCoRoutine->xGenericListItem ) );

+		vListInitialiseItem( &( pxCoRoutine->xEventListItem ) );

+

+		/* Set the co-routine control block as a link back from the xListItem.

+		This is so we can get back to the containing CRCB from a generic item

+		in a list. */

+		listSET_LIST_ITEM_OWNER( &( pxCoRoutine->xGenericListItem ), pxCoRoutine );

+		listSET_LIST_ITEM_OWNER( &( pxCoRoutine->xEventListItem ), pxCoRoutine );

+	

+		/* Event lists are always in priority order. */

+		listSET_LIST_ITEM_VALUE( &( pxCoRoutine->xEventListItem ), configMAX_PRIORITIES - ( portTickType ) uxPriority );

+		

+		/* Now the co-routine has been initialised it can be added to the ready

+		list at the correct priority. */

+		prvAddCoRoutineToReadyQueue( pxCoRoutine );

+

+		xReturn = pdPASS;

+	}

+	else

+	{		

+		xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;

+	}

+	

+	return xReturn;	

+}

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

+

+void vCoRoutineAddToDelayedList( portTickType xTicksToDelay, xList *pxEventList )

+{

+portTickType xTimeToWake;

+

+	/* Calculate the time to wake - this may overflow but this is

+	not a problem. */

+	xTimeToWake = xCoRoutineTickCount + xTicksToDelay;

+

+	/* We must remove ourselves from the ready list before adding

+	ourselves to the blocked list as the same list item is used for

+	both lists. */

+	vListRemove( ( xListItem * ) &( pxCurrentCoRoutine->xGenericListItem ) );

+

+	/* The list item will be inserted in wake time order. */

+	listSET_LIST_ITEM_VALUE( &( pxCurrentCoRoutine->xGenericListItem ), xTimeToWake );

+

+	if( xTimeToWake < xCoRoutineTickCount )

+	{

+		/* Wake time has overflowed.  Place this item in the

+		overflow list. */

+		vListInsert( ( xList * ) pxOverflowDelayedCoRoutineList, ( xListItem * ) &( pxCurrentCoRoutine->xGenericListItem ) );

+	}

+	else

+	{

+		/* The wake time has not overflowed, so we can use the

+		current block list. */

+		vListInsert( ( xList * ) pxDelayedCoRoutineList, ( xListItem * ) &( pxCurrentCoRoutine->xGenericListItem ) );

+	}

+

+	if( pxEventList )

+	{

+		/* Also add the co-routine to an event list.  If this is done then the

+		function must be called with interrupts disabled. */

+		vListInsert( pxEventList, &( pxCurrentCoRoutine->xEventListItem ) );

+	}

+}

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

+

+static void prvCheckPendingReadyList( void )

+{

+	/* Are there any co-routines waiting to get moved to the ready list?  These

+	are co-routines that have been readied by an ISR.  The ISR cannot access

+	the	ready lists itself. */

+	while( listLIST_IS_EMPTY( &xPendingReadyCoRoutineList ) == pdFALSE )

+	{

+		corCRCB *pxUnblockedCRCB;

+

+		/* The pending ready list can be accessed by an ISR. */

+		portDISABLE_INTERRUPTS();

+		{	

+			pxUnblockedCRCB = ( corCRCB * ) listGET_OWNER_OF_HEAD_ENTRY( (&xPendingReadyCoRoutineList) );			

+			vListRemove( &( pxUnblockedCRCB->xEventListItem ) );

+		}

+		portENABLE_INTERRUPTS();

+

+		vListRemove( &( pxUnblockedCRCB->xGenericListItem ) );

+		prvAddCoRoutineToReadyQueue( pxUnblockedCRCB );	

+	}

+}

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

+

+static void prvCheckDelayedList( void )

+{

+corCRCB *pxCRCB;

+

+	xPassedTicks = xTaskGetTickCount() - xLastTickCount;

+	while( xPassedTicks )

+	{

+		xCoRoutineTickCount++;

+		xPassedTicks--;

+

+		/* If the tick count has overflowed we need to swap the ready lists. */

+		if( xCoRoutineTickCount == 0 )

+		{

+			xList * pxTemp;

+

+			/* Tick count has overflowed so we need to swap the delay lists.  If there are

+			any items in pxDelayedCoRoutineList here then there is an error! */

+			pxTemp = pxDelayedCoRoutineList;

+			pxDelayedCoRoutineList = pxOverflowDelayedCoRoutineList;

+			pxOverflowDelayedCoRoutineList = pxTemp;

+		}

+

+		/* See if this tick has made a timeout expire. */

+		while( listLIST_IS_EMPTY( pxDelayedCoRoutineList ) == pdFALSE )

+		{

+			pxCRCB = ( corCRCB * ) listGET_OWNER_OF_HEAD_ENTRY( pxDelayedCoRoutineList );

+

+			if( xCoRoutineTickCount < listGET_LIST_ITEM_VALUE( &( pxCRCB->xGenericListItem ) ) )				

+			{			

+				/* Timeout not yet expired. */																			

+				break;																				

+			}																						

+

+			portDISABLE_INTERRUPTS();

+			{

+				/* The event could have occurred just before this critical

+				section.  If this is the case then the generic list item will

+				have been moved to the pending ready list and the following

+				line is still valid.  Also the pvContainer parameter will have

+				been set to NULL so the following lines are also valid. */

+				vListRemove( &( pxCRCB->xGenericListItem ) );											

+

+				/* Is the co-routine waiting on an event also? */												

+				if( pxCRCB->xEventListItem.pvContainer )													

+				{															

+					vListRemove( &( pxCRCB->xEventListItem ) );											

+				}

+			}

+			portENABLE_INTERRUPTS();

+

+			prvAddCoRoutineToReadyQueue( pxCRCB );													

+		}																									

+	}

+

+	xLastTickCount = xCoRoutineTickCount;

+}

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

+

+void vCoRoutineSchedule( void )

+{

+	/* See if any co-routines readied by events need moving to the ready lists. */

+	prvCheckPendingReadyList();

+

+	/* See if any delayed co-routines have timed out. */

+	prvCheckDelayedList();

+

+	/* Find the highest priority queue that contains ready co-routines. */

+	while( listLIST_IS_EMPTY( &( pxReadyCoRoutineLists[ uxTopCoRoutineReadyPriority ] ) ) )

+	{

+		if( uxTopCoRoutineReadyPriority == 0 )

+		{

+			/* No more co-routines to check. */

+			return;

+		}

+		--uxTopCoRoutineReadyPriority;

+	}

+

+	/* listGET_OWNER_OF_NEXT_ENTRY walks through the list, so the co-routines

+	 of the	same priority get an equal share of the processor time. */

+	listGET_OWNER_OF_NEXT_ENTRY( pxCurrentCoRoutine, &( pxReadyCoRoutineLists[ uxTopCoRoutineReadyPriority ] ) );

+

+	/* Call the co-routine. */

+	( pxCurrentCoRoutine->pxCoRoutineFunction )( pxCurrentCoRoutine, pxCurrentCoRoutine->uxIndex );

+

+	return;

+}

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

+

+static void prvInitialiseCoRoutineLists( void )

+{

+unsigned portBASE_TYPE uxPriority;

+

+	for( uxPriority = 0; uxPriority < configMAX_CO_ROUTINE_PRIORITIES; uxPriority++ )

+	{

+		vListInitialise( ( xList * ) &( pxReadyCoRoutineLists[ uxPriority ] ) );

+	}

+

+	vListInitialise( ( xList * ) &xDelayedCoRoutineList1 );

+	vListInitialise( ( xList * ) &xDelayedCoRoutineList2 );

+	vListInitialise( ( xList * ) &xPendingReadyCoRoutineList );

+

+	/* Start with pxDelayedCoRoutineList using list1 and the

+	pxOverflowDelayedCoRoutineList using list2. */

+	pxDelayedCoRoutineList = &xDelayedCoRoutineList1;

+	pxOverflowDelayedCoRoutineList = &xDelayedCoRoutineList2;

+}

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

+

+signed portBASE_TYPE xCoRoutineRemoveFromEventList( const xList *pxEventList )

+{

+corCRCB *pxUnblockedCRCB;

+signed portBASE_TYPE xReturn;

+

+	/* This function is called from within an interrupt.  It can only access

+	event lists and the pending ready list.  This function assumes that a

+	check has already been made to ensure pxEventList is not empty. */

+	pxUnblockedCRCB = ( corCRCB * ) listGET_OWNER_OF_HEAD_ENTRY( pxEventList );

+	vListRemove( &( pxUnblockedCRCB->xEventListItem ) );

+	vListInsertEnd( ( xList * ) &( xPendingReadyCoRoutineList ), &( pxUnblockedCRCB->xEventListItem ) );

+

+	if( pxUnblockedCRCB->uxPriority >= pxCurrentCoRoutine->uxPriority )

+	{

+		xReturn = pdTRUE;

+	}

+	else

+	{

+		xReturn = pdFALSE;

+	}

+

+	return xReturn;

+}

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/include/FreeRTOS.h b/FreeRTOSV7.2.0/FreeRTOS/Source/include/FreeRTOS.h
new file mode 100644
index 0000000..fd9027d
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/include/FreeRTOS.h
@@ -0,0 +1,528 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+#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"

+

+#ifdef __cplusplus

+#define cast_to_freeRTOS_string(s) (reinterpret_cast<const signed char*>(s))

+#else

+#define cast_to_freeRTOS_string(s) ((const signed char *)(s))

+#endif

+

+

+/* Defines the prototype to which the application task hook function must

+conform. */

+typedef portBASE_TYPE (*pdTASK_HOOK_CODE)( void * );

+

+

+

+

+

+/*

+ * Check all the required application specific macros have been defined.

+ * These macros are application specific and (as downloaded) are defined

+ * within FreeRTOSConfig.h.

+ */

+

+#ifndef configUSE_PREEMPTION

+	#error Missing definition:  configUSE_PREEMPTION should be defined in FreeRTOSConfig.h as either 1 or 0.  See the Configuration section of the FreeRTOS API documentation for details.

+#endif

+

+#ifndef configUSE_IDLE_HOOK

+	#error Missing definition:  configUSE_IDLE_HOOK should be defined in FreeRTOSConfig.h as either 1 or 0.  See the Configuration section of the FreeRTOS API documentation for details.

+#endif

+

+#ifndef configUSE_TICK_HOOK

+	#error Missing definition:  configUSE_TICK_HOOK should be defined in FreeRTOSConfig.h as either 1 or 0.  See the Configuration section of the FreeRTOS API documentation for details.

+#endif

+

+#ifndef configUSE_CO_ROUTINES

+	#error  Missing definition:  configUSE_CO_ROUTINES should be defined in FreeRTOSConfig.h as either 1 or 0.  See the Configuration section of the FreeRTOS API documentation for details.

+#endif

+

+#ifndef INCLUDE_vTaskPrioritySet

+	#error Missing definition:  INCLUDE_vTaskPrioritySet should be defined in FreeRTOSConfig.h as either 1 or 0.  See the Configuration section of the FreeRTOS API documentation for details.

+#endif

+

+#ifndef INCLUDE_uxTaskPriorityGet

+	#error Missing definition:  INCLUDE_uxTaskPriorityGet should be defined in FreeRTOSConfig.h as either 1 or 0.  See the Configuration section of the FreeRTOS API documentation for details.

+#endif

+

+#ifndef INCLUDE_vTaskDelete		

+	#error Missing definition:  INCLUDE_vTaskDelete		 should be defined in FreeRTOSConfig.h as either 1 or 0.  See the Configuration section of the FreeRTOS API documentation for details.

+#endif

+

+#ifndef INCLUDE_vTaskSuspend	

+	#error Missing definition:  INCLUDE_vTaskSuspend	 should be defined in FreeRTOSConfig.h as either 1 or 0.  See the Configuration section of the FreeRTOS API documentation for details.

+#endif

+

+#ifndef INCLUDE_vTaskDelayUntil

+	#error Missing definition:  INCLUDE_vTaskDelayUntil should be defined in FreeRTOSConfig.h as either 1 or 0.  See the Configuration section of the FreeRTOS API documentation for details.

+#endif

+

+#ifndef INCLUDE_vTaskDelay

+	#error Missing definition:  INCLUDE_vTaskDelay should be defined in FreeRTOSConfig.h as either 1 or 0.  See the Configuration section of the FreeRTOS API documentation for details.

+#endif

+

+#ifndef configUSE_16_BIT_TICKS

+	#error Missing definition:  configUSE_16_BIT_TICKS should be defined in FreeRTOSConfig.h as either 1 or 0.  See the Configuration section of the FreeRTOS API documentation for details.

+#endif

+

+#ifndef INCLUDE_xTaskGetIdleTaskHandle

+	#define INCLUDE_xTaskGetIdleTaskHandle 0

+#endif

+

+#ifndef INCLUDE_xTimerGetTimerDaemonTaskHandle

+	#define INCLUDE_xTimerGetTimerDaemonTaskHandle 0

+#endif

+

+#ifndef INCLUDE_xQueueGetMutexHolder

+	#define INCLUDE_xQueueGetMutexHolder 0

+#endif

+

+#ifndef INCLUDE_pcTaskGetTaskName

+	#define INCLUDE_pcTaskGetTaskName 0

+#endif

+

+#ifndef configUSE_APPLICATION_TASK_TAG

+	#define configUSE_APPLICATION_TASK_TAG 0

+#endif

+

+#ifndef INCLUDE_uxTaskGetStackHighWaterMark

+	#define INCLUDE_uxTaskGetStackHighWaterMark 0

+#endif

+

+#ifndef configUSE_RECURSIVE_MUTEXES

+	#define configUSE_RECURSIVE_MUTEXES 0

+#endif

+

+#ifndef configUSE_MUTEXES

+	#define configUSE_MUTEXES 0

+#endif

+

+#ifndef configUSE_TIMERS

+	#define configUSE_TIMERS 0

+#endif

+

+#ifndef configUSE_COUNTING_SEMAPHORES

+	#define configUSE_COUNTING_SEMAPHORES 0

+#endif

+

+#ifndef configUSE_ALTERNATIVE_API

+	#define configUSE_ALTERNATIVE_API 0

+#endif

+

+#ifndef portCRITICAL_NESTING_IN_TCB

+	#define portCRITICAL_NESTING_IN_TCB 0

+#endif

+

+#ifndef configMAX_TASK_NAME_LEN

+	#define configMAX_TASK_NAME_LEN 16

+#endif

+

+#ifndef configIDLE_SHOULD_YIELD

+	#define configIDLE_SHOULD_YIELD		1

+#endif

+

+#if configMAX_TASK_NAME_LEN < 1

+	#error configMAX_TASK_NAME_LEN must be set to a minimum of 1 in FreeRTOSConfig.h

+#endif

+

+#ifndef INCLUDE_xTaskResumeFromISR

+	#define INCLUDE_xTaskResumeFromISR 1

+#endif

+

+#ifndef configASSERT

+	#define configASSERT( x )

+#endif

+

+#ifndef portALIGNMENT_ASSERT_pxCurrentTCB

+	#define portALIGNMENT_ASSERT_pxCurrentTCB configASSERT

+#endif

+

+/* The timers module relies on xTaskGetSchedulerState(). */

+#if configUSE_TIMERS == 1

+

+	#ifndef configTIMER_TASK_PRIORITY

+		#error If configUSE_TIMERS is set to 1 then configTIMER_TASK_PRIORITY must also be defined.

+	#endif /* configTIMER_TASK_PRIORITY */

+

+	#ifndef configTIMER_QUEUE_LENGTH

+		#error If configUSE_TIMERS is set to 1 then configTIMER_QUEUE_LENGTH must also be defined.

+	#endif /* configTIMER_QUEUE_LENGTH */

+

+	#ifndef configTIMER_TASK_STACK_DEPTH

+		#error If configUSE_TIMERS is set to 1 then configTIMER_TASK_STACK_DEPTH must also be defined.

+	#endif /* configTIMER_TASK_STACK_DEPTH */

+

+#endif /* configUSE_TIMERS */

+

+#ifndef INCLUDE_xTaskGetSchedulerState

+	#define INCLUDE_xTaskGetSchedulerState 0

+#endif

+

+#ifndef INCLUDE_xTaskGetCurrentTaskHandle

+	#define INCLUDE_xTaskGetCurrentTaskHandle 0

+#endif

+

+

+#ifndef portSET_INTERRUPT_MASK_FROM_ISR

+	#define portSET_INTERRUPT_MASK_FROM_ISR() 0

+#endif

+

+#ifndef portCLEAR_INTERRUPT_MASK_FROM_ISR

+	#define portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedStatusValue ) ( void ) uxSavedStatusValue

+#endif

+

+#ifndef portCLEAN_UP_TCB

+	#define portCLEAN_UP_TCB( pxTCB ) ( void ) pxTCB

+#endif

+

+#ifndef portSETUP_TCB

+	#define portSETUP_TCB( pxTCB ) ( void ) pxTCB

+#endif

+

+#ifndef configQUEUE_REGISTRY_SIZE

+	#define configQUEUE_REGISTRY_SIZE 0U

+#endif

+

+#if ( configQUEUE_REGISTRY_SIZE < 1 )

+	#define vQueueAddToRegistry( xQueue, pcName )

+	#define vQueueUnregisterQueue( xQueue )

+#endif

+

+#ifndef portPOINTER_SIZE_TYPE

+	#define portPOINTER_SIZE_TYPE unsigned long

+#endif

+

+/* Remove any unused trace macros. */

+#ifndef traceSTART

+	/* Used to perform any necessary initialisation - for example, open a file

+	into which trace is to be written. */

+	#define traceSTART()

+#endif

+

+#ifndef traceEND

+	/* Use to close a trace, for example close a file into which trace has been

+	written. */

+	#define traceEND()

+#endif

+

+#ifndef traceTASK_SWITCHED_IN

+	/* Called after a task has been selected to run.  pxCurrentTCB holds a pointer

+	to the task control block of the selected task. */

+	#define traceTASK_SWITCHED_IN()

+#endif

+

+#ifndef traceTASK_SWITCHED_OUT

+	/* Called before a task has been selected to run.  pxCurrentTCB holds a pointer

+	to the task control block of the task being switched out. */

+	#define traceTASK_SWITCHED_OUT()

+#endif

+

+#ifndef traceTASK_PRIORITY_INHERIT

+	/* Called when a task attempts to take a mutex that is already held by a

+	lower priority task.  pxTCBOfMutexHolder is a pointer to the TCB of the task

+	that holds the mutex.  uxInheritedPriority is the priority the mutex holder

+	will inherit (the priority of the task that is attempting to obtain the

+	muted. */

+	#define traceTASK_PRIORITY_INHERIT( pxTCBOfMutexHolder, uxInheritedPriority )

+#endif

+

+#ifndef traceTASK_PRIORITY_DISINHERIT

+	/* Called when a task releases a mutex, the holding of which had resulted in

+	the task inheriting the priority of a higher priority task.  

+	pxTCBOfMutexHolder is a pointer to the TCB of the task that is releasing the

+	mutex.  uxOriginalPriority is the task's configured (base) priority. */

+	#define traceTASK_PRIORITY_DISINHERIT( pxTCBOfMutexHolder, uxOriginalPriority )

+#endif

+

+#ifndef traceBLOCKING_ON_QUEUE_RECEIVE

+	/* Task is about to block because it cannot read from a

+	queue/mutex/semaphore.  pxQueue is a pointer to the queue/mutex/semaphore

+	upon which the read was attempted.  pxCurrentTCB points to the TCB of the

+	task that attempted the read. */

+	#define traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue )

+#endif

+

+#ifndef traceBLOCKING_ON_QUEUE_SEND

+	/* Task is about to block because it cannot write to a

+	queue/mutex/semaphore.  pxQueue is a pointer to the queue/mutex/semaphore

+	upon which the write was attempted.  pxCurrentTCB points to the TCB of the

+	task that attempted the write. */

+	#define traceBLOCKING_ON_QUEUE_SEND( pxQueue )

+#endif

+

+#ifndef configCHECK_FOR_STACK_OVERFLOW

+	#define configCHECK_FOR_STACK_OVERFLOW 0

+#endif

+

+/* The following event macros are embedded in the kernel API calls. */

+

+#ifndef traceMOVED_TASK_TO_READY_STATE

+	#define traceMOVED_TASK_TO_READY_STATE( pxTCB )

+#endif

+

+#ifndef traceQUEUE_CREATE	

+	#define traceQUEUE_CREATE( pxNewQueue )

+#endif

+

+#ifndef traceQUEUE_CREATE_FAILED

+	#define traceQUEUE_CREATE_FAILED( ucQueueType )

+#endif

+

+#ifndef traceCREATE_MUTEX

+	#define traceCREATE_MUTEX( pxNewQueue )

+#endif

+

+#ifndef traceCREATE_MUTEX_FAILED

+	#define traceCREATE_MUTEX_FAILED()

+#endif

+

+#ifndef traceGIVE_MUTEX_RECURSIVE

+	#define traceGIVE_MUTEX_RECURSIVE( pxMutex )

+#endif

+

+#ifndef traceGIVE_MUTEX_RECURSIVE_FAILED

+	#define traceGIVE_MUTEX_RECURSIVE_FAILED( pxMutex )

+#endif

+

+#ifndef traceTAKE_MUTEX_RECURSIVE

+	#define traceTAKE_MUTEX_RECURSIVE( pxMutex )

+#endif

+

+#ifndef traceTAKE_MUTEX_RECURSIVE_FAILED

+	#define traceTAKE_MUTEX_RECURSIVE_FAILED( pxMutex )

+#endif

+

+#ifndef traceCREATE_COUNTING_SEMAPHORE

+	#define traceCREATE_COUNTING_SEMAPHORE()

+#endif

+

+#ifndef traceCREATE_COUNTING_SEMAPHORE_FAILED

+	#define traceCREATE_COUNTING_SEMAPHORE_FAILED()

+#endif

+

+#ifndef traceQUEUE_SEND

+	#define traceQUEUE_SEND( pxQueue )

+#endif

+

+#ifndef traceQUEUE_SEND_FAILED

+	#define traceQUEUE_SEND_FAILED( pxQueue )

+#endif

+

+#ifndef traceQUEUE_RECEIVE

+	#define traceQUEUE_RECEIVE( pxQueue )

+#endif

+

+#ifndef traceQUEUE_PEEK

+	#define traceQUEUE_PEEK( pxQueue )

+#endif

+

+#ifndef traceQUEUE_RECEIVE_FAILED

+	#define traceQUEUE_RECEIVE_FAILED( pxQueue )

+#endif

+

+#ifndef traceQUEUE_SEND_FROM_ISR

+	#define traceQUEUE_SEND_FROM_ISR( pxQueue )

+#endif

+

+#ifndef traceQUEUE_SEND_FROM_ISR_FAILED

+	#define traceQUEUE_SEND_FROM_ISR_FAILED( pxQueue )

+#endif

+

+#ifndef traceQUEUE_RECEIVE_FROM_ISR

+	#define traceQUEUE_RECEIVE_FROM_ISR( pxQueue )

+#endif

+

+#ifndef traceQUEUE_RECEIVE_FROM_ISR_FAILED

+	#define traceQUEUE_RECEIVE_FROM_ISR_FAILED( pxQueue )

+#endif

+

+#ifndef traceQUEUE_DELETE

+	#define traceQUEUE_DELETE( pxQueue )

+#endif

+

+#ifndef traceTASK_CREATE

+	#define traceTASK_CREATE( pxNewTCB )

+#endif

+

+#ifndef traceTASK_CREATE_FAILED

+	#define traceTASK_CREATE_FAILED()

+#endif

+

+#ifndef traceTASK_DELETE

+	#define traceTASK_DELETE( pxTaskToDelete )

+#endif

+

+#ifndef traceTASK_DELAY_UNTIL

+	#define traceTASK_DELAY_UNTIL()

+#endif

+

+#ifndef traceTASK_DELAY

+	#define traceTASK_DELAY()

+#endif

+

+#ifndef traceTASK_PRIORITY_SET

+	#define traceTASK_PRIORITY_SET( pxTask, uxNewPriority )

+#endif

+

+#ifndef traceTASK_SUSPEND

+	#define traceTASK_SUSPEND( pxTaskToSuspend )

+#endif

+

+#ifndef traceTASK_RESUME

+	#define traceTASK_RESUME( pxTaskToResume )

+#endif

+

+#ifndef traceTASK_RESUME_FROM_ISR

+	#define traceTASK_RESUME_FROM_ISR( pxTaskToResume )

+#endif

+

+#ifndef traceTASK_INCREMENT_TICK

+	#define traceTASK_INCREMENT_TICK( xTickCount )

+#endif

+

+#ifndef traceTIMER_CREATE

+	#define traceTIMER_CREATE( pxNewTimer )

+#endif

+

+#ifndef traceTIMER_CREATE_FAILED

+	#define traceTIMER_CREATE_FAILED()

+#endif

+

+#ifndef traceTIMER_COMMAND_SEND

+	#define traceTIMER_COMMAND_SEND( xTimer, xMessageID, xMessageValueValue, xReturn )

+#endif

+

+#ifndef traceTIMER_EXPIRED

+	#define traceTIMER_EXPIRED( pxTimer )

+#endif

+

+#ifndef traceTIMER_COMMAND_RECEIVED

+	#define traceTIMER_COMMAND_RECEIVED( pxTimer, xMessageID, xMessageValue )

+#endif

+

+#ifndef configGENERATE_RUN_TIME_STATS

+	#define configGENERATE_RUN_TIME_STATS 0

+#endif

+

+#if ( configGENERATE_RUN_TIME_STATS == 1 )

+

+	#ifndef portCONFIGURE_TIMER_FOR_RUN_TIME_STATS

+		#error If configGENERATE_RUN_TIME_STATS is defined then portCONFIGURE_TIMER_FOR_RUN_TIME_STATS must also be defined.  portCONFIGURE_TIMER_FOR_RUN_TIME_STATS should call a port layer function to setup a peripheral timer/counter that can then be used as the run time counter time base.

+	#endif /* portCONFIGURE_TIMER_FOR_RUN_TIME_STATS */

+

+	#ifndef portGET_RUN_TIME_COUNTER_VALUE

+		#ifndef portALT_GET_RUN_TIME_COUNTER_VALUE

+			#error If configGENERATE_RUN_TIME_STATS is defined then either portGET_RUN_TIME_COUNTER_VALUE or portALT_GET_RUN_TIME_COUNTER_VALUE must also be defined.  See the examples provided and the FreeRTOS web site for more information.

+		#endif /* portALT_GET_RUN_TIME_COUNTER_VALUE */

+	#endif /* portGET_RUN_TIME_COUNTER_VALUE */

+

+#endif /* configGENERATE_RUN_TIME_STATS */

+

+#ifndef portCONFIGURE_TIMER_FOR_RUN_TIME_STATS

+	#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS()

+#endif

+

+#ifndef configUSE_MALLOC_FAILED_HOOK

+	#define configUSE_MALLOC_FAILED_HOOK 0

+#endif

+

+#ifndef portPRIVILEGE_BIT

+	#define portPRIVILEGE_BIT ( ( unsigned portBASE_TYPE ) 0x00 )

+#endif

+

+#ifndef portYIELD_WITHIN_API

+	#define portYIELD_WITHIN_API portYIELD

+#endif

+

+#ifndef pvPortMallocAligned

+	#define pvPortMallocAligned( x, puxStackBuffer ) ( ( ( puxStackBuffer ) == NULL ) ? ( pvPortMalloc( ( x ) ) ) : ( puxStackBuffer ) )

+#endif

+

+#ifndef vPortFreeAligned

+	#define vPortFreeAligned( pvBlockToFree ) vPortFree( pvBlockToFree )

+#endif

+

+#endif /* INC_FREERTOS_H */

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/include/StackMacros.h b/FreeRTOSV7.2.0/FreeRTOS/Source/include/StackMacros.h
new file mode 100644
index 0000000..daf3ce4
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/include/StackMacros.h
@@ -0,0 +1,181 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+#ifndef STACK_MACROS_H

+#define STACK_MACROS_H

+

+/*

+ * Call the stack overflow hook function if the stack of the task being swapped

+ * out is currently overflowed, or looks like it might have overflowed in the

+ * past.

+ *

+ * Setting configCHECK_FOR_STACK_OVERFLOW to 1 will cause the macro to check

+ * the current stack state only - comparing the current top of stack value to

+ * the stack limit.  Setting configCHECK_FOR_STACK_OVERFLOW to greater than 1

+ * will also cause the last few stack bytes to be checked to ensure the value

+ * to which the bytes were set when the task was created have not been

+ * overwritten.  Note this second test does not guarantee that an overflowed

+ * stack will always be recognised.

+ */

+

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

+

+#if( configCHECK_FOR_STACK_OVERFLOW == 0 )

+

+	/* FreeRTOSConfig.h is not set to check for stack overflows. */

+	#define taskFIRST_CHECK_FOR_STACK_OVERFLOW()

+	#define taskSECOND_CHECK_FOR_STACK_OVERFLOW()

+

+#endif /* configCHECK_FOR_STACK_OVERFLOW == 0 */

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

+

+#if( configCHECK_FOR_STACK_OVERFLOW == 1 )

+

+	/* FreeRTOSConfig.h is only set to use the first method of

+	overflow checking. */

+	#define taskSECOND_CHECK_FOR_STACK_OVERFLOW()

+

+#endif

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

+

+#if( ( configCHECK_FOR_STACK_OVERFLOW > 0 ) && ( portSTACK_GROWTH < 0 ) )

+

+	/* Only the current stack state is to be checked. */

+	#define taskFIRST_CHECK_FOR_STACK_OVERFLOW()														\

+	{																									\

+		/* Is the currently saved stack pointer within the stack limit? */								\

+		if( pxCurrentTCB->pxTopOfStack <= pxCurrentTCB->pxStack )										\

+		{																								\

+			vApplicationStackOverflowHook( ( xTaskHandle ) pxCurrentTCB, pxCurrentTCB->pcTaskName );	\

+		}																								\

+	}

+

+#endif /* configCHECK_FOR_STACK_OVERFLOW > 0 */

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

+

+#if( ( configCHECK_FOR_STACK_OVERFLOW > 0 ) && ( portSTACK_GROWTH > 0 ) )

+

+	/* Only the current stack state is to be checked. */

+	#define taskFIRST_CHECK_FOR_STACK_OVERFLOW()														\

+	{																									\

+																										\

+		/* Is the currently saved stack pointer within the stack limit? */								\

+		if( pxCurrentTCB->pxTopOfStack >= pxCurrentTCB->pxEndOfStack )									\

+		{																								\

+			vApplicationStackOverflowHook( ( xTaskHandle ) pxCurrentTCB, pxCurrentTCB->pcTaskName );	\

+		}																								\

+	}

+

+#endif /* configCHECK_FOR_STACK_OVERFLOW == 1 */

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

+

+#if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) && ( portSTACK_GROWTH < 0 ) )

+

+	#define taskSECOND_CHECK_FOR_STACK_OVERFLOW()																								\

+	{																																			\

+	static const unsigned char ucExpectedStackBytes[] = {	tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,		\

+															tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,		\

+															tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,		\

+															tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,		\

+															tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE };	\

+																																				\

+																																				\

+		/* Has the extremity of the task stack ever been written over? */																		\

+		if( memcmp( ( void * ) pxCurrentTCB->pxStack, ( void * ) ucExpectedStackBytes, sizeof( ucExpectedStackBytes ) ) != 0 )					\

+		{																																		\

+			vApplicationStackOverflowHook( ( xTaskHandle ) pxCurrentTCB, pxCurrentTCB->pcTaskName );											\

+		}																																		\

+	}

+

+#endif /* #if( configCHECK_FOR_STACK_OVERFLOW > 1 ) */

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

+

+#if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) && ( portSTACK_GROWTH > 0 ) )

+

+	#define taskSECOND_CHECK_FOR_STACK_OVERFLOW()																								\

+	{																																			\

+	char *pcEndOfStack = ( char * ) pxCurrentTCB->pxEndOfStack;																					\

+	static const unsigned char ucExpectedStackBytes[] = {	tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,		\

+															tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,		\

+															tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,		\

+															tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE,		\

+															tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE, tskSTACK_FILL_BYTE };	\

+																																				\

+																																				\

+		pcEndOfStack -= sizeof( ucExpectedStackBytes );																							\

+																																				\

+		/* Has the extremity of the task stack ever been written over? */																		\

+		if( memcmp( ( void * ) pcEndOfStack, ( void * ) ucExpectedStackBytes, sizeof( ucExpectedStackBytes ) ) != 0 )							\

+		{																																		\

+			vApplicationStackOverflowHook( ( xTaskHandle ) pxCurrentTCB, pxCurrentTCB->pcTaskName );											\

+		}																																		\

+	}

+

+#endif /* #if( configCHECK_FOR_STACK_OVERFLOW > 1 ) */

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

+

+#endif /* STACK_MACROS_H */

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/include/croutine.h b/FreeRTOSV7.2.0/FreeRTOS/Source/include/croutine.h
new file mode 100644
index 0000000..f2843cd
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/include/croutine.h
@@ -0,0 +1,759 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+#ifndef CO_ROUTINE_H

+#define CO_ROUTINE_H

+

+#ifndef INC_FREERTOS_H

+	#error "include FreeRTOS.h must appear in source files before include croutine.h"

+#endif

+

+#include "list.h"

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+/* 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 short 		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 uxFlashRates[ 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 long 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 long 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 );

+

+        if( xResult != pdPASS )

+        {

+            // The message was not posted!

+        }

+

+        // Increment the number to be posted onto the queue.

+        xNumberToPost++;

+

+        // Delay for 100 ticks.

+        crDELAY( xHandle, 100 );

+    }

+

+    // Co-routines must end with a call to crEND().

+    crEND();

+ }</pre>

+ * \defgroup crQUEUE_SEND crQUEUE_SEND

+ * \ingroup Tasks

+ */

+#define crQUEUE_SEND( xHandle, pxQueue, pvItemToQueue, xTicksToWait, pxResult )			\

+{																						\

+	*( pxResult ) = xQueueCRSend( ( pxQueue) , ( pvItemToQueue) , ( xTicksToWait ) );	\

+	if( *( pxResult ) == errQUEUE_BLOCKED )												\

+	{																					\

+		crSET_STATE0( ( xHandle ) );													\

+		*pxResult = xQueueCRSend( ( pxQueue ), ( pvItemToQueue ), 0 );					\

+	}																					\

+	if( *pxResult == errQUEUE_YIELD )													\

+	{																					\

+		crSET_STATE1( ( xHandle ) );													\

+		*pxResult = pdPASS;																\

+	}																					\

+}

+

+/**

+ * croutine. h

+ * <pre>

+  crQUEUE_RECEIVE(

+                     xCoRoutineHandle xHandle,

+                     xQueueHandle pxQueue,

+                     void *pvBuffer,

+                     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_RECEIVE 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 from which the data will be received.

+ * The handle is obtained as the return value when the queue is created using

+ * the xQueueCreate() API function.

+ *

+ * @param pvBuffer The buffer into which the received item is to be copied.

+ * The number of bytes of each queued item is specified when the queue is

+ * created.  This number of bytes is copied into pvBuffer.

+ *

+ * @param xTickToDelay The number of ticks that the co-routine should block

+ * to wait for data to become available from the queue, should data 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 the

+ * crQUEUE_SEND example).

+ *

+ * @param pxResult The variable pointed to by pxResult will be set to pdPASS if

+ * data was successfully retrieved from the queue, otherwise it will be set to

+ * an error code as defined within ProjDefs.h.

+ *

+ * Example usage:

+ <pre>

+ // A co-routine receives the number of an LED to flash from a queue.  It

+ // blocks on the queue until the number is received.

+ static void prvCoRoutineFlashWorkTask( 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 xResult;

+ static unsigned portBASE_TYPE uxLEDToFlash;

+

+    // All co-routines must start with a call to crSTART().

+    crSTART( xHandle );

+

+    for( ;; )

+    {

+        // Wait for data to become available on the queue.

+        crQUEUE_RECEIVE( xHandle, xCoRoutineQueue, &uxLEDToFlash, portMAX_DELAY, &xResult );

+

+        if( xResult == pdPASS )

+        {

+            // We received the LED to flash - flash it!

+            vParTestToggleLED( uxLEDToFlash );

+        }

+    }

+

+    crEND();

+ }</pre>

+ * \defgroup crQUEUE_RECEIVE crQUEUE_RECEIVE

+ * \ingroup Tasks

+ */

+#define crQUEUE_RECEIVE( xHandle, pxQueue, pvBuffer, xTicksToWait, pxResult )			\

+{																						\

+	*( pxResult ) = xQueueCRReceive( ( pxQueue) , ( pvBuffer ), ( xTicksToWait ) );		\

+	if( *( pxResult ) == errQUEUE_BLOCKED ) 											\

+	{																					\

+		crSET_STATE0( ( xHandle ) );													\

+		*( pxResult ) = xQueueCRReceive( ( pxQueue) , ( pvBuffer ), 0 );				\

+	}																					\

+	if( *( pxResult ) == errQUEUE_YIELD )												\

+	{																					\

+		crSET_STATE1( ( xHandle ) );													\

+		*( pxResult ) = pdPASS;															\

+	}																					\

+}

+

+/**

+ * croutine. h

+ * <pre>

+  crQUEUE_SEND_FROM_ISR(

+                            xQueueHandle pxQueue,

+                            void *pvItemToQueue,

+                            portBASE_TYPE xCoRoutinePreviouslyWoken

+                       )</pre>

+ *

+ * The macro's crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() are the

+ * co-routine equivalent to the xQueueSendFromISR() and xQueueReceiveFromISR()

+ * functions used by tasks.

+ *

+ * crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() can only be used to

+ * pass data between a co-routine and and ISR, whereas xQueueSendFromISR() and

+ * xQueueReceiveFromISR() can only be used to pass data between a task and and

+ * ISR.

+ *

+ * crQUEUE_SEND_FROM_ISR can only be called from an ISR to send data to a queue

+ * that is being used from within a co-routine.

+ *

+ * 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 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 xCoRoutinePreviouslyWoken This is included so an ISR can post onto

+ * the same queue multiple times from a single interrupt.  The first call

+ * should always pass in pdFALSE.  Subsequent calls should pass in

+ * the value returned from the previous call.

+ *

+ * @return pdTRUE if a co-routine was woken by posting onto the queue.  This is

+ * used by the ISR to determine if a context switch may be required following

+ * the ISR.

+ *

+ * Example usage:

+ <pre>

+ // A co-routine that blocks on a queue waiting for characters to be received.

+ static void vReceivingCoRoutine( xCoRoutineHandle xHandle, unsigned portBASE_TYPE uxIndex )

+ {

+ char cRxedChar;

+ portBASE_TYPE xResult;

+

+     // All co-routines must start with a call to crSTART().

+     crSTART( xHandle );

+

+     for( ;; )

+     {

+         // Wait for data to become available on the queue.  This assumes the

+         // queue xCommsRxQueue has already been created!

+         crQUEUE_RECEIVE( xHandle, xCommsRxQueue, &uxLEDToFlash, portMAX_DELAY, &xResult );

+

+         // Was a character received?

+         if( xResult == pdPASS )

+         {

+             // Process the character here.

+         }

+     }

+

+     // All co-routines must end with a call to crEND().

+     crEND();

+ }

+

+ // An ISR that uses a queue to send characters received on a serial port to

+ // a co-routine.

+ void vUART_ISR( void )

+ {

+ char cRxedChar;

+ portBASE_TYPE xCRWokenByPost = pdFALSE;

+

+     // We loop around reading characters until there are none left in the UART.

+     while( UART_RX_REG_NOT_EMPTY() )

+     {

+         // Obtain the character from the UART.

+         cRxedChar = UART_RX_REG;

+

+         // Post the character onto a queue.  xCRWokenByPost will be pdFALSE

+         // the first time around the loop.  If the post causes a co-routine

+         // to be woken (unblocked) then xCRWokenByPost will be set to pdTRUE.

+         // In this manner we can ensure that if more than one co-routine is

+         // blocked on the queue only one is woken by this ISR no matter how

+         // many characters are posted to the queue.

+         xCRWokenByPost = crQUEUE_SEND_FROM_ISR( xCommsRxQueue, &cRxedChar, xCRWokenByPost );

+     }

+ }</pre>

+ * \defgroup crQUEUE_SEND_FROM_ISR crQUEUE_SEND_FROM_ISR

+ * \ingroup Tasks

+ */

+#define crQUEUE_SEND_FROM_ISR( pxQueue, pvItemToQueue, xCoRoutinePreviouslyWoken ) xQueueCRSendFromISR( ( pxQueue ), ( pvItemToQueue ), ( xCoRoutinePreviouslyWoken ) )

+

+

+/**

+ * croutine. h

+ * <pre>

+  crQUEUE_SEND_FROM_ISR(

+                            xQueueHandle pxQueue,

+                            void *pvBuffer,

+                            portBASE_TYPE * pxCoRoutineWoken

+                       )</pre>

+ *

+ * The macro's crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() are the

+ * co-routine equivalent to the xQueueSendFromISR() and xQueueReceiveFromISR()

+ * functions used by tasks.

+ *

+ * crQUEUE_SEND_FROM_ISR() and crQUEUE_RECEIVE_FROM_ISR() can only be used to

+ * pass data between a co-routine and and ISR, whereas xQueueSendFromISR() and

+ * xQueueReceiveFromISR() can only be used to pass data between a task and and

+ * ISR.

+ *

+ * crQUEUE_RECEIVE_FROM_ISR can only be called from an ISR to receive data

+ * from a queue that is being used from within a co-routine (a co-routine

+ * posted to the queue).

+ *

+ * 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 xQueue The handle to the queue on which the item is to be posted.

+ *

+ * @param pvBuffer A pointer to a buffer into which the received item will be

+ * placed.  The size of the items the queue will hold was defined when the

+ * queue was created, so this many bytes will be copied from the queue into

+ * pvBuffer.

+ *

+ * @param pxCoRoutineWoken A co-routine may be blocked waiting for space to become

+ * available on the queue.  If crQUEUE_RECEIVE_FROM_ISR causes such a

+ * co-routine to unblock *pxCoRoutineWoken will get set to pdTRUE, otherwise

+ * *pxCoRoutineWoken will remain unchanged.

+ *

+ * @return pdTRUE an item was successfully received from the queue, otherwise

+ * pdFALSE.

+ *

+ * Example usage:

+ <pre>

+ // A co-routine that posts a character to a queue then blocks for a fixed

+ // period.  The character is incremented each time.

+ static void vSendingCoRoutine( xCoRoutineHandle xHandle, unsigned portBASE_TYPE uxIndex )

+ {

+ // cChar holds its value while this co-routine is blocked and must therefore

+ // be declared static.

+ static char cCharToTx = 'a';

+ portBASE_TYPE xResult;

+

+     // All co-routines must start with a call to crSTART().

+     crSTART( xHandle );

+

+     for( ;; )

+     {

+         // Send the next character to the queue.

+         crQUEUE_SEND( xHandle, xCoRoutineQueue, &cCharToTx, NO_DELAY, &xResult );

+

+         if( xResult == pdPASS )

+         {

+             // The character was successfully posted to the queue.

+         }

+		 else

+		 {

+			// Could not post the character to the queue.

+		 }

+

+         // Enable the UART Tx interrupt to cause an interrupt in this

+		 // hypothetical UART.  The interrupt will obtain the character

+		 // from the queue and send it.

+		 ENABLE_RX_INTERRUPT();

+

+		 // Increment to the next character then block for a fixed period.

+		 // cCharToTx will maintain its value across the delay as it is

+		 // declared static.

+		 cCharToTx++;

+		 if( cCharToTx > 'x' )

+		 {

+			cCharToTx = 'a';

+		 }

+		 crDELAY( 100 );

+     }

+

+     // All co-routines must end with a call to crEND().

+     crEND();

+ }

+

+ // An ISR that uses a queue to receive characters to send on a UART.

+ void vUART_ISR( void )

+ {

+ char cCharToTx;

+ portBASE_TYPE xCRWokenByPost = pdFALSE;

+

+     while( UART_TX_REG_EMPTY() )

+     {

+         // Are there any characters in the queue waiting to be sent?

+		 // xCRWokenByPost will automatically be set to pdTRUE if a co-routine

+		 // is woken by the post - ensuring that only a single co-routine is

+		 // woken no matter how many times we go around this loop.

+         if( crQUEUE_RECEIVE_FROM_ISR( pxQueue, &cCharToTx, &xCRWokenByPost ) )

+		 {

+			 SEND_CHARACTER( cCharToTx );

+		 }

+     }

+ }</pre>

+ * \defgroup crQUEUE_RECEIVE_FROM_ISR crQUEUE_RECEIVE_FROM_ISR

+ * \ingroup Tasks

+ */

+#define crQUEUE_RECEIVE_FROM_ISR( pxQueue, pvBuffer, pxCoRoutineWoken ) xQueueCRReceiveFromISR( ( pxQueue ), ( pvBuffer ), ( pxCoRoutineWoken ) )

+

+/*

+ * This function is intended for internal use by the co-routine macros only.

+ * The macro nature of the co-routine implementation requires that the

+ * prototype appears here.  The function should not be used by application

+ * writers.

+ *

+ * Removes the current co-routine from its ready list and places it in the

+ * appropriate delayed list.

+ */

+void vCoRoutineAddToDelayedList( portTickType xTicksToDelay, xList *pxEventList );

+

+/*

+ * This function is intended for internal use by the queue implementation only.

+ * The function should not be used by application writers.

+ *

+ * Removes the highest priority co-routine from the event list and places it in

+ * the pending ready list.

+ */

+signed portBASE_TYPE xCoRoutineRemoveFromEventList( const xList *pxEventList );

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif /* CO_ROUTINE_H */

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/include/init.h b/FreeRTOSV7.2.0/FreeRTOS/Source/include/init.h
new file mode 100644
index 0000000..6010967
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/include/init.h
@@ -0,0 +1,21 @@
+
+#ifndef __FREE_RTOS_INIT_H
+#define __FREE_RTOS_INIT_H
+
+#ifndef INC_FREERTOS_H
+	#error "include FreeRTOS.h" must appear in source files before "include queue.h"
+#endif
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+void xInitRTOS(void);
+
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __FREE_RTOS_INIT_H */
+
diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/include/list.h b/FreeRTOSV7.2.0/FreeRTOS/Source/include/list.h
new file mode 100644
index 0000000..28d4f24
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/include/list.h
@@ -0,0 +1,337 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+/*

+ * 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

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+/*

+ * 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 get 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 listGET_LIST_ITEM_OWNER( pxListItem )		( pxListItem )->pvOwner

+

+/*

+ * 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 to 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 the retrieve the value of the list item at the head of a given

+ * list.

+ *

+ * \page listGET_LIST_ITEM_VALUE listGET_LIST_ITEM_VALUE

+ * \ingroup LinkedList

+ */

+#define listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxList )			( (&( ( pxList )->xListEnd ))->pxNext->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.

+ */

+#define listCURRENT_LIST_LENGTH( pxList )		( ( pxList )->uxNumberOfItems )

+

+/*

+ * Access function to obtain the owner of the next entry in a list.

+ *

+ * The list member pxIndex is used to walk through a list.  Calling

+ * listGET_OWNER_OF_NEXT_ENTRY increments pxIndex to the next item in the list

+ * and returns that entries pxOwner parameter.  Using multiple calls to this

+ * function it is therefore possible to move through every item contained in

+ * a list.

+ *

+ * The pxOwner parameter of a list item is a pointer to the object that owns

+ * the list item.  In the scheduler this is normally a task control block.

+ * The pxOwner parameter effectively creates a two way link between the list

+ * item and its owner.

+ *

+ * @param pxList The list from which the next item owner is to be returned.

+ *

+ * \page listGET_OWNER_OF_NEXT_ENTRY listGET_OWNER_OF_NEXT_ENTRY

+ * \ingroup LinkedList

+ */

+#define listGET_OWNER_OF_NEXT_ENTRY( pxTCB, pxList )									\

+{																						\

+xList * const pxConstList = ( pxList );													\

+	/* Increment the index to the next item and return the item, ensuring */			\

+	/* we don't return the marker used at the end of the list.  */						\

+	( pxConstList )->pxIndex = ( pxConstList )->pxIndex->pxNext;						\

+	if( ( pxConstList )->pxIndex == ( xListItem * ) &( ( pxConstList )->xListEnd ) )	\

+	{																					\

+		( pxConstList )->pxIndex = ( pxConstList )->pxIndex->pxNext;					\

+	}																					\

+	( pxTCB ) = ( pxConstList )->pxIndex->pvOwner;										\

+}

+

+

+/*

+ * Access function to obtain the owner of the first entry in a list.  Lists

+ * are normally sorted in ascending item value order.

+ *

+ * This function returns the pxOwner member of the first item in the list.

+ * The pxOwner parameter of a list item is a pointer to the object that owns

+ * the list item.  In the scheduler this is normally a task control block.

+ * The pxOwner parameter effectively creates a two way link between the list

+ * item and its owner.

+ *

+ * @param pxList The list from which the owner of the head item is to be

+ * returned.

+ *

+ * \page listGET_OWNER_OF_HEAD_ENTRY listGET_OWNER_OF_HEAD_ENTRY

+ * \ingroup LinkedList

+ */

+#define listGET_OWNER_OF_HEAD_ENTRY( pxList )  ( (&( ( pxList )->xListEnd ))->pxNext->pvOwner )

+

+/*

+ * Check to see if a list item is within a list.  The list item maintains a

+ * "container" pointer that points to the list it is in.  All this macro does

+ * is check to see if the container and the list match.

+ *

+ * @param pxList The list we want to know if the list item is within.

+ * @param pxListItem The list item we want to know if is in the list.

+ * @return pdTRUE is the list item is in the list, otherwise pdFALSE.

+ * pointer against

+ */

+#define listIS_CONTAINED_WITHIN( pxList, pxListItem ) ( ( pxListItem )->pvContainer == ( void * ) ( pxList ) )

+

+/*

+ * This provides a crude means of knowing if a list has been initialised, as

+ * pxList->xListEnd.xItemValue is set to portMAX_DELAY by the vListInitialise()

+ * function.

+ */

+#define listLIST_IS_INITIALISED( pxList ) ( ( pxList )->xListEnd.xItemValue == portMAX_DELAY )

+

+/*

+ * Must be called before a list is used!  This initialises all the members

+ * of the list structure and inserts the xListEnd item into the list as a

+ * marker to the back of the list.

+ *

+ * @param pxList Pointer to the list being initialised.

+ *

+ * \page vListInitialise vListInitialise

+ * \ingroup LinkedList

+ */

+void vListInitialise( xList *pxList );

+

+/*

+ * Must be called before a list item is used.  This sets the list container to

+ * null so the item does not think that it is already contained in a list.

+ *

+ * @param pxItem Pointer to the list item being initialised.

+ *

+ * \page vListInitialiseItem vListInitialiseItem

+ * \ingroup LinkedList

+ */

+void vListInitialiseItem( xListItem *pxItem );

+

+/*

+ * Insert a list item into a list.  The item will be inserted into the list in

+ * a position determined by its item value (descending item value order).

+ *

+ * @param pxList The list into which the item is to be inserted.

+ *

+ * @param pxNewListItem The item to that is to be placed in the list.

+ *

+ * \page vListInsert vListInsert

+ * \ingroup LinkedList

+ */

+void vListInsert( xList *pxList, xListItem *pxNewListItem );

+

+/*

+ * Insert a list item into a list.  The item will be inserted in a position

+ * such that it will be the last item within the list returned by multiple

+ * calls to listGET_OWNER_OF_NEXT_ENTRY.

+ *

+ * The list member pvIndex is used to walk through a list.  Calling

+ * listGET_OWNER_OF_NEXT_ENTRY increments pvIndex to the next item in the list.

+ * Placing an item in a list using vListInsertEnd effectively places the item

+ * in the list position pointed to by pvIndex.  This means that every other

+ * item within the list will be returned by listGET_OWNER_OF_NEXT_ENTRY before

+ * the pvIndex parameter again points to the item being inserted.

+ *

+ * @param pxList The list into which the item is to be inserted.

+ *

+ * @param pxNewListItem The list item to be inserted into the list.

+ *

+ * \page vListInsertEnd vListInsertEnd

+ * \ingroup LinkedList

+ */

+void vListInsertEnd( xList *pxList, xListItem *pxNewListItem );

+

+/*

+ * Remove an item from a list.  The list item has a pointer to the list that

+ * it is in, so only the list item need be passed into the function.

+ *

+ * @param vListRemove The item to be removed.  The item will remove itself from

+ * the list pointed to by it's pxContainer parameter.

+ *

+ * \page vListRemove vListRemove

+ * \ingroup LinkedList

+ */

+void vListRemove( xListItem *pxItemToRemove );

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/include/mpu_wrappers.h b/FreeRTOSV7.2.0/FreeRTOS/Source/include/mpu_wrappers.h
new file mode 100644
index 0000000..be49c3d
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/include/mpu_wrappers.h
@@ -0,0 +1,146 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+#ifndef MPU_WRAPPERS_H

+#define MPU_WRAPPERS_H

+

+/* This file redefines API functions to be called through a wrapper macro, but

+only for ports that are using the MPU. */

+#ifdef portUSING_MPU_WRAPPERS

+

+	/* MPU_WRAPPERS_INCLUDED_FROM_API_FILE will be defined when this file is

+	included from queue.c or task.c to prevent it from having an effect within

+	those files. */

+	#ifndef MPU_WRAPPERS_INCLUDED_FROM_API_FILE

+

+		#define xTaskGenericCreate				MPU_xTaskGenericCreate

+		#define vTaskAllocateMPURegions			MPU_vTaskAllocateMPURegions

+		#define vTaskDelete						MPU_vTaskDelete

+		#define vTaskDelayUntil					MPU_vTaskDelayUntil

+		#define vTaskDelay						MPU_vTaskDelay

+		#define uxTaskPriorityGet				MPU_uxTaskPriorityGet

+		#define vTaskPrioritySet				MPU_vTaskPrioritySet

+		#define vTaskSuspend					MPU_vTaskSuspend

+		#define xTaskIsTaskSuspended			MPU_xTaskIsTaskSuspended

+		#define vTaskResume						MPU_vTaskResume

+		#define vTaskSuspendAll					MPU_vTaskSuspendAll

+		#define xTaskResumeAll					MPU_xTaskResumeAll

+		#define xTaskGetTickCount				MPU_xTaskGetTickCount

+		#define uxTaskGetNumberOfTasks			MPU_uxTaskGetNumberOfTasks

+		#define vTaskList						MPU_vTaskList

+		#define vTaskGetRunTimeStats			MPU_vTaskGetRunTimeStats

+		#define vTaskSetApplicationTaskTag		MPU_vTaskSetApplicationTaskTag

+		#define xTaskGetApplicationTaskTag		MPU_xTaskGetApplicationTaskTag

+		#define xTaskCallApplicationTaskHook	MPU_xTaskCallApplicationTaskHook

+		#define uxTaskGetStackHighWaterMark		MPU_uxTaskGetStackHighWaterMark

+		#define xTaskGetCurrentTaskHandle		MPU_xTaskGetCurrentTaskHandle

+		#define xTaskGetSchedulerState			MPU_xTaskGetSchedulerState

+

+		#define xQueueGenericCreate				MPU_xQueueGenericCreate

+		#define xQueueCreateMutex				MPU_xQueueCreateMutex

+		#define xQueueGiveMutexRecursive		MPU_xQueueGiveMutexRecursive

+		#define xQueueTakeMutexRecursive		MPU_xQueueTakeMutexRecursive

+		#define xQueueCreateCountingSemaphore	MPU_xQueueCreateCountingSemaphore

+		#define xQueueGenericSend				MPU_xQueueGenericSend

+		#define xQueueAltGenericSend			MPU_xQueueAltGenericSend

+		#define xQueueAltGenericReceive			MPU_xQueueAltGenericReceive

+		#define xQueueGenericReceive			MPU_xQueueGenericReceive

+		#define uxQueueMessagesWaiting			MPU_uxQueueMessagesWaiting

+		#define vQueueDelete					MPU_vQueueDelete

+

+		#define pvPortMalloc					MPU_pvPortMalloc

+		#define vPortFree						MPU_vPortFree

+		#define xPortGetFreeHeapSize			MPU_xPortGetFreeHeapSize

+		#define vPortInitialiseBlocks			MPU_vPortInitialiseBlocks

+

+		#if configQUEUE_REGISTRY_SIZE > 0

+			#define vQueueAddToRegistry				MPU_vQueueAddToRegistry

+			#define vQueueUnregisterQueue			MPU_vQueueUnregisterQueue

+		#endif

+

+		/* Remove the privileged function macro. */

+		#define PRIVILEGED_FUNCTION

+

+	#else /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */

+

+		/* Ensure API functions go in the privileged execution section. */

+		#define PRIVILEGED_FUNCTION __attribute__((section("privileged_functions")))

+		#define PRIVILEGED_DATA __attribute__((section("privileged_data")))

+        //#define PRIVILEGED_DATA

+

+	#endif /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */

+

+#else /* portUSING_MPU_WRAPPERS */

+

+	#define PRIVILEGED_FUNCTION

+	#define PRIVILEGED_DATA

+	#define portUSING_MPU_WRAPPERS 0

+

+#endif /* portUSING_MPU_WRAPPERS */

+

+

+#endif /* MPU_WRAPPERS_H */

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/include/portable.h b/FreeRTOSV7.2.0/FreeRTOS/Source/include/portable.h
new file mode 100644
index 0000000..88cfbb2
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/include/portable.h
@@ -0,0 +1,403 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

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

+ * 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_PIC24_PORT

+	#include "..\..\Source\portable\MPLAB\PIC24_dsPIC\portmacro.h"

+#endif

+

+#ifdef MPLAB_DSPIC_PORT

+	#include "..\..\Source\portable\MPLAB\PIC24_dsPIC\portmacro.h"

+#endif

+

+#ifdef MPLAB_PIC18F_PORT

+	#include "..\..\Source\portable\MPLAB\PIC18F\portmacro.h"

+#endif

+

+#ifdef MPLAB_PIC32MX_PORT

+	#include "..\..\Source\portable\MPLAB\PIC32MX\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_ARM7_ECLIPSE

+	#include "portmacro.h"

+#endif

+

+#ifdef ROWLEY_LPC23xx

+	#include "../../Source/portable/GCC/ARM7_LPC23xx/portmacro.h"

+#endif

+

+#ifdef IAR_MSP430

+	#include "..\..\Source\portable\IAR\MSP430\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 ARM7_LPC21xx_KEIL_RVDS

+	#include "..\..\Source\portable\RVDS\ARM7_LPC21xx\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 SAM9XE_IAR

+	#include "..\..\Source\portable\IAR\AtmelSAM9XE\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 STR75X_IAR

+	#include "..\..\Source\portable\IAR\STR75x\portmacro.h"

+#endif

+	

+#ifdef STR75X_GCC

+	#include "..\..\Source\portable\GCC\STR75x\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 GCC_ARMCM3

+	#include "../../Source/portable/GCC/ARM_CM3/portmacro.h"

+#endif

+

+#ifdef IAR_ARM_CM3

+	#include "../../Source/portable/IAR/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_MCF5235

+    #include "../../Source/portable/GCC/MCF5235/portmacro.h"

+#endif

+

+#ifdef COLDFIRE_V2_GCC

+	#include "../../../Source/portable/GCC/ColdFire_V2/portmacro.h"

+#endif

+

+#ifdef COLDFIRE_V2_CODEWARRIOR

+	#include "../../Source/portable/CodeWarrior/ColdFire_V2/portmacro.h"

+#endif

+

+#ifdef GCC_PPC405

+	#include "../../Source/portable/GCC/PPC405_Xilinx/portmacro.h"

+#endif

+

+#ifdef GCC_PPC440

+	#include "../../Source/portable/GCC/PPC440_Xilinx/portmacro.h"

+#endif

+

+#ifdef _16FX_SOFTUNE

+	#include "..\..\Source\portable\Softune\MB96340\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

+

+#ifdef __GNUC__

+   #ifdef __AVR32_AVR32A__

+	   #include "portmacro.h"

+   #endif

+#endif

+

+#ifdef __ICCAVR32__

+   #ifdef __CORE__

+      #if __CORE__ == __AVR32A__

+	      #include "portmacro.h"

+      #endif

+   #endif

+#endif

+

+#ifdef __91467D

+	#include "portmacro.h"

+#endif

+

+#ifdef __96340

+	#include "portmacro.h"

+#endif

+

+

+#ifdef __IAR_V850ES_Fx3__

+	#include "../../Source/portable/IAR/V850ES/portmacro.h"

+#endif

+

+#ifdef __IAR_V850ES_Jx3__

+	#include "../../Source/portable/IAR/V850ES/portmacro.h"

+#endif

+

+#ifdef __IAR_V850ES_Jx3_L__

+	#include "../../Source/portable/IAR/V850ES/portmacro.h"

+#endif

+

+#ifdef __IAR_V850ES_Jx2__

+	#include "../../Source/portable/IAR/V850ES/portmacro.h"

+#endif

+

+#ifdef __IAR_V850ES_Hx2__

+	#include "../../Source/portable/IAR/V850ES/portmacro.h"

+#endif

+

+#ifdef __IAR_78K0R_Kx3__

+	#include "../../Source/portable/IAR/78K0R/portmacro.h"

+#endif

+	

+#ifdef __IAR_78K0R_Kx3L__

+	#include "../../Source/portable/IAR/78K0R/portmacro.h"

+#endif

+	

+/* Catch all to ensure portmacro.h is included in the build.  Newer demos

+have the path as part of the project options, rather than as relative from

+the project location.  If portENTER_CRITICAL() has not been defined then

+portmacro.h has not yet been included - as every portmacro.h provides a

+portENTER_CRITICAL() definition.  Check the demo application for your demo

+to find the path to the correct portmacro.h file. */

+#ifndef portENTER_CRITICAL

+	#include "portmacro.h"	

+#endif

+	

+#if portBYTE_ALIGNMENT == 8

+	#define portBYTE_ALIGNMENT_MASK ( 0x0007 )

+#endif

+

+#if portBYTE_ALIGNMENT == 4

+	#define portBYTE_ALIGNMENT_MASK	( 0x0003 )

+#endif

+

+#if portBYTE_ALIGNMENT == 2

+	#define portBYTE_ALIGNMENT_MASK	( 0x0001 )

+#endif

+

+#if portBYTE_ALIGNMENT == 1

+	#define portBYTE_ALIGNMENT_MASK	( 0x0000 )

+#endif

+

+#ifndef portBYTE_ALIGNMENT_MASK

+	#error "Invalid portBYTE_ALIGNMENT definition"

+#endif

+

+#ifndef portNUM_CONFIGURABLE_REGIONS

+	#define portNUM_CONFIGURABLE_REGIONS 1

+#endif

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+#include "mpu_wrappers.h"

+

+/*

+ * 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.

+ *

+ */

+#if( portUSING_MPU_WRAPPERS == 1 )

+	portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE *pxTopOfStack, pdTASK_CODE pxCode, void *pvParameters, portBASE_TYPE xRunPrivileged ) PRIVILEGED_FUNCTION;

+#else

+	portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE *pxTopOfStack, pdTASK_CODE pxCode, void *pvParameters );

+#endif

+

+/*

+ * Map to the memory management routines required for the port.

+ */

+void *pvPortMalloc( size_t xSize ) PRIVILEGED_FUNCTION;

+void vPortFree( void *pv ) PRIVILEGED_FUNCTION;

+void vPortInitialiseBlocks( void ) PRIVILEGED_FUNCTION;

+size_t xPortGetFreeHeapSize( void ) PRIVILEGED_FUNCTION;

+

+/*

+ * 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 ) PRIVILEGED_FUNCTION;

+

+/*

+ * 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 ) PRIVILEGED_FUNCTION;

+

+/*

+ * The structures and methods of manipulating the MPU are contained within the

+ * port layer.

+ *

+ * Fills the xMPUSettings structure with the memory region information

+ * contained in xRegions.

+ */

+#if( portUSING_MPU_WRAPPERS == 1 ) 

+	struct xMEMORY_REGION;

+	void vPortStoreTaskMPUSettings( xMPU_SETTINGS *xMPUSettings, const struct xMEMORY_REGION * const xRegions, portSTACK_TYPE *pxBottomOfStack, unsigned short usStackDepth ) PRIVILEGED_FUNCTION;

+#endif

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif /* PORTABLE_H */

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/include/projdefs.h b/FreeRTOSV7.2.0/FreeRTOS/Source/include/projdefs.h
new file mode 100644
index 0000000..c69db92
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/include/projdefs.h
@@ -0,0 +1,90 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+#ifndef PROJDEFS_H

+#define PROJDEFS_H

+

+/* Defines the prototype to which task functions must conform. */

+typedef void (*pdTASK_CODE)( void * );

+

+#define pdTRUE		( 1 )

+#define pdFALSE		( 0 )

+

+#define pdPASS									( 1 )

+#define pdFAIL									( 0 )

+#define errQUEUE_EMPTY							( 0 )

+#define errQUEUE_FULL							( 0 )

+

+/* Error definitions. */

+#define errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY	( -1 )

+#define errNO_TASK_TO_RUN						( -2 )

+#define errQUEUE_BLOCKED						( -4 )

+#define errQUEUE_YIELD							( -5 )

+

+#endif /* PROJDEFS_H */

+

+

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/include/queue.h b/FreeRTOSV7.2.0/FreeRTOS/Source/include/queue.h
new file mode 100644
index 0000000..c3efc64
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/include/queue.h
@@ -0,0 +1,1302 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+

+#ifndef QUEUE_H

+#define QUEUE_H

+

+#ifndef INC_FREERTOS_H

+	#error "include FreeRTOS.h" must appear in source files before "include queue.h"

+#endif

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+

+#include "mpu_wrappers.h"

+

+/**

+ * Type by which queues are referenced.  For example, a call to xQueueCreate

+ * returns (via a pointer parameter) an xQueueHandle variable that can then

+ * be used as a parameter to xQueueSend(), xQueueReceive(), etc.

+ */

+typedef void * xQueueHandle;

+

+

+/* For internal use only. */

+#define	queueSEND_TO_BACK	( 0 )

+#define	queueSEND_TO_FRONT	( 1 )

+

+/* For internal use only.  These definitions *must* match those in queue.c. */

+#define queueQUEUE_TYPE_BASE				( 0U )

+#define queueQUEUE_TYPE_MUTEX 				( 1U )

+#define queueQUEUE_TYPE_COUNTING_SEMAPHORE	( 2U )

+#define queueQUEUE_TYPE_BINARY_SEMAPHORE	( 3U )

+#define queueQUEUE_TYPE_RECURSIVE_MUTEX		( 4U )

+

+void xInitQueues(void);

+

+/**

+ * 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

+ {

+	char ucMessageID;

+	char ucData[ 20 ];

+ };

+

+ void vATask( void *pvParameters )

+ {

+ xQueueHandle xQueue1, xQueue2;

+

+	// Create a queue capable of containing 10 unsigned long values.

+	xQueue1 = xQueueCreate( 10, sizeof( unsigned long ) );

+	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

+ */

+#define xQueueCreate( buffer, uxQueueLength, uxItemSize ) xQueueGenericCreate( buffer, uxQueueLength, uxItemSize, queueQUEUE_TYPE_BASE )

+

+/**

+ * queue. h

+ * <pre>

+ portBASE_TYPE xQueueSendToToFront(

+								   xQueueHandle	xQueue,

+								   const void	*	pvItemToQueue,

+								   portTickType	xTicksToWait

+							   );

+ * </pre>

+ *

+ * This is a macro that calls xQueueGenericSend().

+ *

+ * Post an item to the front of 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 and the

+ * queue is full.  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

+ {

+	char ucMessageID;

+	char ucData[ 20 ];

+ } xMessage;

+

+ unsigned long 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 long ) );

+

+	// 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( xQueueSendToFront( 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;

+		xQueueSendToFront( xQueue2, ( void * ) &pxMessage, ( portTickType ) 0 );

+	}

+

+	// ... Rest of task code.

+ }

+ </pre>

+ * \defgroup xQueueSend xQueueSend

+ * \ingroup QueueManagement

+ */

+#define xQueueSendToFront( xQueue, pvItemToQueue, xTicksToWait ) xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_FRONT )

+

+/**

+ * queue. h

+ * <pre>

+ portBASE_TYPE xQueueSendToBack(

+								   xQueueHandle	xQueue,

+								   const	void	*	pvItemToQueue,

+								   portTickType	xTicksToWait

+							   );

+ * </pre>

+ *

+ * This is a macro that calls xQueueGenericSend().

+ *

+ * Post an item to the back of 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 and the queue

+ * is full.  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

+ {

+	char ucMessageID;

+	char ucData[ 20 ];

+ } xMessage;

+

+ unsigned long 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 long ) );

+

+	// 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( xQueueSendToBack( 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;

+		xQueueSendToBack( xQueue2, ( void * ) &pxMessage, ( portTickType ) 0 );

+	}

+

+	// ... Rest of task code.

+ }

+ </pre>

+ * \defgroup xQueueSend xQueueSend

+ * \ingroup QueueManagement

+ */

+#define xQueueSendToBack( xQueue, pvItemToQueue, xTicksToWait ) xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )

+

+/**

+ * queue. h

+ * <pre>

+ portBASE_TYPE xQueueSend(

+							  xQueueHandle xQueue,

+							  const void * pvItemToQueue,

+							  portTickType xTicksToWait

+						 );

+ * </pre>

+ *

+ * This is a macro that calls xQueueGenericSend().  It is included for

+ * backward compatibility with versions of FreeRTOS.org that did not

+ * include the xQueueSendToFront() and xQueueSendToBack() macros.  It is

+ * equivalent to xQueueSendToBack().

+ *

+ * 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 and the

+ * queue is full.  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

+ {

+	char ucMessageID;

+	char ucData[ 20 ];

+ } xMessage;

+

+ unsigned long 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 long ) );

+

+	// 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

+ */

+#define xQueueSend( xQueue, pvItemToQueue, xTicksToWait ) xQueueGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )

+

+

+/**

+ * queue. h

+ * <pre>

+ portBASE_TYPE xQueueGenericSend(

+									xQueueHandle xQueue,

+									const void * pvItemToQueue,

+									portTickType xTicksToWait

+									portBASE_TYPE xCopyPosition

+								);

+ * </pre>

+ *

+ * It is preferred that the macros xQueueSend(), xQueueSendToFront() and

+ * xQueueSendToBack() are used in place of calling this function directly.

+ *

+ * 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 and the

+ * queue is full.  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.

+ *

+ * @param xCopyPosition Can take the value queueSEND_TO_BACK to place the

+ * item at the back of the queue, or queueSEND_TO_FRONT to place the item

+ * at the front of the queue (for high priority messages).

+ *

+ * @return pdTRUE if the item was successfully posted, otherwise errQUEUE_FULL.

+ *

+ * Example usage:

+   <pre>

+ struct AMessage

+ {

+	char ucMessageID;

+	char ucData[ 20 ];

+ } xMessage;

+

+ unsigned long 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 long ) );

+

+	// 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( xQueueGenericSend( xQueue1, ( void * ) &ulVar, ( portTickType ) 10, queueSEND_TO_BACK ) != 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;

+		xQueueGenericSend( xQueue2, ( void * ) &pxMessage, ( portTickType ) 0, queueSEND_TO_BACK );

+	}

+

+	// ... Rest of task code.

+ }

+ </pre>

+ * \defgroup xQueueSend xQueueSend

+ * \ingroup QueueManagement

+ */

+signed portBASE_TYPE xQueueGenericSend( xQueueHandle pxQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition );

+

+/**

+ * queue. h

+ * <pre>

+ portBASE_TYPE xQueuePeek(

+							 xQueueHandle xQueue,

+							 void *pvBuffer,

+							 portTickType xTicksToWait

+						 );</pre>

+ *

+ * This is a macro that calls the xQueueGenericReceive() function.

+ *

+ * Receive an item from a queue without removing the item from the 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.

+ *

+ * Successfully received items remain on the queue so will be returned again

+ * by the next call, or a call to xQueueReceive().

+ *

+ * This macro must not be used in an interrupt service routine.

+ *

+ * @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.

+ * xQueuePeek() will return immediately if xTicksToWait is 0 and the queue

+ * is empty.

+ *

+ * @return pdTRUE if an item was successfully received from the queue,

+ * otherwise pdFALSE.

+ *

+ * Example usage:

+   <pre>

+ struct AMessage

+ {

+	char ucMessageID;

+	char 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.

+ }

+

+ // Task to peek the data from the queue.

+ void vADifferentTask( void *pvParameters )

+ {

+ struct AMessage *pxRxedMessage;

+

+	if( xQueue != 0 )

+	{

+		// Peek a message on the created queue.  Block for 10 ticks if a

+		// message is not immediately available.

+		if( xQueuePeek( xQueue, &( pxRxedMessage ), ( portTickType ) 10 ) )

+		{

+			// pcRxedMessage now points to the struct AMessage variable posted

+			// by vATask, but the item still remains on the queue.

+		}

+	}

+

+	// ... Rest of task code.

+ }

+ </pre>

+ * \defgroup xQueueReceive xQueueReceive

+ * \ingroup QueueManagement

+ */

+#define xQueuePeek( xQueue, pvBuffer, xTicksToWait ) xQueueGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdTRUE )

+

+/**

+ * queue. h

+ * <pre>

+ portBASE_TYPE xQueueReceive(

+								 xQueueHandle xQueue,

+								 void *pvBuffer,

+								 portTickType xTicksToWait

+							);</pre>

+ *

+ * This is a macro that calls the xQueueGenericReceive() function.

+ *

+ * 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.

+ *

+ * Successfully received items are removed from the queue.

+ *

+ * 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.	 xQueueReceive() will return immediately if xTicksToWait

+ * is zero and the queue is empty.  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

+ {

+	char ucMessageID;

+	char 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.

+ }

+

+ // Task to receive from the queue.

+ void vADifferentTask( void *pvParameters )

+ {

+ struct AMessage *pxRxedMessage;

+

+	if( xQueue != 0 )

+	{

+		// Receive a message on the created queue.  Block for 10 ticks if a

+		// message is not immediately available.

+		if( xQueueReceive( xQueue, &( pxRxedMessage ), ( portTickType ) 10 ) )

+		{

+			// pcRxedMessage now points to the struct AMessage variable posted

+			// by vATask.

+		}

+	}

+

+	// ... Rest of task code.

+ }

+ </pre>

+ * \defgroup xQueueReceive xQueueReceive

+ * \ingroup QueueManagement

+ */

+#define xQueueReceive( xQueue, pvBuffer, xTicksToWait ) xQueueGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdFALSE )

+

+

+/**

+ * queue. h

+ * <pre>

+ portBASE_TYPE xQueueGenericReceive(

+									   xQueueHandle	xQueue,

+									   void	*pvBuffer,

+									   portTickType	xTicksToWait

+									   portBASE_TYPE	xJustPeek

+									);</pre>

+ *

+ * It is preferred that the macro xQueueReceive() be used rather than calling

+ * this function directly.

+ *

+ * 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.

+ * xQueueGenericReceive() will return immediately if the queue is empty and

+ * xTicksToWait is 0.

+ *

+ * @param xJustPeek When set to true, the item received from the queue is not

+ * actually removed from the queue - meaning a subsequent call to

+ * xQueueReceive() will return the same item.  When set to false, the item

+ * being received from the queue is also removed from the queue.

+ *

+ * @return pdTRUE if an item was successfully received from the queue,

+ * otherwise pdFALSE.

+ *

+ * Example usage:

+   <pre>

+ struct AMessage

+ {

+	char ucMessageID;

+	char 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.

+ }

+

+ // Task to receive from the queue.

+ void vADifferentTask( void *pvParameters )

+ {

+ struct AMessage *pxRxedMessage;

+

+	if( xQueue != 0 )

+	{

+		// Receive a message on the created queue.  Block for 10 ticks if a

+		// message is not immediately available.

+		if( xQueueGenericReceive( xQueue, &( pxRxedMessage ), ( portTickType ) 10 ) )

+		{

+			// pcRxedMessage now points to the struct AMessage variable posted

+			// by vATask.

+		}

+	}

+

+	// ... Rest of task code.

+ }

+ </pre>

+ * \defgroup xQueueReceive xQueueReceive

+ * \ingroup QueueManagement

+ */

+signed portBASE_TYPE xQueueGenericReceive( xQueueHandle xQueue, void * const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeek );

+

+/**

+ * queue. h

+ * <pre>unsigned portBASE_TYPE uxQueueMessagesWaiting( const xQueueHandle xQueue );</pre>

+ *

+ * Return the number of messages stored in a queue.

+ *

+ * @param xQueue A handle to the queue being queried.

+ *

+ * @return The number of messages available in the queue.

+ *

+ * \page uxQueueMessagesWaiting uxQueueMessagesWaiting

+ * \ingroup QueueManagement

+ */

+unsigned portBASE_TYPE uxQueueMessagesWaiting( const xQueueHandle xQueue );

+

+/**

+ * queue. h

+ * <pre>void vQueueDelete( xQueueHandle xQueue );</pre>

+ *

+ * Delete a queue - freeing all the memory allocated for storing of items

+ * placed on the queue.

+ *

+ * @param xQueue A handle to the queue to be deleted.

+ *

+ * \page vQueueDelete vQueueDelete

+ * \ingroup QueueManagement

+ */

+void vQueueDelete( xQueueHandle pxQueue );

+

+/**

+ * queue. h

+ * <pre>

+ portBASE_TYPE xQueueSendToFrontFromISR(

+										 xQueueHandle pxQueue,

+										 const void *pvItemToQueue,

+										 portBASE_TYPE *pxHigherPriorityTaskWoken

+									  );

+ </pre>

+ *

+ * This is a macro that calls xQueueGenericSendFromISR().

+ *

+ * Post an item to the front of a queue.  It is safe to use this macro from

+ * within an interrupt service routine.

+ *

+ * Items are queued by copy not reference so it is preferable to only

+ * queue small items, especially when called from an ISR.  In most cases

+ * it would be preferable to store a pointer to the item being queued.

+ *

+ * @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 pxHigherPriorityTaskWoken xQueueSendToFrontFromISR() will set

+ * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task

+ * to unblock, and the unblocked task has a priority higher than the currently

+ * running task.  If xQueueSendToFromFromISR() sets this value to pdTRUE then

+ * a context switch should be requested before the interrupt is exited.

+ *

+ * @return pdTRUE if the data was successfully sent to the queue, otherwise

+ * errQUEUE_FULL.

+ *

+ * Example usage for buffered IO (where the ISR can obtain more than one value

+ * per call):

+   <pre>

+ void vBufferISR( void )

+ {

+ char cIn;

+ portBASE_TYPE xHigherPrioritTaskWoken;

+

+	// We have not woken a task at the start of the ISR.

+	xHigherPriorityTaskWoken = pdFALSE;

+

+	// Loop until the buffer is empty.

+	do

+	{

+		// Obtain a byte from the buffer.

+		cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );

+

+		// Post the byte.

+		xQueueSendToFrontFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );

+

+	} while( portINPUT_BYTE( BUFFER_COUNT ) );

+

+	// Now the buffer is empty we can switch context if necessary.

+	if( xHigherPriorityTaskWoken )

+	{

+		taskYIELD ();

+	}

+ }

+ </pre>

+ *

+ * \defgroup xQueueSendFromISR xQueueSendFromISR

+ * \ingroup QueueManagement

+ */

+#define xQueueSendToFrontFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( pxQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_FRONT )

+

+

+/**

+ * queue. h

+ * <pre>

+ portBASE_TYPE xQueueSendToBackFromISR(

+										 xQueueHandle pxQueue,

+										 const void *pvItemToQueue,

+										 portBASE_TYPE *pxHigherPriorityTaskWoken

+									  );

+ </pre>

+ *

+ * This is a macro that calls xQueueGenericSendFromISR().

+ *

+ * Post an item to the back of a queue.  It is safe to use this macro from

+ * within an interrupt service routine.

+ *

+ * Items are queued by copy not reference so it is preferable to only

+ * queue small items, especially when called from an ISR.  In most cases

+ * it would be preferable to store a pointer to the item being queued.

+ *

+ * @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 pxHigherPriorityTaskWoken xQueueSendToBackFromISR() will set

+ * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task

+ * to unblock, and the unblocked task has a priority higher than the currently

+ * running task.  If xQueueSendToBackFromISR() sets this value to pdTRUE then

+ * a context switch should be requested before the interrupt is exited.

+ *

+ * @return pdTRUE if the data was successfully sent to the queue, otherwise

+ * errQUEUE_FULL.

+ *

+ * Example usage for buffered IO (where the ISR can obtain more than one value

+ * per call):

+   <pre>

+ void vBufferISR( void )

+ {

+ char cIn;

+ portBASE_TYPE xHigherPriorityTaskWoken;

+

+	// We have not woken a task at the start of the ISR.

+	xHigherPriorityTaskWoken = pdFALSE;

+

+	// Loop until the buffer is empty.

+	do

+	{

+		// Obtain a byte from the buffer.

+		cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );

+

+		// Post the byte.

+		xQueueSendToBackFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );

+

+	} while( portINPUT_BYTE( BUFFER_COUNT ) );

+

+	// Now the buffer is empty we can switch context if necessary.

+	if( xHigherPriorityTaskWoken )

+	{

+		taskYIELD ();

+	}

+ }

+ </pre>

+ *

+ * \defgroup xQueueSendFromISR xQueueSendFromISR

+ * \ingroup QueueManagement

+ */

+#define xQueueSendToBackFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( pxQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )

+

+/**

+ * queue. h

+ * <pre>

+ portBASE_TYPE xQueueSendFromISR(

+									 xQueueHandle pxQueue,

+									 const void *pvItemToQueue,

+									 portBASE_TYPE *pxHigherPriorityTaskWoken

+								);

+ </pre>

+ *

+ * This is a macro that calls xQueueGenericSendFromISR().  It is included

+ * for backward compatibility with versions of FreeRTOS.org that did not

+ * include the xQueueSendToBackFromISR() and xQueueSendToFrontFromISR()

+ * macros.

+ *

+ * Post an item to the back of a queue.  It is safe to use this function from

+ * within an interrupt service routine.

+ *

+ * Items are queued by copy not reference so it is preferable to only

+ * queue small items, especially when called from an ISR.  In most cases

+ * it would be preferable to store a pointer to the item being queued.

+ *

+ * @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 pxHigherPriorityTaskWoken xQueueSendFromISR() will set

+ * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task

+ * to unblock, and the unblocked task has a priority higher than the currently

+ * running task.  If xQueueSendFromISR() sets this value to pdTRUE then

+ * a context switch should be requested before the interrupt is exited.

+ *

+ * @return pdTRUE if the data was successfully sent to the queue, otherwise

+ * errQUEUE_FULL.

+ *

+ * Example usage for buffered IO (where the ISR can obtain more than one value

+ * per call):

+   <pre>

+ void vBufferISR( void )

+ {

+ char cIn;

+ portBASE_TYPE xHigherPriorityTaskWoken;

+

+	// We have not woken a task at the start of the ISR.

+	xHigherPriorityTaskWoken = pdFALSE;

+

+	// Loop until the buffer is empty.

+	do

+	{

+		// Obtain a byte from the buffer.

+		cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );

+

+		// Post the byte.

+		xQueueSendFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWoken );

+

+	} while( portINPUT_BYTE( BUFFER_COUNT ) );

+

+	// Now the buffer is empty we can switch context if necessary.

+	if( xHigherPriorityTaskWoken )

+	{

+		// Actual macro used here is port specific.

+		taskYIELD_FROM_ISR ();

+	}

+ }

+ </pre>

+ *

+ * \defgroup xQueueSendFromISR xQueueSendFromISR

+ * \ingroup QueueManagement

+ */

+#define xQueueSendFromISR( pxQueue, pvItemToQueue, pxHigherPriorityTaskWoken ) xQueueGenericSendFromISR( ( pxQueue ), ( pvItemToQueue ), ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )

+

+/**

+ * queue. h

+ * <pre>

+ portBASE_TYPE xQueueGenericSendFromISR(

+										   xQueueHandle	pxQueue,

+										   const	void	*pvItemToQueue,

+										   portBASE_TYPE	*pxHigherPriorityTaskWoken,

+										   portBASE_TYPE	xCopyPosition

+									   );

+ </pre>

+ *

+ * It is preferred that the macros xQueueSendFromISR(),

+ * xQueueSendToFrontFromISR() and xQueueSendToBackFromISR() be used in place

+ * of calling this function directly.

+ *

+ * Post an item on a queue.  It is safe to use this function from within an

+ * interrupt service routine.

+ *

+ * Items are queued by copy not reference so it is preferable to only

+ * queue small items, especially when called from an ISR.  In most cases

+ * it would be preferable to store a pointer to the item being queued.

+ *

+ * @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 pxHigherPriorityTaskWoken xQueueGenericSendFromISR() will set

+ * *pxHigherPriorityTaskWoken to pdTRUE if sending to the queue caused a task

+ * to unblock, and the unblocked task has a priority higher than the currently

+ * running task.  If xQueueGenericSendFromISR() sets this value to pdTRUE then

+ * a context switch should be requested before the interrupt is exited.

+ *

+ * @param xCopyPosition Can take the value queueSEND_TO_BACK to place the

+ * item at the back of the queue, or queueSEND_TO_FRONT to place the item

+ * at the front of the queue (for high priority messages).

+ *

+ * @return pdTRUE if the data was successfully sent to the queue, otherwise

+ * errQUEUE_FULL.

+ *

+ * Example usage for buffered IO (where the ISR can obtain more than one value

+ * per call):

+   <pre>

+ void vBufferISR( void )

+ {

+ char cIn;

+ portBASE_TYPE xHigherPriorityTaskWokenByPost;

+

+	// We have not woken a task at the start of the ISR.

+	xHigherPriorityTaskWokenByPost = pdFALSE;

+

+	// Loop until the buffer is empty.

+	do

+	{

+		// Obtain a byte from the buffer.

+		cIn = portINPUT_BYTE( RX_REGISTER_ADDRESS );

+

+		// Post each byte.

+		xQueueGenericSendFromISR( xRxQueue, &cIn, &xHigherPriorityTaskWokenByPost, queueSEND_TO_BACK );

+

+	} while( portINPUT_BYTE( BUFFER_COUNT ) );

+

+	// Now the buffer is empty we can switch context if necessary.  Note that the

+	// name of the yield function required is port specific.

+	if( xHigherPriorityTaskWokenByPost )

+	{

+		taskYIELD_YIELD_FROM_ISR();

+	}

+ }

+ </pre>

+ *

+ * \defgroup xQueueSendFromISR xQueueSendFromISR

+ * \ingroup QueueManagement

+ */

+signed portBASE_TYPE xQueueGenericSendFromISR( xQueueHandle pxQueue, const void * const pvItemToQueue, signed portBASE_TYPE *pxHigherPriorityTaskWoken, portBASE_TYPE xCopyPosition );

+

+/**

+ * queue. h

+ * <pre>

+ portBASE_TYPE xQueueReceiveFromISR(

+									   xQueueHandle	pxQueue,

+									   void	*pvBuffer,

+									   portBASE_TYPE	*pxTaskWoken

+								   );

+ * </pre>

+ *

+ * Receive an item from a queue.  It is safe to use this function from within an

+ * interrupt service routine.

+ *

+ * @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 pxTaskWoken A task may be blocked waiting for space to become

+ * available on the queue.  If xQueueReceiveFromISR causes such a task to

+ * unblock *pxTaskWoken will get set to pdTRUE, otherwise *pxTaskWoken will

+ * remain unchanged.

+ *

+ * @return pdTRUE if an item was successfully received from the queue,

+ * otherwise pdFALSE.

+ *

+ * Example usage:

+   <pre>

+

+ xQueueHandle xQueue;

+

+ // Function to create a queue and post some values.

+ void vAFunction( void *pvParameters )

+ {

+ char cValueToPost;

+ const portTickType xBlockTime = ( portTickType )0xff;

+

+	// Create a queue capable of containing 10 characters.

+	xQueue = xQueueCreate( 10, sizeof( char ) );

+	if( xQueue == 0 )

+	{

+		// Failed to create the queue.

+	}

+

+	// ...

+

+	// Post some characters that will be used within an ISR.  If the queue

+	// is full then this task will block for xBlockTime ticks.

+	cValueToPost = 'a';

+	xQueueSend( xQueue, ( void * ) &cValueToPost, xBlockTime );

+	cValueToPost = 'b';

+	xQueueSend( xQueue, ( void * ) &cValueToPost, xBlockTime );

+

+	// ... keep posting characters ... this task may block when the queue

+	// becomes full.

+

+	cValueToPost = 'c';

+	xQueueSend( xQueue, ( void * ) &cValueToPost, xBlockTime );

+ }

+

+ // ISR that outputs all the characters received on the queue.

+ void vISR_Routine( void )

+ {

+ portBASE_TYPE xTaskWokenByReceive = pdFALSE;

+ char cRxedChar;

+

+	while( xQueueReceiveFromISR( xQueue, ( void * ) &cRxedChar, &xTaskWokenByReceive) )

+	{

+		// A character was received.  Output the character now.

+		vOutputCharacter( cRxedChar );

+

+		// If removing the character from the queue woke the task that was

+		// posting onto the queue cTaskWokenByReceive will have been set to

+		// pdTRUE.  No matter how many times this loop iterates only one

+		// task will be woken.

+	}

+

+	if( cTaskWokenByPost != ( char ) pdFALSE;

+	{

+		taskYIELD ();

+	}

+ }

+ </pre>

+ * \defgroup xQueueReceiveFromISR xQueueReceiveFromISR

+ * \ingroup QueueManagement

+ */

+signed portBASE_TYPE xQueueReceiveFromISR( xQueueHandle pxQueue, void * const pvBuffer, signed portBASE_TYPE *pxHigherPriorityTaskWoken );

+

+/*

+ * Utilities to query queues that are safe to use from an ISR.  These utilities

+ * should be used only from witin an ISR, or within a critical section.

+ */

+signed portBASE_TYPE xQueueIsQueueEmptyFromISR( const xQueueHandle pxQueue );

+signed portBASE_TYPE xQueueIsQueueFullFromISR( const xQueueHandle pxQueue );

+unsigned portBASE_TYPE uxQueueMessagesWaitingFromISR( const xQueueHandle pxQueue );

+

+

+/*

+ * xQueueAltGenericSend() is an alternative version of xQueueGenericSend().

+ * Likewise xQueueAltGenericReceive() is an alternative version of

+ * xQueueGenericReceive().

+ *

+ * The source code that implements the alternative (Alt) API is much

+ * simpler	because it executes everything from within a critical section.

+ * This is	the approach taken by many other RTOSes, but FreeRTOS.org has the

+ * preferred fully featured API too.  The fully featured API has more

+ * complex	code that takes longer to execute, but makes much less use of

+ * critical sections.  Therefore the alternative API sacrifices interrupt

+ * responsiveness to gain execution speed, whereas the fully featured API

+ * sacrifices execution speed to ensure better interrupt responsiveness.

+ */

+signed portBASE_TYPE xQueueAltGenericSend( xQueueHandle pxQueue, const void * const pvItemToQueue, portTickType xTicksToWait, portBASE_TYPE xCopyPosition );

+signed portBASE_TYPE xQueueAltGenericReceive( xQueueHandle pxQueue, void * const pvBuffer, portTickType xTicksToWait, portBASE_TYPE xJustPeeking );

+#define xQueueAltSendToFront( xQueue, pvItemToQueue, xTicksToWait ) xQueueAltGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_FRONT )

+#define xQueueAltSendToBack( xQueue, pvItemToQueue, xTicksToWait ) xQueueAltGenericSend( ( xQueue ), ( pvItemToQueue ), ( xTicksToWait ), queueSEND_TO_BACK )

+#define xQueueAltReceive( xQueue, pvBuffer, xTicksToWait ) xQueueAltGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdFALSE )

+#define xQueueAltPeek( xQueue, pvBuffer, xTicksToWait ) xQueueAltGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdTRUE )

+

+/*

+ * The functions defined above are for passing data to and from tasks.  The

+ * functions below are the equivalents for passing data to and from

+ * co-routines.

+ *

+ * These functions are called from the co-routine macro implementation and

+ * should not be called directly from application code.  Instead use the macro

+ * wrappers defined within croutine.h.

+ */

+signed portBASE_TYPE xQueueCRSendFromISR( xQueueHandle pxQueue, const void *pvItemToQueue, signed portBASE_TYPE xCoRoutinePreviouslyWoken );

+signed portBASE_TYPE xQueueCRReceiveFromISR( xQueueHandle pxQueue, void *pvBuffer, signed portBASE_TYPE *pxTaskWoken );

+signed portBASE_TYPE xQueueCRSend( xQueueHandle pxQueue, const void *pvItemToQueue, portTickType xTicksToWait );

+signed portBASE_TYPE xQueueCRReceive( xQueueHandle pxQueue, void *pvBuffer, portTickType xTicksToWait );

+

+/*

+ * For internal use only.  Use xSemaphoreCreateMutex(), 

+ * xSemaphoreCreateCounting() or xSemaphoreGetMutexHolder() instead of calling 

+ * these functions directly.

+ */

+xQueueHandle xQueueCreateMutex( unsigned char ucQueueType );

+xQueueHandle xQueueCreateCountingSemaphore( unsigned portBASE_TYPE uxCountValue, unsigned portBASE_TYPE uxInitialCount );

+void* xQueueGetMutexHolder( xQueueHandle xSemaphore );

+

+/*

+ * For internal use only.  Use xSemaphoreTakeMutexRecursive() or

+ * xSemaphoreGiveMutexRecursive() instead of calling these functions directly.

+ */

+portBASE_TYPE xQueueTakeMutexRecursive( xQueueHandle pxMutex, portTickType xBlockTime );

+portBASE_TYPE xQueueGiveMutexRecursive( xQueueHandle pxMutex );

+

+/*

+ * Reset a queue back to its original empty state.  pdPASS is returned if the

+ * queue is successfully reset.  pdFAIL is returned if the queue could not be

+ * reset because there are tasks blocked on the queue waiting to either

+ * receive from the queue or send to the queue.

+ */

+#define xQueueReset( pxQueue ) xQueueGenericReset( pxQueue, pdFALSE )

+

+/*

+ * The registry is provided as a means for kernel aware debuggers to

+ * locate queues, semaphores and mutexes.  Call vQueueAddToRegistry() add

+ * a queue, semaphore or mutex handle to the registry if you want the handle

+ * to be available to a kernel aware debugger.  If you are not using a kernel

+ * aware debugger then this function can be ignored.

+ *

+ * configQUEUE_REGISTRY_SIZE defines the maximum number of handles the

+ * registry can hold.  configQUEUE_REGISTRY_SIZE must be greater than 0

+ * within FreeRTOSConfig.h for the registry to be available.  Its value

+ * does not effect the number of queues, semaphores and mutexes that can be

+ * created - just the number that the registry can hold.

+ *

+ * @param xQueue The handle of the queue being added to the registry.  This

+ * is the handle returned by a call to xQueueCreate().  Semaphore and mutex

+ * handles can also be passed in here.

+ *

+ * @param pcName The name to be associated with the handle.  This is the

+ * name that the kernel aware debugger will display.

+ */

+#if configQUEUE_REGISTRY_SIZE > 0U

+	void vQueueAddToRegistry( xQueueHandle xQueue, signed char *pcName );

+#endif

+

+/*

+ * Generic version of the queue creation function, which is in turn called by 

+ * any queue, semaphore or mutex creation function or macro.

+ */

+    xQueueHandle xQueueGenericCreate( void* buffer, unsigned portBASE_TYPE uxQueueLength, unsigned portBASE_TYPE uxItemSize, unsigned char ucQueueType );

+

+/* Not public API functions. */

+void vQueueWaitForMessageRestricted( xQueueHandle pxQueue, portTickType xTicksToWait );

+portBASE_TYPE xQueueGenericReset( xQueueHandle pxQueue, portBASE_TYPE xNewQueue );

+

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif /* QUEUE_H */

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/include/semphr.h b/FreeRTOSV7.2.0/FreeRTOS/Source/include/semphr.h
new file mode 100644
index 0000000..bec8c06
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/include/semphr.h
@@ -0,0 +1,782 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+#ifndef SEMAPHORE_H

+#define SEMAPHORE_H

+

+#ifndef INC_FREERTOS_H

+	#error "include FreeRTOS.h" must appear in source files before "include semphr.h"

+#endif

+

+#include "queue.h"

+

+typedef xQueueHandle xSemaphoreHandle;

+

+#define semBINARY_SEMAPHORE_QUEUE_LENGTH	( ( unsigned char ) 1U )

+#define semSEMAPHORE_QUEUE_ITEM_LENGTH		( ( unsigned char ) 0U )

+#define semGIVE_BLOCK_TIME					( ( portTickType ) 0U )

+

+

+/**

+ * 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.

+ *

+ * This type of semaphore can be used for pure synchronisation between tasks or

+ * between an interrupt and a task.  The semaphore need not be given back once

+ * obtained, so one task/interrupt can continuously 'give' the semaphore while

+ * another continuously 'takes' the semaphore.  For this reason this type of

+ * semaphore does not use a priority inheritance mechanism.  For an alternative

+ * that does use priority inheritance see xSemaphoreCreateMutex().

+ *

+ * @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

+ */

+xQueueHandle xSemaphoreCreateBinary(void);

+

+#define vSemaphoreCreateBinary( xSemaphore ) ( xSemaphore ) = xSemaphoreCreateBinary( )

+

+/**

+ * semphr. h

+ * <pre>xSemaphoreTake( 

+ *                   xSemaphoreHandle xSemaphore, 

+ *                   portTickType xBlockTime 

+ *               )</pre>

+ *

+ * <i>Macro</i> to obtain a semaphore.  The semaphore must have previously been

+ * created with a call to vSemaphoreCreateBinary(), xSemaphoreCreateMutex() or

+ * xSemaphoreCreateCounting().

+ *

+ * @param xSemaphore A handle to the semaphore being taken - obtained when

+ * the semaphore was created.

+ *

+ * @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.  A block

+ * time of portMAX_DELAY can be used to block indefinitely (provided

+ * INCLUDE_vTaskSuspend is set to 1 in FreeRTOSConfig.h).

+ *

+ * @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

+ */

+#define xSemaphoreTake( xSemaphore, xBlockTime )		xQueueGenericReceive( ( xQueueHandle ) ( xSemaphore ), NULL, ( xBlockTime ), pdFALSE )

+

+/**

+ * semphr. h

+ * xSemaphoreTakeRecursive( 

+ *                          xSemaphoreHandle xMutex, 

+ *                          portTickType xBlockTime 

+ *                        )

+ *

+ * <i>Macro</i> to recursively obtain, or 'take', a mutex type semaphore.  

+ * The mutex must have previously been created using a call to 

+ * xSemaphoreCreateRecursiveMutex();

+ * 

+ * configUSE_RECURSIVE_MUTEXES must be set to 1 in FreeRTOSConfig.h for this

+ * macro to be available.

+ * 

+ * This macro must not be used on mutexes created using xSemaphoreCreateMutex().

+ *

+ * A mutex used recursively can be 'taken' repeatedly by the owner. The mutex 

+ * doesn't become available again until the owner has called 

+ * xSemaphoreGiveRecursive() for each successful 'take' request.  For example, 

+ * if a task successfully 'takes' the same mutex 5 times then the mutex will 

+ * not be available to any other task until it has also  'given' the mutex back

+ * exactly five times.

+ *

+ * @param xMutex A handle to the mutex being obtained.  This is the

+ * handle returned by xSemaphoreCreateRecursiveMutex();

+ *

+ * @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.  If

+ * the task already owns the semaphore then xSemaphoreTakeRecursive() will

+ * return immediately no matter what the value of xBlockTime. 

+ *

+ * @return pdTRUE if the semaphore was obtained.  pdFALSE if xBlockTime

+ * expired without the semaphore becoming available.

+ *

+ * Example usage:

+ <pre>

+ xSemaphoreHandle xMutex = NULL;

+

+ // A task that creates a mutex.

+ void vATask( void * pvParameters )

+ {

+    // Create the mutex to guard a shared resource.

+    xMutex = xSemaphoreCreateRecursiveMutex();

+ }

+

+ // A task that uses the mutex.

+ void vAnotherTask( void * pvParameters )

+ {

+    // ... Do other things.

+

+    if( xMutex != NULL )

+    {

+        // See if we can obtain the mutex.  If the mutex is not available

+        // wait 10 ticks to see if it becomes free.	

+        if( xSemaphoreTakeRecursive( xSemaphore, ( portTickType ) 10 ) == pdTRUE )

+        {

+            // We were able to obtain the mutex and can now access the

+            // shared resource.

+

+            // ...

+            // For some reason due to the nature of the code further calls to 

+			// xSemaphoreTakeRecursive() are made on the same mutex.  In real

+			// code these would not be just sequential calls as this would make

+			// no sense.  Instead the calls are likely to be buried inside

+			// a more complex call structure.

+            xSemaphoreTakeRecursive( xMutex, ( portTickType ) 10 );

+            xSemaphoreTakeRecursive( xMutex, ( portTickType ) 10 );

+

+            // The mutex has now been 'taken' three times, so will not be 

+			// available to another task until it has also been given back

+			// three times.  Again it is unlikely that real code would have

+			// these calls sequentially, but instead buried in a more complex

+			// call structure.  This is just for illustrative purposes.

+            xSemaphoreGiveRecursive( xMutex );

+			xSemaphoreGiveRecursive( xMutex );

+			xSemaphoreGiveRecursive( xMutex );

+

+			// Now the mutex can be taken by other tasks.

+        }

+        else

+        {

+            // We could not obtain the mutex and can therefore not access

+            // the shared resource safely.

+        }

+    }

+ }

+ </pre>

+ * \defgroup xSemaphoreTakeRecursive xSemaphoreTakeRecursive

+ * \ingroup Semaphores

+ */

+#define xSemaphoreTakeRecursive( xMutex, xBlockTime )	xQueueTakeMutexRecursive( ( xMutex ), ( xBlockTime ) )

+

+

+/* 

+ * xSemaphoreAltTake() is an alternative version of xSemaphoreTake().

+ *

+ * The source code that implements the alternative (Alt) API is much 

+ * simpler	because it executes everything from within a critical section.  

+ * This is	the approach taken by many other RTOSes, but FreeRTOS.org has the 

+ * preferred fully featured API too.  The fully featured API has more 

+ * complex	code that takes longer to execute, but makes much less use of 

+ * critical sections.  Therefore the alternative API sacrifices interrupt 

+ * responsiveness to gain execution speed, whereas the fully featured API

+ * sacrifices execution speed to ensure better interrupt responsiveness.

+ */

+#define xSemaphoreAltTake( xSemaphore, xBlockTime )		xQueueAltGenericReceive( ( xQueueHandle ) ( xSemaphore ), NULL, ( xBlockTime ), pdFALSE )

+

+/**

+ * semphr. h

+ * <pre>xSemaphoreGive( xSemaphoreHandle xSemaphore )</pre>

+ *

+ * <i>Macro</i> to release a semaphore.  The semaphore must have previously been

+ * created with a call to vSemaphoreCreateBinary(), xSemaphoreCreateMutex() or

+ * xSemaphoreCreateCounting(). and obtained using sSemaphoreTake().

+ *

+ * This macro must not be used from an ISR.  See xSemaphoreGiveFromISR () for

+ * an alternative which can be used from an ISR.

+ *

+ * This macro must also not be used on semaphores created using 

+ * xSemaphoreCreateRecursiveMutex().

+ *

+ * @param xSemaphore A handle to the semaphore being released.  This is the

+ * handle returned when the semaphore was created.

+ *

+ * @return pdTRUE if the semaphore was released.  pdFALSE if an error occurred.

+ * Semaphores are implemented using queues.  An error can occur if there is

+ * no space on the queue to post a message - indicating that the 

+ * semaphore was not first obtained correctly.

+ *

+ * Example usage:

+ <pre>

+ xSemaphoreHandle xSemaphore = NULL;

+

+ void vATask( void * pvParameters )

+ {

+    // Create the semaphore to guard a shared resource.

+    vSemaphoreCreateBinary( xSemaphore );

+

+    if( xSemaphore != NULL )

+    {

+        if( xSemaphoreGive( xSemaphore ) != pdTRUE )

+        {

+            // We would expect this call to fail because we cannot give

+            // a semaphore without first "taking" it!

+        }

+

+        // Obtain the semaphore - don't block if the semaphore is not

+        // immediately available.

+        if( xSemaphoreTake( xSemaphore, ( portTickType ) 0 ) )

+        {

+            // We now have the semaphore and can access the shared resource.

+

+            // ...

+

+            // We have finished accessing the shared resource so can free the

+            // semaphore.

+            if( xSemaphoreGive( xSemaphore ) != pdTRUE )

+            {

+                // We would not expect this call to fail because we must have

+                // obtained the semaphore to get here.

+            }

+        }

+    }

+ }

+ </pre>

+ * \defgroup xSemaphoreGive xSemaphoreGive

+ * \ingroup Semaphores

+ */

+#define xSemaphoreGive( xSemaphore )		xQueueGenericSend( ( xQueueHandle ) ( xSemaphore ), NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK )

+

+/**

+ * semphr. h

+ * <pre>xSemaphoreGiveRecursive( xSemaphoreHandle xMutex )</pre>

+ *

+ * <i>Macro</i> to recursively release, or 'give', a mutex type semaphore.

+ * The mutex must have previously been created using a call to 

+ * xSemaphoreCreateRecursiveMutex();

+ * 

+ * configUSE_RECURSIVE_MUTEXES must be set to 1 in FreeRTOSConfig.h for this

+ * macro to be available.

+ *

+ * This macro must not be used on mutexes created using xSemaphoreCreateMutex().

+ * 

+ * A mutex used recursively can be 'taken' repeatedly by the owner. The mutex 

+ * doesn't become available again until the owner has called 

+ * xSemaphoreGiveRecursive() for each successful 'take' request.  For example, 

+ * if a task successfully 'takes' the same mutex 5 times then the mutex will 

+ * not be available to any other task until it has also  'given' the mutex back

+ * exactly five times.

+ *

+ * @param xMutex A handle to the mutex being released, or 'given'.  This is the

+ * handle returned by xSemaphoreCreateMutex();

+ *

+ * @return pdTRUE if the semaphore was given.

+ *

+ * Example usage:

+ <pre>

+ xSemaphoreHandle xMutex = NULL;

+

+ // A task that creates a mutex.

+ void vATask( void * pvParameters )

+ {

+    // Create the mutex to guard a shared resource.

+    xMutex = xSemaphoreCreateRecursiveMutex();

+ }

+

+ // A task that uses the mutex.

+ void vAnotherTask( void * pvParameters )

+ {

+    // ... Do other things.

+

+    if( xMutex != NULL )

+    {

+        // See if we can obtain the mutex.  If the mutex is not available

+        // wait 10 ticks to see if it becomes free.	

+        if( xSemaphoreTakeRecursive( xMutex, ( portTickType ) 10 ) == pdTRUE )

+        {

+            // We were able to obtain the mutex and can now access the

+            // shared resource.

+

+            // ...

+            // For some reason due to the nature of the code further calls to 

+			// xSemaphoreTakeRecursive() are made on the same mutex.  In real

+			// code these would not be just sequential calls as this would make

+			// no sense.  Instead the calls are likely to be buried inside

+			// a more complex call structure.

+            xSemaphoreTakeRecursive( xMutex, ( portTickType ) 10 );

+            xSemaphoreTakeRecursive( xMutex, ( portTickType ) 10 );

+

+            // The mutex has now been 'taken' three times, so will not be 

+			// available to another task until it has also been given back

+			// three times.  Again it is unlikely that real code would have

+			// these calls sequentially, it would be more likely that the calls

+			// to xSemaphoreGiveRecursive() would be called as a call stack

+			// unwound.  This is just for demonstrative purposes.

+            xSemaphoreGiveRecursive( xMutex );

+			xSemaphoreGiveRecursive( xMutex );

+			xSemaphoreGiveRecursive( xMutex );

+

+			// Now the mutex can be taken by other tasks.

+        }

+        else

+        {

+            // We could not obtain the mutex and can therefore not access

+            // the shared resource safely.

+        }

+    }

+ }

+ </pre>

+ * \defgroup xSemaphoreGiveRecursive xSemaphoreGiveRecursive

+ * \ingroup Semaphores

+ */

+#define xSemaphoreGiveRecursive( xMutex )	xQueueGiveMutexRecursive( ( xMutex ) )

+

+/* 

+ * xSemaphoreAltGive() is an alternative version of xSemaphoreGive().

+ *

+ * The source code that implements the alternative (Alt) API is much 

+ * simpler	because it executes everything from within a critical section.  

+ * This is	the approach taken by many other RTOSes, but FreeRTOS.org has the 

+ * preferred fully featured API too.  The fully featured API has more 

+ * complex	code that takes longer to execute, but makes much less use of 

+ * critical sections.  Therefore the alternative API sacrifices interrupt 

+ * responsiveness to gain execution speed, whereas the fully featured API

+ * sacrifices execution speed to ensure better interrupt responsiveness.

+ */

+#define xSemaphoreAltGive( xSemaphore )		xQueueAltGenericSend( ( xQueueHandle ) ( xSemaphore ), NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK )

+

+/**

+ * semphr. h

+ * <pre>

+ xSemaphoreGiveFromISR( 

+                          xSemaphoreHandle xSemaphore, 

+                          signed portBASE_TYPE *pxHigherPriorityTaskWoken

+                      )</pre>

+ *

+ * <i>Macro</i> to  release a semaphore.  The semaphore must have previously been

+ * created with a call to vSemaphoreCreateBinary() or xSemaphoreCreateCounting().

+ *

+ * Mutex type semaphores (those created using a call to xSemaphoreCreateMutex())

+ * must not be used with this macro.

+ *

+ * This macro can be used from an ISR.

+ *

+ * @param xSemaphore A handle to the semaphore being released.  This is the

+ * handle returned when the semaphore was created.

+ *

+ * @param pxHigherPriorityTaskWoken xSemaphoreGiveFromISR() will set

+ * *pxHigherPriorityTaskWoken to pdTRUE if giving the semaphore caused a task

+ * to unblock, and the unblocked task has a priority higher than the currently

+ * running task.  If xSemaphoreGiveFromISR() sets this value to pdTRUE then

+ * a context switch should be requested before the interrupt is exited.

+ *

+ * @return pdTRUE if the semaphore was successfully given, otherwise errQUEUE_FULL.

+ *

+ * Example usage:

+ <pre>

+ \#define LONG_TIME 0xffff

+ \#define TICKS_TO_WAIT	10

+ xSemaphoreHandle xSemaphore = NULL;

+

+ // Repetitive task.

+ void vATask( void * pvParameters )

+ {

+    for( ;; )

+    {

+        // We want this task to run every 10 ticks of a timer.  The semaphore 

+        // was created before this task was started.

+

+        // Block waiting for the semaphore to become available.

+        if( xSemaphoreTake( xSemaphore, LONG_TIME ) == pdTRUE )

+        {

+            // It is time to execute.

+

+            // ...

+

+            // We have finished our task.  Return to the top of the loop where

+            // we will block on the semaphore until it is time to execute 

+            // again.  Note when using the semaphore for synchronisation with an

+			// ISR in this manner there is no need to 'give' the semaphore back.

+        }

+    }

+ }

+

+ // Timer ISR

+ void vTimerISR( void * pvParameters )

+ {

+ static unsigned char ucLocalTickCount = 0;

+ static signed portBASE_TYPE xHigherPriorityTaskWoken;

+

+    // A timer tick has occurred.

+

+    // ... Do other time functions.

+

+    // Is it time for vATask () to run?

+	xHigherPriorityTaskWoken = pdFALSE;

+    ucLocalTickCount++;

+    if( ucLocalTickCount >= TICKS_TO_WAIT )

+    {

+        // Unblock the task by releasing the semaphore.

+        xSemaphoreGiveFromISR( xSemaphore, &xHigherPriorityTaskWoken );

+

+        // Reset the count so we release the semaphore again in 10 ticks time.

+        ucLocalTickCount = 0;

+    }

+

+    if( xHigherPriorityTaskWoken != pdFALSE )

+    {

+        // We can force a context switch here.  Context switching from an

+        // ISR uses port specific syntax.  Check the demo task for your port

+        // to find the syntax required.

+    }

+ }

+ </pre>

+ * \defgroup xSemaphoreGiveFromISR xSemaphoreGiveFromISR

+ * \ingroup Semaphores

+ */

+#define xSemaphoreGiveFromISR( xSemaphore, pxHigherPriorityTaskWoken )			xQueueGenericSendFromISR( ( xQueueHandle ) ( xSemaphore ), NULL, ( pxHigherPriorityTaskWoken ), queueSEND_TO_BACK )

+

+/**

+ * semphr. h

+ * <pre>

+ xSemaphoreTakeFromISR( 

+                          xSemaphoreHandle xSemaphore, 

+                          signed portBASE_TYPE *pxHigherPriorityTaskWoken

+                      )</pre>

+ *

+ * <i>Macro</i> to  take a semaphore from an ISR.  The semaphore must have 

+ * previously been created with a call to vSemaphoreCreateBinary() or 

+ * xSemaphoreCreateCounting().

+ *

+ * Mutex type semaphores (those created using a call to xSemaphoreCreateMutex())

+ * must not be used with this macro.

+ *

+ * This macro can be used from an ISR, however taking a semaphore from an ISR

+ * is not a common operation.  It is likely to only be useful when taking a

+ * counting semaphore when an interrupt is obtaining an object from a resource

+ * pool (when the semaphore count indicates the number of resources available).

+ *

+ * @param xSemaphore A handle to the semaphore being taken.  This is the

+ * handle returned when the semaphore was created.

+ *

+ * @param pxHigherPriorityTaskWoken xSemaphoreTakeFromISR() will set

+ * *pxHigherPriorityTaskWoken to pdTRUE if taking the semaphore caused a task

+ * to unblock, and the unblocked task has a priority higher than the currently

+ * running task.  If xSemaphoreTakeFromISR() sets this value to pdTRUE then

+ * a context switch should be requested before the interrupt is exited.

+ *

+ * @return pdTRUE if the semaphore was successfully taken, otherwise 

+ * pdFALSE

+ */

+#define xSemaphoreTakeFromISR( xSemaphore, pxHigherPriorityTaskWoken )			xQueueReceiveFromISR( ( xQueueHandle ) ( xSemaphore ), NULL, ( pxHigherPriorityTaskWoken ) )

+

+/**

+ * semphr. h

+ * <pre>xSemaphoreHandle xSemaphoreCreateMutex( void )</pre>

+ *

+ * <i>Macro</i> that implements a mutex semaphore by using the existing queue 

+ * mechanism.

+ *

+ * Mutexes created using this macro can be accessed using the xSemaphoreTake()

+ * and xSemaphoreGive() macros.  The xSemaphoreTakeRecursive() and 

+ * xSemaphoreGiveRecursive() macros should not be used.

+ * 

+ * This type of semaphore uses a priority inheritance mechanism so a task 

+ * 'taking' a semaphore MUST ALWAYS 'give' the semaphore back once the 

+ * semaphore it is no longer required.  

+ *

+ * Mutex type semaphores cannot be used from within interrupt service routines.  

+ *

+ * See vSemaphoreCreateBinary() for an alternative implementation that can be 

+ * used for pure synchronisation (where one task or interrupt always 'gives' the 

+ * semaphore and another always 'takes' the semaphore) and from within interrupt 

+ * service routines.

+ *

+ * @return xSemaphore Handle to the created mutex semaphore.  Should be of type 

+ *		xSemaphoreHandle.

+ *

+ * Example usage:

+ <pre>

+ xSemaphoreHandle xSemaphore;

+

+ void vATask( void * pvParameters )

+ {

+    // Semaphore cannot be used before a call to xSemaphoreCreateMutex().

+    // This is a macro so pass the variable in directly.

+    xSemaphore = xSemaphoreCreateMutex();

+

+    if( xSemaphore != NULL )

+    {

+        // The semaphore was created successfully.

+        // The semaphore can now be used.  

+    }

+ }

+ </pre>

+ * \defgroup vSemaphoreCreateMutex vSemaphoreCreateMutex

+ * \ingroup Semaphores

+ */

+#define xSemaphoreCreateMutex() xQueueCreateMutex( queueQUEUE_TYPE_MUTEX )

+

+

+/**

+ * semphr. h

+ * <pre>xSemaphoreHandle xSemaphoreCreateRecursiveMutex( void )</pre>

+ *

+ * <i>Macro</i> that implements a recursive mutex by using the existing queue 

+ * mechanism.

+ *

+ * Mutexes created using this macro can be accessed using the 

+ * xSemaphoreTakeRecursive() and xSemaphoreGiveRecursive() macros.  The 

+ * xSemaphoreTake() and xSemaphoreGive() macros should not be used.

+ *

+ * A mutex used recursively can be 'taken' repeatedly by the owner. The mutex 

+ * doesn't become available again until the owner has called 

+ * xSemaphoreGiveRecursive() for each successful 'take' request.  For example, 

+ * if a task successfully 'takes' the same mutex 5 times then the mutex will 

+ * not be available to any other task until it has also  'given' the mutex back

+ * exactly five times.

+ * 

+ * This type of semaphore uses a priority inheritance mechanism so a task 

+ * 'taking' a semaphore MUST ALWAYS 'give' the semaphore back once the 

+ * semaphore it is no longer required.  

+ *

+ * Mutex type semaphores cannot be used from within interrupt service routines.  

+ *

+ * See vSemaphoreCreateBinary() for an alternative implementation that can be 

+ * used for pure synchronisation (where one task or interrupt always 'gives' the 

+ * semaphore and another always 'takes' the semaphore) and from within interrupt 

+ * service routines.

+ *

+ * @return xSemaphore Handle to the created mutex semaphore.  Should be of type 

+ *		xSemaphoreHandle.

+ *

+ * Example usage:

+ <pre>

+ xSemaphoreHandle xSemaphore;

+

+ void vATask( void * pvParameters )

+ {

+    // Semaphore cannot be used before a call to xSemaphoreCreateMutex().

+    // This is a macro so pass the variable in directly.

+    xSemaphore = xSemaphoreCreateRecursiveMutex();

+

+    if( xSemaphore != NULL )

+    {

+        // The semaphore was created successfully.

+        // The semaphore can now be used.  

+    }

+ }

+ </pre>

+ * \defgroup vSemaphoreCreateMutex vSemaphoreCreateMutex

+ * \ingroup Semaphores

+ */

+#define xSemaphoreCreateRecursiveMutex() xQueueCreateMutex( queueQUEUE_TYPE_RECURSIVE_MUTEX )

+

+/**

+ * semphr. h

+ * <pre>xSemaphoreHandle xSemaphoreCreateCounting( unsigned portBASE_TYPE uxMaxCount, unsigned portBASE_TYPE uxInitialCount )</pre>

+ *

+ * <i>Macro</i> that creates a counting semaphore by using the existing 

+ * queue mechanism.  

+ *

+ * Counting semaphores are typically used for two things:

+ *

+ * 1) Counting events.  

+ *

+ *    In this usage scenario an event handler will 'give' a semaphore each time

+ *    an event occurs (incrementing the semaphore count value), and a handler 

+ *    task will 'take' a semaphore each time it processes an event 

+ *    (decrementing the semaphore count value).  The count value is therefore 

+ *    the difference between the number of events that have occurred and the 

+ *    number that have been processed.  In this case it is desirable for the 

+ *    initial count value to be zero.

+ *

+ * 2) Resource management.

+ *

+ *    In this usage scenario the count value indicates the number of resources

+ *    available.  To obtain control of a resource a task must first obtain a 

+ *    semaphore - decrementing the semaphore count value.  When the count value

+ *    reaches zero there are no free resources.  When a task finishes with the

+ *    resource it 'gives' the semaphore back - incrementing the semaphore count

+ *    value.  In this case it is desirable for the initial count value to be

+ *    equal to the maximum count value, indicating that all resources are free.

+ *

+ * @param uxMaxCount The maximum count value that can be reached.  When the 

+ *        semaphore reaches this value it can no longer be 'given'.

+ *

+ * @param uxInitialCount The count value assigned to the semaphore when it is

+ *        created.

+ *

+ * @return Handle to the created semaphore.  Null if the semaphore could not be

+ *         created.

+ * 

+ * Example usage:

+ <pre>

+ xSemaphoreHandle xSemaphore;

+

+ void vATask( void * pvParameters )

+ {

+ xSemaphoreHandle xSemaphore = NULL;

+

+    // Semaphore cannot be used before a call to xSemaphoreCreateCounting().

+    // The max value to which the semaphore can count should be 10, and the

+    // initial value assigned to the count should be 0.

+    xSemaphore = xSemaphoreCreateCounting( 10, 0 );

+

+    if( xSemaphore != NULL )

+    {

+        // The semaphore was created successfully.

+        // The semaphore can now be used.  

+    }

+ }

+ </pre>

+ * \defgroup xSemaphoreCreateCounting xSemaphoreCreateCounting

+ * \ingroup Semaphores

+ */

+#define xSemaphoreCreateCounting( uxMaxCount, uxInitialCount ) xQueueCreateCountingSemaphore( ( uxMaxCount ), ( uxInitialCount ) )

+

+/**

+ * semphr. h

+ * <pre>void vSemaphoreDelete( xSemaphoreHandle xSemaphore );</pre>

+ *

+ * Delete a semaphore.  This function must be used with care.  For example,

+ * do not delete a mutex type semaphore if the mutex is held by a task.

+ *

+ * @param xSemaphore A handle to the semaphore to be deleted.

+ *

+ * \page vSemaphoreDelete vSemaphoreDelete

+ * \ingroup Semaphores

+ */

+#define vSemaphoreDelete( xSemaphore ) vQueueDelete( ( xQueueHandle ) ( xSemaphore ) )

+

+/**

+ * semphr.h

+ * <pre>xTaskHandle xSemaphoreGetMutexHolder( xSemaphoreHandle xMutex );</pre>

+ *

+ * If xMutex is indeed a mutex type semaphore, return the current mutex holder.

+ * If xMutex is not a mutex type semaphore, or the mutex is available (not held

+ * by a task), return NULL.

+ *

+ * Note: This Is is a good way of determining if the calling task is the mutex 

+ * holder, but not a good way of determining the identity of the mutex holder as

+ * the holder may change between the function exiting and the returned value

+ * being tested.

+ */

+#define xSemaphoreGetMutexHolder( xSemaphore ) xQueueGetMutexHolder( ( xSemaphore ) )

+

+#endif /* SEMAPHORE_H */

+

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/include/static-allocator.h b/FreeRTOSV7.2.0/FreeRTOS/Source/include/static-allocator.h
new file mode 100644
index 0000000..2e6defc
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/include/static-allocator.h
@@ -0,0 +1,22 @@
+#ifndef __STATIC_ALLOCATOR_H_INCLUDED__
+#define __STATIC_ALLOCATOR_H_INCLUDED__
+
+#include <stdint.h>
+
+typedef struct static_pool_s {
+    void* backing_store;
+    void* flags;
+    int   item_size;
+    int   num_items;
+} static_pool_t;
+
+void poolInit( static_pool_t* inPool,
+               int inItemSize,
+               int inNumItems,
+               void* inBackingStore,
+               void* inFlags);
+void *poolAllocateBuffer( static_pool_t* inPool );
+void poolFreeBuffer( static_pool_t* inPool, void* inPointer);
+
+
+#endif // __STATIC_ALLOCATOR_H_INCLUDED__
diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/include/task.h b/FreeRTOSV7.2.0/FreeRTOS/Source/include/task.h
new file mode 100644
index 0000000..12965ee
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/include/task.h
@@ -0,0 +1,1322 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+	

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

+	including FreeRTOS+Trace - an indispensable productivity tool.

+

+	Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+	the code with commercial support, indemnification, and middleware, under 

+	the OpenRTOS brand:  http://www.OpenRTOS.com.  High Integrity Systems also

+	provide a safety engineered and independently SIL3 certified version under 

+	the	SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+

+#ifndef TASK_H

+#define TASK_H

+

+#ifndef INC_FREERTOS_H

+	#error "include FreeRTOS.h must appear in source files before include task.h"

+#endif

+

+#include "portable.h"

+#include "list.h"

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

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

+ * MACROS AND DEFINITIONS

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

+

+#define tskKERNEL_VERSION_NUMBER "V7.2.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 memory ranges allocated to the task when an MPU is used.

+ */

+typedef struct xMEMORY_REGION

+{

+	void *pvBaseAddress;

+	unsigned long ulLengthInBytes;

+	unsigned long ulParameters;

+} xMemoryRegion;

+

+/*

+ * Parameters required to create an MPU protected task.

+ */

+typedef struct xTASK_PARAMTERS

+{

+	pdTASK_CODE pvTaskCode;

+	const signed char * const pcName;

+	unsigned short usStackDepth;

+	void *pvParameters;

+	unsigned portBASE_TYPE uxPriority;

+	portSTACK_TYPE *puxStackBuffer;

+	xMemoryRegion xRegions[ portNUM_CONFIGURABLE_REGIONS ];

+} xTaskParameters;

+

+/*

+ * Defines the priority used by the idle task.  This must not be modified.

+ *

+ * \ingroup TaskUtils

+ */

+#define tskIDLE_PRIORITY			( ( unsigned portBASE_TYPE ) 0U )

+

+/**

+ * 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()

+

+/* Definitions returned by xTaskGetSchedulerState(). */

+#define taskSCHEDULER_NOT_STARTED	0

+#define taskSCHEDULER_RUNNING		1

+#define taskSCHEDULER_SUSPENDED		2

+

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

+ * TASK CREATION API

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

+

+/**

+ * task. h

+ *<pre>

+ portBASE_TYPE xTaskCreate(

+							  pdTASK_CODE pvTaskCode,

+							  const char * const pcName,

+							  unsigned short 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.

+ *

+ * xTaskCreate() can only be used to create a task that has unrestricted

+ * access to the entire microcontroller memory map.  Systems that include MPU

+ * support can alternatively create an MPU constrained task using

+ * xTaskCreateRestricted().

+ *

+ * @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.  Systems that

+ * include MPU support can optionally create tasks in a privileged (system)

+ * mode by setting bit portPRIVILEGE_BIT of the priority parameter.  For

+ * example, to create a privileged task at priority 2 the uxPriority parameter

+ * should be set to ( 2 | portPRIVILEGE_BIT ).

+ *

+ * @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 )

+ {

+ static unsigned char ucParameterToPass;

+ xTaskHandle xHandle;

+

+	 // Create the task, storing the handle.  Note that the passed parameter ucParameterToPass

+	 // must exist for the lifetime of the task, so in this case is declared static.  If it was just an

+	 // an automatic stack variable it might no longer exist, or at least have been corrupted, by the time

+	 // the new task attempts to access it.

+	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, &ucParameterToPass, tskIDLE_PRIORITY, &xHandle );

+

+	 // Use the handle to delete the task.

+	 vTaskDelete( xHandle );

+ }

+   </pre>

+ * \defgroup xTaskCreate xTaskCreate

+ * \ingroup Tasks

+ */

+#define xTaskCreate( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask ) xTaskGenericCreate( ( pvTaskCode ), ( pcName ), ( usStackDepth ), ( pvParameters ), ( uxPriority ), ( pxCreatedTask ), ( NULL ), ( NULL ) )

+

+/**

+ * task. h

+ *<pre>

+ portBASE_TYPE xTaskCreateRestricted( xTaskParameters *pxTaskDefinition, xTaskHandle *pxCreatedTask );</pre>

+ *

+ * xTaskCreateRestricted() should only be used in systems that include an MPU

+ * implementation.

+ *

+ * Create a new task and add it to the list of tasks that are ready to run.

+ * The function parameters define the memory regions and associated access

+ * permissions allocated to the task.

+ *

+ * @param pxTaskDefinition Pointer to a structure that contains a member

+ * for each of the normal xTaskCreate() parameters (see the xTaskCreate() API

+ * documentation) plus an optional stack buffer and the memory region

+ * definitions.

+ *

+ * @param pxCreatedTask 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>

+// Create an xTaskParameters structure that defines the task to be created.

+static const xTaskParameters xCheckTaskParameters =

+{

+	vATask,		// pvTaskCode - the function that implements the task.

+	"ATask",	// pcName - just a text name for the task to assist debugging.

+	100,		// usStackDepth	- the stack size DEFINED IN WORDS.

+	NULL,		// pvParameters - passed into the task function as the function parameters.

+	( 1UL | portPRIVILEGE_BIT ),// uxPriority - task priority, set the portPRIVILEGE_BIT if the task should run in a privileged state.

+	cStackBuffer,// puxStackBuffer - the buffer to be used as the task stack.

+

+	// xRegions - Allocate up to three separate memory regions for access by

+	// the task, with appropriate access permissions.  Different processors have

+	// different memory alignment requirements - refer to the FreeRTOS documentation

+	// for full information.

+	{											

+		// Base address					Length	Parameters

+        { cReadWriteArray,				32,		portMPU_REGION_READ_WRITE },

+        { cReadOnlyArray,				32,		portMPU_REGION_READ_ONLY },

+        { cPrivilegedOnlyAccessArray,	128,	portMPU_REGION_PRIVILEGED_READ_WRITE }

+	}

+};

+

+int main( void )

+{

+xTaskHandle xHandle;

+

+	// Create a task from the const structure defined above.  The task handle

+	// is requested (the second parameter is not NULL) but in this case just for

+	// demonstration purposes as its not actually used.

+	xTaskCreateRestricted( &xRegTest1Parameters, &xHandle );

+

+	// Start the scheduler.

+	vTaskStartScheduler();

+

+	// Will only get here if there was insufficient memory to create the idle

+	// task.

+	for( ;; );

+}

+   </pre>

+ * \defgroup xTaskCreateRestricted xTaskCreateRestricted

+ * \ingroup Tasks

+ */

+#define xTaskCreateRestricted( x, pxCreatedTask ) xTaskGenericCreate( ((x)->pvTaskCode), ((x)->pcName), ((x)->usStackDepth), ((x)->pvParameters), ((x)->uxPriority), (pxCreatedTask), ((x)->puxStackBuffer), ((x)->xRegions) )

+

+/**

+ * task. h

+ *<pre>

+ void vTaskAllocateMPURegions( xTaskHandle xTask, const xMemoryRegion * const pxRegions );</pre>

+ *

+ * Memory regions are assigned to a restricted task when the task is created by

+ * a call to xTaskCreateRestricted().  These regions can be redefined using

+ * vTaskAllocateMPURegions().

+ *

+ * @param xTask The handle of the task being updated.

+ *

+ * @param xRegions A pointer to an xMemoryRegion structure that contains the

+ * new memory region definitions.

+ *

+ * Example usage:

+   <pre>

+// Define an array of xMemoryRegion structures that configures an MPU region

+// allowing read/write access for 1024 bytes starting at the beginning of the

+// ucOneKByte array.  The other two of the maximum 3 definable regions are

+// unused so set to zero.

+static const xMemoryRegion xAltRegions[ portNUM_CONFIGURABLE_REGIONS ] =

+{											

+	// Base address		Length		Parameters

+	{ ucOneKByte,		1024,		portMPU_REGION_READ_WRITE },

+	{ 0,				0,			0 },

+	{ 0,				0,			0 }

+};

+

+void vATask( void *pvParameters )

+{

+	// This task was created such that it has access to certain regions of

+	// memory as defined by the MPU configuration.  At some point it is

+	// desired that these MPU regions are replaced with that defined in the

+	// xAltRegions const struct above.  Use a call to vTaskAllocateMPURegions()

+	// for this purpose.  NULL is used as the task handle to indicate that this

+	// function should modify the MPU regions of the calling task.

+	vTaskAllocateMPURegions( NULL, xAltRegions );

+	

+	// Now the task can continue its function, but from this point on can only

+	// access its stack and the ucOneKByte array (unless any other statically

+	// defined or shared regions have been declared elsewhere).

+}

+   </pre>

+ * \defgroup xTaskCreateRestricted xTaskCreateRestricted

+ * \ingroup Tasks

+ */

+void vTaskAllocateMPURegions( xTaskHandle xTask, const xMemoryRegion * const pxRegions ) PRIVILEGED_FUNCTION;

+

+/**

+ * 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 pxTaskToDelete ) PRIVILEGED_FUNCTION;

+

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

+ * 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.

+ *

+ *

+ * vTaskDelay() specifies a time at which the task wishes to unblock relative to

+ * the time at which vTaskDelay() is called.  For example, specifying a block

+ * period of 100 ticks will cause the task to unblock 100 ticks after

+ * vTaskDelay() is called.  vTaskDelay() does not therefore provide a good method

+ * of controlling the frequency of a cyclical task as the path taken through the

+ * code, as well as other task and interrupt activity, will effect the frequency

+ * at which vTaskDelay() gets called and therefore the time at which the task

+ * next executes.  See vTaskDelayUntil() for an alternative API function designed

+ * to facilitate fixed frequency execution.  It does this by specifying an

+ * absolute time (rather than a relative time) at which the calling task should

+ * unblock.

+ *

+ * @param xTicksToDelay The amount of time, in tick periods, that

+ * the calling task should block.

+ *

+ * Example usage:

+

+ void vTaskFunction( void * pvParameters )

+ {

+ void vTaskFunction( void * pvParameters )

+ {

+ // Block for 500ms.

+ const portTickType xDelay = 500 / portTICK_RATE_MS;

+

+	 for( ;; )

+	 {

+		 // Simply toggle the LED every 500ms, blocking between each toggle.

+		 vToggleLED();

+		 vTaskDelay( xDelay );

+	 }

+ }

+

+ * \defgroup vTaskDelay vTaskDelay

+ * \ingroup TaskCtrl

+ */

+void vTaskDelay( portTickType xTicksToDelay ) PRIVILEGED_FUNCTION;

+

+/**

+ * 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 * const pxPreviousWakeTime, portTickType xTimeIncrement ) PRIVILEGED_FUNCTION;

+

+/**

+ * 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 ) PRIVILEGED_FUNCTION;

+

+/**

+ * 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 ) PRIVILEGED_FUNCTION;

+

+/**

+ * 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 );

+

+	 // ...

+

+	 // The created task will not run during this period, unless

+	 // another task calls vTaskResume( xHandle ).

+

+	 //...

+

+

+	 // Suspend ourselves.

+	 vTaskSuspend( NULL );

+

+	 // We cannot get here unless another task calls vTaskResume

+	 // with our handle as the parameter.

+ }

+   </pre>

+ * \defgroup vTaskSuspend vTaskSuspend

+ * \ingroup TaskCtrl

+ */

+void vTaskSuspend( xTaskHandle pxTaskToSuspend ) PRIVILEGED_FUNCTION;

+

+/**

+ * task. h

+ * <pre>void vTaskResume( xTaskHandle pxTaskToResume );</pre>

+ *

+ * INCLUDE_vTaskSuspend must be defined as 1 for this function to be available.

+ * See the configuration section for more information.

+ *

+ * Resumes a suspended task.

+ *

+ * A task that has been suspended by one of more calls to vTaskSuspend ()

+ * will be made available for running again by a single call to

+ * vTaskResume ().

+ *

+ * @param pxTaskToResume Handle to the task being readied.

+ *

+ * 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 );

+

+	 // ...

+

+	 // The created task will not run during this period, unless

+	 // another task calls vTaskResume( xHandle ).

+

+	 //...

+

+

+	 // Resume the suspended task ourselves.

+	 vTaskResume( xHandle );

+

+	 // The created task will once again get microcontroller processing

+	 // time in accordance with it priority within the system.

+ }

+   </pre>

+ * \defgroup vTaskResume vTaskResume

+ * \ingroup TaskCtrl

+ */

+void vTaskResume( xTaskHandle pxTaskToResume ) PRIVILEGED_FUNCTION;

+

+/**

+ * task. h

+ * <pre>void xTaskResumeFromISR( xTaskHandle pxTaskToResume );</pre>

+ *

+ * INCLUDE_xTaskResumeFromISR must be defined as 1 for this function to be

+ * available.  See the configuration section for more information.

+ *

+ * An implementation of vTaskResume() that can be called from within an ISR.

+ *

+ * A task that has been suspended by one of more calls to vTaskSuspend ()

+ * will be made available for running again by a single call to

+ * xTaskResumeFromISR ().

+ *

+ * @param pxTaskToResume Handle to the task being readied.

+ *

+ * \defgroup vTaskResumeFromISR vTaskResumeFromISR

+ * \ingroup TaskCtrl

+ */

+portBASE_TYPE xTaskResumeFromISR( xTaskHandle pxTaskToResume ) PRIVILEGED_FUNCTION;

+

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

+ * SCHEDULER CONTROL

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

+

+/**

+ * task. h

+ * <pre>void vTaskStartScheduler( void );</pre>

+ *

+ * Starts the real time kernel tick processing.  After calling the kernel

+ * has control over which tasks are executed and when.  This function

+ * does not return until an executing task calls vTaskEndScheduler ().

+ *

+ * At least one task should be created via a call to xTaskCreate ()

+ * before calling vTaskStartScheduler ().  The idle task is created

+ * automatically when the first application task is created.

+ *

+ * See the demo application file main.c for an example of creating

+ * tasks and starting the kernel.

+ *

+ * Example usage:

+   <pre>

+ void vAFunction( void )

+ {

+	 // Create at least one task before starting the kernel.

+	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );

+

+	 // Start the real time kernel with preemption.

+	 vTaskStartScheduler ();

+

+	 // Will not get here unless a task calls vTaskEndScheduler ()

+ }

+   </pre>

+ *

+ * \defgroup vTaskStartScheduler vTaskStartScheduler

+ * \ingroup SchedulerControl

+ */

+void vTaskStartScheduler( void ) PRIVILEGED_FUNCTION;

+

+/**

+ * task. h

+ * <pre>void vTaskEndScheduler( void );</pre>

+ *

+ * Stops the real time kernel tick.  All created tasks will be automatically

+ * deleted and multitasking (either preemptive or cooperative) will

+ * stop.  Execution then resumes from the point where vTaskStartScheduler ()

+ * was called, as if vTaskStartScheduler () had just returned.

+ *

+ * See the demo application file main. c in the demo/PC directory for an

+ * example that uses vTaskEndScheduler ().

+ *

+ * vTaskEndScheduler () requires an exit function to be defined within the

+ * portable layer (see vPortEndScheduler () in port. c for the PC port).  This

+ * performs hardware specific operations such as stopping the kernel tick.

+ *

+ * vTaskEndScheduler () will cause all of the resources allocated by the

+ * kernel to be freed - but will not free resources allocated by application

+ * tasks.

+ *

+ * Example usage:

+   <pre>

+ void vTaskCode( void * pvParameters )

+ {

+	 for( ;; )

+	 {

+		 // Task code goes here.

+

+		 // At some point we want to end the real time kernel processing

+		 // so call ...

+		 vTaskEndScheduler ();

+	 }

+ }

+

+ void vAFunction( void )

+ {

+	 // Create at least one task before starting the kernel.

+	 xTaskCreate( vTaskCode, "NAME", STACK_SIZE, NULL, tskIDLE_PRIORITY, NULL );

+

+	 // Start the real time kernel with preemption.

+	 vTaskStartScheduler ();

+

+	 // Will only get here when the vTaskCode () task has called

+	 // vTaskEndScheduler ().  When we get here we are back to single task

+	 // execution.

+ }

+   </pre>

+ *

+ * \defgroup vTaskEndScheduler vTaskEndScheduler

+ * \ingroup SchedulerControl

+ */

+void vTaskEndScheduler( void ) PRIVILEGED_FUNCTION;

+

+/**

+ * task. h

+ * <pre>void vTaskSuspendAll( void );</pre>

+ *

+ * Suspends all real time kernel activity while keeping interrupts (including the

+ * kernel tick) enabled.

+ *

+ * After calling vTaskSuspendAll () the calling task will continue to execute

+ * without risk of being swapped out until a call to xTaskResumeAll () has been

+ * made.

+ *

+ * API functions that have the potential to cause a context switch (for example,

+ * vTaskDelayUntil(), xQueueSend(), etc.) must not be called while the scheduler

+ * is suspended.

+ *

+ * Example usage:

+   <pre>

+ void vTask1( void * pvParameters )

+ {

+	 for( ;; )

+	 {

+		 // Task code goes here.

+

+		 // ...

+

+		 // At some point the task wants to perform a long operation during

+		 // which it does not want to get swapped out.  It cannot use

+		 // taskENTER_CRITICAL ()/taskEXIT_CRITICAL () as the length of the

+		 // operation may cause interrupts to be missed - including the

+		 // ticks.

+

+		 // Prevent the real time kernel swapping out the task.

+		 vTaskSuspendAll ();

+

+		 // Perform the operation here.  There is no need to use critical

+		 // sections as we have all the microcontroller processing time.

+		 // During this time interrupts will still operate and the kernel

+		 // tick count will be maintained.

+

+		 // ...

+

+		 // The operation is complete.  Restart the kernel.

+		 xTaskResumeAll ();

+	 }

+ }

+   </pre>

+ * \defgroup vTaskSuspendAll vTaskSuspendAll

+ * \ingroup SchedulerControl

+ */

+void vTaskSuspendAll( void ) PRIVILEGED_FUNCTION;

+

+/**

+ * task. h

+ * <pre>char xTaskResumeAll( void );</pre>

+ *

+ * Resumes real time kernel activity following a call to vTaskSuspendAll ().

+ * After a call to vTaskSuspendAll () the kernel will take control of which

+ * task is executing at any time.

+ *

+ * @return If resuming the scheduler caused a context switch then pdTRUE is

+ *		  returned, otherwise pdFALSE is returned.

+ *

+ * Example usage:

+   <pre>

+ void vTask1( void * pvParameters )

+ {

+	 for( ;; )

+	 {

+		 // Task code goes here.

+

+		 // ...

+

+		 // At some point the task wants to perform a long operation during

+		 // which it does not want to get swapped out.  It cannot use

+		 // taskENTER_CRITICAL ()/taskEXIT_CRITICAL () as the length of the

+		 // operation may cause interrupts to be missed - including the

+		 // ticks.

+

+		 // Prevent the real time kernel swapping out the task.

+		 vTaskSuspendAll ();

+

+		 // Perform the operation here.  There is no need to use critical

+		 // sections as we have all the microcontroller processing time.

+		 // During this time interrupts will still operate and the real

+		 // time kernel tick count will be maintained.

+

+		 // ...

+

+		 // The operation is complete.  Restart the kernel.  We want to force

+		 // a context switch - but there is no point if resuming the scheduler

+		 // caused a context switch already.

+		 if( !xTaskResumeAll () )

+		 {

+			  taskYIELD ();

+		 }

+	 }

+ }

+   </pre>

+ * \defgroup xTaskResumeAll xTaskResumeAll

+ * \ingroup SchedulerControl

+ */

+signed portBASE_TYPE xTaskResumeAll( void ) PRIVILEGED_FUNCTION;

+

+/**

+ * task. h

+ * <pre>signed portBASE_TYPE xTaskIsTaskSuspended( xTaskHandle xTask );</pre>

+ *

+ * Utility task that simply returns pdTRUE if the task referenced by xTask is

+ * currently in the Suspended state, or pdFALSE if the task referenced by xTask

+ * is in any other state.

+ *

+ */

+signed portBASE_TYPE xTaskIsTaskSuspended( xTaskHandle xTask ) PRIVILEGED_FUNCTION;

+

+/**

+ * task. h

+ * <pre>signed portBASE_TYPE xTaskIsTaskFinished( xTaskHandle xTask );</pre>

+ *

+ * Utility task that simply returns pdTRUE if the task has terminated.

+ *

+ */

+signed portBASE_TYPE xTaskIsTaskFinished( xTaskHandle xTask ) PRIVILEGED_FUNCTION;

+

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

+ * TASK UTILITIES

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

+

+/**

+ * task. h

+ * <PRE>portTickType xTaskGetTickCount( void );</PRE>

+ *

+ * @return The count of ticks since vTaskStartScheduler was called.

+ *

+ * \page xTaskGetTickCount xTaskGetTickCount

+ * \ingroup TaskUtils

+ */

+portTickType xTaskGetTickCount( void ) PRIVILEGED_FUNCTION;

+

+/**

+ * task. h

+ * <PRE>portTickType xTaskGetTickCountFromISR( void );</PRE>

+ *

+ * @return The count of ticks since vTaskStartScheduler was called.

+ *

+ * This is a version of xTaskGetTickCount() that is safe to be called from an

+ * ISR - provided that portTickType is the natural word size of the

+ * microcontroller being used or interrupt nesting is either not supported or

+ * not being used.

+ *

+ * \page xTaskGetTickCount xTaskGetTickCount

+ * \ingroup TaskUtils

+ */

+portTickType xTaskGetTickCountFromISR( void ) PRIVILEGED_FUNCTION;

+

+/**

+ * task. h

+ * <PRE>unsigned short uxTaskGetNumberOfTasks( void );</PRE>

+ *

+ * @return The number of tasks that the real time kernel is currently managing.

+ * This includes all ready, blocked and suspended tasks.  A task that

+ * has been deleted but not yet freed by the idle task will also be

+ * included in the count.

+ *

+ * \page uxTaskGetNumberOfTasks uxTaskGetNumberOfTasks

+ * \ingroup TaskUtils

+ */

+unsigned portBASE_TYPE uxTaskGetNumberOfTasks( void ) PRIVILEGED_FUNCTION;

+

+/**

+ * task. h

+ * <PRE>signed char *pcTaskGetTaskName( xTaskHandle xTaskToQuery );</PRE>

+ *

+ * @return The text (human readable) name of the task referenced by the handle

+ * xTaskToQueury.  A task can query its own name by either passing in its own

+ * handle, or by setting xTaskToQuery to NULL.  INCLUDE_pcTaskGetTaskName must be

+ * set to 1 in FreeRTOSConfig.h for pcTaskGetTaskName() to be available.

+ *

+ * \page pcTaskGetTaskName pcTaskGetTaskName

+ * \ingroup TaskUtils

+ */

+signed char *pcTaskGetTaskName( xTaskHandle xTaskToQuery );

+

+/**

+ * task. h

+ * <PRE>void vTaskList( char *pcWriteBuffer );</PRE>

+ *

+ * configUSE_TRACE_FACILITY must be defined as 1 for this function to be

+ * available.  See the configuration section for more information.

+ *

+ * NOTE: This function will disable interrupts for its duration.  It is

+ * not intended for normal application runtime use but as a debug aid.

+ *

+ * Lists all the current tasks, along with their current state and stack

+ * usage high water mark.

+ *

+ * Tasks are reported as blocked ('B'), ready ('R'), deleted ('D') or

+ * suspended ('S').

+ *

+ * @param pcWriteBuffer A buffer into which the above mentioned details

+ * will be written, in ascii form.  This buffer is assumed to be large

+ * enough to contain the generated report.  Approximately 40 bytes per

+ * task should be sufficient.

+ *

+ * \page vTaskList vTaskList

+ * \ingroup TaskUtils

+ */

+void vTaskList( signed char *pcWriteBuffer ) PRIVILEGED_FUNCTION;

+void vTaskList1(void (*pmCallback)(volatile void *pxPCB, signed char cStatus) ) PRIVILEGED_FUNCTION;

+

+/**

+ * task. h

+ * <PRE>void vTaskGetRunTimeStats( char *pcWriteBuffer );</PRE>

+ *

+ * configGENERATE_RUN_TIME_STATS must be defined as 1 for this function

+ * to be available.  The application must also then provide definitions

+ * for portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() and

+ * portGET_RUN_TIME_COUNTER_VALUE to configure a peripheral timer/counter

+ * and return the timers current count value respectively.  The counter

+ * should be at least 10 times the frequency of the tick count.

+ *

+ * NOTE: This function will disable interrupts for its duration.  It is

+ * not intended for normal application runtime use but as a debug aid.

+ *

+ * Setting configGENERATE_RUN_TIME_STATS to 1 will result in a total

+ * accumulated execution time being stored for each task.  The resolution

+ * of the accumulated time value depends on the frequency of the timer

+ * configured by the portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() macro.

+ * Calling vTaskGetRunTimeStats() writes the total execution time of each

+ * task into a buffer, both as an absolute count value and as a percentage

+ * of the total system execution time.

+ *

+ * @param pcWriteBuffer A buffer into which the execution times will be

+ * written, in ascii form.  This buffer is assumed to be large enough to

+ * contain the generated report.  Approximately 40 bytes per task should

+ * be sufficient.

+ *

+ * \page vTaskGetRunTimeStats vTaskGetRunTimeStats

+ * \ingroup TaskUtils

+ */

+void vTaskGetRunTimeStats( signed char *pcWriteBuffer ) PRIVILEGED_FUNCTION;

+

+/**

+ * task.h

+ * <PRE>unsigned portBASE_TYPE uxTaskGetStackHighWaterMark( xTaskHandle xTask );</PRE>

+ *

+ * INCLUDE_uxTaskGetStackHighWaterMark must be set to 1 in FreeRTOSConfig.h for

+ * this function to be available.

+ *

+ * Returns the high water mark of the stack associated with xTask.  That is,

+ * the minimum free stack space there has been (in words, so on a 32 bit machine

+ * a value of 1 means 4 bytes) since the task started.  The smaller the returned

+ * number the closer the task has come to overflowing its stack.

+ *

+ * @param xTask Handle of the task associated with the stack to be checked.

+ * Set xTask to NULL to check the stack of the calling task.

+ *

+ * @return The smallest amount of free stack space there has been (in bytes)

+ * since the task referenced by xTask was created.

+ */

+unsigned portBASE_TYPE uxTaskGetStackHighWaterMark( xTaskHandle xTask ) PRIVILEGED_FUNCTION;

+

+/* When using trace macros it is sometimes necessary to include tasks.h before

+FreeRTOS.h.  When this is done pdTASK_HOOK_CODE will not yet have been defined,

+so the following two prototypes will cause a compilation error.  This can be

+fixed by simply guarding against the inclusion of these two prototypes unless

+they are explicitly required by the configUSE_APPLICATION_TASK_TAG configuration

+constant. */

+#ifdef configUSE_APPLICATION_TASK_TAG

+	#if configUSE_APPLICATION_TASK_TAG == 1

+		/**

+		 * task.h

+		 * <pre>void vTaskSetApplicationTaskTag( xTaskHandle xTask, pdTASK_HOOK_CODE pxHookFunction );</pre>

+		 *

+		 * Sets pxHookFunction to be the task hook function used by the task xTask.

+		 * Passing xTask as NULL has the effect of setting the calling tasks hook

+		 * function.

+		 */

+		void vTaskSetApplicationTaskTag( xTaskHandle xTask, pdTASK_HOOK_CODE pxHookFunction ) PRIVILEGED_FUNCTION;

+

+		/**

+		 * task.h

+		 * <pre>void xTaskGetApplicationTaskTag( xTaskHandle xTask );</pre>

+		 *

+		 * Returns the pxHookFunction value assigned to the task xTask.

+		 */

+		pdTASK_HOOK_CODE xTaskGetApplicationTaskTag( xTaskHandle xTask ) PRIVILEGED_FUNCTION;

+	#endif /* configUSE_APPLICATION_TASK_TAG ==1 */

+#endif /* ifdef configUSE_APPLICATION_TASK_TAG */

+

+/**

+ * task.h

+ * <pre>portBASE_TYPE xTaskCallApplicationTaskHook( xTaskHandle xTask, pdTASK_HOOK_CODE pxHookFunction );</pre>

+ *

+ * Calls the hook function associated with xTask.  Passing xTask as NULL has

+ * the effect of calling the Running tasks (the calling task) hook function.

+ *

+ * pvParameter is passed to the hook function for the task to interpret as it

+ * wants.

+ */

+portBASE_TYPE xTaskCallApplicationTaskHook( xTaskHandle xTask, void *pvParameter ) PRIVILEGED_FUNCTION;

+

+/**

+ * xTaskGetIdleTaskHandle() is only available if 

+ * INCLUDE_xTaskGetIdleTaskHandle is set to 1 in FreeRTOSConfig.h.

+ *

+ * Simply returns the handle of the idle task.  It is not valid to call

+ * xTaskGetIdleTaskHandle() before the scheduler has been started.

+ */

+xTaskHandle xTaskGetIdleTaskHandle( void );

+

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

+ * SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES

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

+

+/*

+ * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS ONLY

+ * INTENDED FOR USE WHEN IMPLEMENTING A PORT OF THE SCHEDULER AND IS

+ * AN INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.

+ *

+ * Called from the real time kernel tick (either preemptive or cooperative),

+ * this increments the tick count and checks if any tasks that are blocked

+ * for a finite period required removing from a blocked list and placing on

+ * a ready list.

+ */

+void vTaskIncrementTick( void ) PRIVILEGED_FUNCTION;

+

+/*

+ * Ported from FreeRTOSV8.0.1 to support k24 VLPS mode

+ * If tickless mode is being used, or a low power mode is implemented, then

+ * the tick interrupt will not execute during idle periods.  When this is the

+ * case, the tick count value maintained by the scheduler needs to be kept up

+ * to date with the actual execution time by being skipped forward by a time

+ * equal to the idle period.

+ */

+void vTaskStepTick( const portTickType xTicksToJump );

+

+/*

+ * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS AN

+ * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.

+ *

+ * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED.

+ *

+ * Removes the calling task from the ready list and places it both

+ * on the list of tasks waiting for a particular event, and the

+ * list of delayed tasks.  The task will be removed from both lists

+ * and replaced on the ready list should either the event occur (and

+ * there be no higher priority tasks waiting on the same event) or

+ * the delay period expires.

+ *

+ * @param pxEventList The list containing tasks that are blocked waiting

+ * for the event to occur.

+ *

+ * @param xTicksToWait The maximum amount of time that the task should wait

+ * for the event to occur.  This is specified in kernel ticks,the constant

+ * portTICK_RATE_MS can be used to convert kernel ticks into a real time

+ * period.

+ */

+void vTaskPlaceOnEventList( const xList * const pxEventList, portTickType xTicksToWait ) PRIVILEGED_FUNCTION;

+

+/*

+ * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS AN

+ * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.

+ *

+ * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED.

+ *

+ * This function performs nearly the same function as vTaskPlaceOnEventList().

+ * The difference being that this function does not permit tasks to block

+ * indefinitely, whereas vTaskPlaceOnEventList() does.

+ *

+ * @return pdTRUE if the task being removed has a higher priority than the task

+ * making the call, otherwise pdFALSE.

+ */

+void vTaskPlaceOnEventListRestricted( const xList * const pxEventList, portTickType xTicksToWait ) PRIVILEGED_FUNCTION;

+

+/*

+ * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS AN

+ * INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.

+ *

+ * THIS FUNCTION MUST BE CALLED WITH INTERRUPTS DISABLED.

+ *

+ * Removes a task from both the specified event list and the list of blocked

+ * tasks, and places it on a ready queue.

+ *

+ * xTaskRemoveFromEventList () will be called if either an event occurs to

+ * unblock a task, or the block timeout period expires.

+ *

+ * @return pdTRUE if the task being removed has a higher priority than the task

+ * making the call, otherwise pdFALSE.

+ */

+signed portBASE_TYPE xTaskRemoveFromEventList( const xList * const pxEventList ) PRIVILEGED_FUNCTION;

+

+/*

+ * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS ONLY

+ * INTENDED FOR USE WHEN IMPLEMENTING A PORT OF THE SCHEDULER AND IS

+ * AN INTERFACE WHICH IS FOR THE EXCLUSIVE USE OF THE SCHEDULER.

+ *

+ * Sets the pointer to the current TCB to the TCB of the highest priority task

+ * that is ready to run.

+ */

+void vTaskSwitchContext( void ) PRIVILEGED_FUNCTION;

+

+/*

+ * Return the handle of the calling task.

+ */

+xTaskHandle xTaskGetCurrentTaskHandle( void ) PRIVILEGED_FUNCTION;

+

+/*

+ * Capture the current time status for future reference.

+ */

+void vTaskSetTimeOutState( xTimeOutType * const pxTimeOut ) PRIVILEGED_FUNCTION;

+

+/*

+ * Compare the time status now with that previously captured to see if the

+ * timeout has expired.

+ */

+portBASE_TYPE xTaskCheckForTimeOut( xTimeOutType * const pxTimeOut, portTickType * const pxTicksToWait ) PRIVILEGED_FUNCTION;

+

+/*

+ * Shortcut used by the queue implementation to prevent unnecessary call to

+ * taskYIELD();

+ */

+void vTaskMissedYield( void ) PRIVILEGED_FUNCTION;

+

+/*

+ * Returns the scheduler state as taskSCHEDULER_RUNNING,

+ * taskSCHEDULER_NOT_STARTED or taskSCHEDULER_SUSPENDED.

+ */

+portBASE_TYPE xTaskGetSchedulerState( void ) PRIVILEGED_FUNCTION;

+

+/*

+ * Raises the priority of the mutex holder to that of the calling task should

+ * the mutex holder have a priority less than the calling task.

+ */

+void vTaskPriorityInherit( xTaskHandle * const pxMutexHolder ) PRIVILEGED_FUNCTION;

+

+/*

+ * Set the priority of a task back to its proper priority in the case that it

+ * inherited a higher priority while it was holding a semaphore.

+ */

+void vTaskPriorityDisinherit( xTaskHandle * const pxMutexHolder ) PRIVILEGED_FUNCTION;

+

+/*

+ * Generic version of the task creation function which is in turn called by the

+ * xTaskCreate() and xTaskCreateRestricted() macros.

+ */

+signed portBASE_TYPE xTaskGenericCreate( pdTASK_CODE pxTaskCode, const signed char * const pcName, unsigned short usStackDepth, void *pvParameters, unsigned portBASE_TYPE uxPriority, xTaskHandle *pxCreatedTask, portSTACK_TYPE *puxStackBuffer, const xMemoryRegion * const xRegions ) PRIVILEGED_FUNCTION;

+

+/*

+ * Get the uxTCBNumber assigned to the task referenced by the xTask parameter.

+ */

+unsigned portBASE_TYPE uxTaskGetTaskNumber( xTaskHandle xTask );

+

+/* 

+ * Set the uxTCBNumber of the task referenced by the xTask parameter to

+ * ucHandle.

+ */

+void vTaskSetTaskNumber( xTaskHandle xTask, unsigned portBASE_TYPE uxHandle );

+

+

+#ifdef __cplusplus

+}

+#endif

+#endif /* TASK_H */

+

+

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/include/timers.h b/FreeRTOSV7.2.0/FreeRTOS/Source/include/timers.h
new file mode 100644
index 0000000..5f62368
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/include/timers.h
@@ -0,0 +1,952 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+

+#ifndef TIMERS_H

+#define TIMERS_H

+

+#ifndef INC_FREERTOS_H

+	#error "include FreeRTOS.h must appear in source files before include timers.h"

+#endif

+

+#include "portable.h"

+#include "list.h"

+#include "task.h"

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

+/* IDs for commands that can be sent/received on the timer queue.  These are to

+be used solely through the macros that make up the public software timer API,

+as defined below. */

+#define tmrCOMMAND_START					0

+#define tmrCOMMAND_STOP						1

+#define tmrCOMMAND_CHANGE_PERIOD			2

+#define tmrCOMMAND_DELETE					3

+

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

+ * MACROS AND DEFINITIONS

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

+

+ /**

+ * Type by which software timers are referenced.  For example, a call to

+ * xTimerCreate() returns an xTimerHandle variable that can then be used to

+ * reference the subject timer in calls to other software timer API functions

+ * (for example, xTimerStart(), xTimerReset(), etc.).

+ */

+typedef void * xTimerHandle;

+

+/* Define the prototype to which timer callback functions must conform. */

+typedef void (*tmrTIMER_CALLBACK)( xTimerHandle xTimer );

+

+/**

+ * xTimerHandle xTimerCreate( 	const signed char *pcTimerName,

+ * 								portTickType xTimerPeriodInTicks,

+ * 								unsigned portBASE_TYPE uxAutoReload,

+ * 								void * pvTimerID,

+ * 								tmrTIMER_CALLBACK pxCallbackFunction );

+ *

+ * Creates a new software timer instance.  This allocates the storage required

+ * by the new timer, initialises the new timers internal state, and returns a

+ * handle by which the new timer can be referenced.

+ *

+ * Timers are created in the dormant state.  The xTimerStart(), xTimerReset(),

+ * xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and

+ * xTimerChangePeriodFromISR() API functions can all be used to transition a timer into the

+ * active state.

+ *

+ * @param pcTimerName A text name that is assigned to the timer.  This is done

+ * purely to assist debugging.  The kernel itself only ever references a timer by

+ * its handle, and never by its name.

+ *

+ * @param xTimerPeriodInTicks The timer period.  The time is defined in tick periods so

+ * the constant portTICK_RATE_MS can be used to convert a time that has been

+ * specified in milliseconds.  For example, if the timer must expire after 100

+ * ticks, then xTimerPeriodInTicks should be set to 100.  Alternatively, if the timer

+ * must expire after 500ms, then xPeriod can be set to ( 500 / portTICK_RATE_MS )

+ * provided configTICK_RATE_HZ is less than or equal to 1000.

+ *

+ * @param uxAutoReload If uxAutoReload is set to pdTRUE then the timer will

+ * expire repeatedly with a frequency set by the xTimerPeriodInTicks parameter.  If

+ * uxAutoReload is set to pdFALSE then the timer will be a one-shot timer and

+ * enter the dormant state after it expires.

+ *

+ * @param pvTimerID An identifier that is assigned to the timer being created.

+ * Typically this would be used in the timer callback function to identify which

+ * timer expired when the same callback function is assigned to more than one

+ * timer.

+ *

+ * @param pxCallbackFunction The function to call when the timer expires.

+ * Callback functions must have the prototype defined by tmrTIMER_CALLBACK,

+ * which is	"void vCallbackFunction( xTimerHandle xTimer );".

+ *

+ * @return If the timer is successfully create then a handle to the newly

+ * created timer is returned.  If the timer cannot be created (because either

+ * there is insufficient FreeRTOS heap remaining to allocate the timer

+ * structures, or the timer period was set to 0) then 0 is returned.

+ *

+ * Example usage:

+ *

+ * #define NUM_TIMERS 5

+ *

+ * // An array to hold handles to the created timers.

+ * xTimerHandle xTimers[ NUM_TIMERS ];

+ *

+ * // An array to hold a count of the number of times each timer expires.

+ * long lExpireCounters[ NUM_TIMERS ] = { 0 };

+ *

+ * // Define a callback function that will be used by multiple timer instances.

+ * // The callback function does nothing but count the number of times the

+ * // associated timer expires, and stop the timer once the timer has expired

+ * // 10 times.

+ * void vTimerCallback( xTimerHandle pxTimer )

+ * {

+ * long lArrayIndex;

+ * const long xMaxExpiryCountBeforeStopping = 10;

+ *

+ * 	   // Optionally do something if the pxTimer parameter is NULL.

+ * 	   configASSERT( pxTimer );

+ * 	

+ *     // Which timer expired?

+ *     lArrayIndex = ( long ) pvTimerGetTimerID( pxTimer );

+ *

+ *     // Increment the number of times that pxTimer has expired.

+ *     lExpireCounters[ lArrayIndex ] += 1;

+ *

+ *     // If the timer has expired 10 times then stop it from running.

+ *     if( lExpireCounters[ lArrayIndex ] == xMaxExpiryCountBeforeStopping )

+ *     {

+ *         // Do not use a block time if calling a timer API function from a

+ *         // timer callback function, as doing so could cause a deadlock!

+ *         xTimerStop( pxTimer, 0 );

+ *     }

+ * }

+ *

+ * void main( void )

+ * {

+ * long x;

+ *

+ *     // Create then start some timers.  Starting the timers before the scheduler

+ *     // has been started means the timers will start running immediately that

+ *     // the scheduler starts.

+ *     for( x = 0; x < NUM_TIMERS; x++ )

+ *     {

+ *         xTimers[ x ] = xTimerCreate(     "Timer",         // Just a text name, not used by the kernel.

+ *                                         ( 100 * x ),     // The timer period in ticks.

+ *                                         pdTRUE,         // The timers will auto-reload themselves when they expire.

+ *                                         ( void * ) x,     // Assign each timer a unique id equal to its array index.

+ *                                         vTimerCallback     // Each timer calls the same callback when it expires.

+ *                                     );

+ *

+ *         if( xTimers[ x ] == NULL )

+ *         {

+ *             // The timer was not created.

+ *         }

+ *         else

+ *         {

+ *             // Start the timer.  No block time is specified, and even if one was

+ *             // it would be ignored because the scheduler has not yet been

+ *             // started.

+ *             if( xTimerStart( xTimers[ x ], 0 ) != pdPASS )

+ *             {

+ *                 // The timer could not be set into the Active state.

+ *             }

+ *         }

+ *     }

+ *

+ *     // ...

+ *     // Create tasks here.

+ *     // ...

+ *

+ *     // Starting the scheduler will start the timers running as they have already

+ *     // been set into the active state.

+ *     xTaskStartScheduler();

+ *

+ *     // Should not reach here.

+ *     for( ;; );

+ * }

+ */

+xTimerHandle xTimerCreate( const signed char *pcTimerName, portTickType xTimerPeriodInTicks, unsigned portBASE_TYPE uxAutoReload, void * pvTimerID, tmrTIMER_CALLBACK pxCallbackFunction ) PRIVILEGED_FUNCTION;

+

+/**

+ * void *pvTimerGetTimerID( xTimerHandle xTimer );

+ *

+ * Returns the ID assigned to the timer.

+ *

+ * IDs are assigned to timers using the pvTimerID parameter of the call to

+ * xTimerCreated() that was used to create the timer.

+ *

+ * If the same callback function is assigned to multiple timers then the timer

+ * ID can be used within the callback function to identify which timer actually

+ * expired.

+ *

+ * @param xTimer The timer being queried.

+ *

+ * @return The ID assigned to the timer being queried.

+ *

+ * Example usage:

+ *

+ * See the xTimerCreate() API function example usage scenario.

+ */

+void *pvTimerGetTimerID( xTimerHandle xTimer ) PRIVILEGED_FUNCTION;

+

+/**

+ * portBASE_TYPE xTimerIsTimerActive( xTimerHandle xTimer );

+ *

+ * Queries a timer to see if it is active or dormant.

+ *

+ * A timer will be dormant if:

+ *     1) It has been created but not started, or

+ *     2) It is an expired on-shot timer that has not been restarted.

+ *

+ * Timers are created in the dormant state.  The xTimerStart(), xTimerReset(),

+ * xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and

+ * xTimerChangePeriodFromISR() API functions can all be used to transition a timer into the

+ * active state.

+ *

+ * @param xTimer The timer being queried.

+ *

+ * @return pdFALSE will be returned if the timer is dormant.  A value other than

+ * pdFALSE will be returned if the timer is active.

+ *

+ * Example usage:

+ *

+ * // This function assumes xTimer has already been created.

+ * void vAFunction( xTimerHandle xTimer )

+ * {

+ *     if( xTimerIsTimerActive( xTimer ) != pdFALSE ) // or more simply and equivalently "if( xTimerIsTimerActive( xTimer ) )"

+ *     {

+ *         // xTimer is active, do something.

+ *     }

+ *     else

+ *     {

+ *         // xTimer is not active, do something else.

+ *     }

+ * }

+ */

+portBASE_TYPE xTimerIsTimerActive( xTimerHandle xTimer ) PRIVILEGED_FUNCTION;

+

+/**

+ * xTimerGetTimerDaemonTaskHandle() is only available if 

+ * INCLUDE_xTimerGetTimerDaemonTaskHandle is set to 1 in FreeRTOSConfig.h.

+ *

+ * Simply returns the handle of the timer service/daemon task.  It it not valid

+ * to call xTimerGetTimerDaemonTaskHandle() before the scheduler has been started.

+ */

+xTaskHandle xTimerGetTimerDaemonTaskHandle( void );

+

+/**

+ * portBASE_TYPE xTimerStart( xTimerHandle xTimer, portTickType xBlockTime );

+ *

+ * Timer functionality is provided by a timer service/daemon task.  Many of the

+ * public FreeRTOS timer API functions send commands to the timer service task

+ * though a queue called the timer command queue.  The timer command queue is

+ * private to the kernel itself and is not directly accessible to application

+ * code.  The length of the timer command queue is set by the

+ * configTIMER_QUEUE_LENGTH configuration constant.

+ *

+ * xTimerStart() starts a timer that was previously created using the

+ * xTimerCreate() API function.  If the timer had already been started and was

+ * already in the active state, then xTimerStart() has equivalent functionality

+ * to the xTimerReset() API function.

+ *

+ * Starting a timer ensures the timer is in the active state.  If the timer

+ * is not stopped, deleted, or reset in the mean time, the callback function

+ * associated with the timer will get called 'n' ticks after xTimerStart() was

+ * called, where 'n' is the timers defined period.

+ *

+ * It is valid to call xTimerStart() before the scheduler has been started, but

+ * when this is done the timer will not actually start until the scheduler is

+ * started, and the timers expiry time will be relative to when the scheduler is

+ * started, not relative to when xTimerStart() was called.

+ *

+ * The configUSE_TIMERS configuration constant must be set to 1 for xTimerStart()

+ * to be available.

+ *

+ * @param xTimer The handle of the timer being started/restarted.

+ *

+ * @param xBlockTime Specifies the time, in ticks, that the calling task should

+ * be held in the Blocked state to wait for the start command to be successfully

+ * sent to the timer command queue, should the queue already be full when

+ * xTimerStart() was called.  xBlockTime is ignored if xTimerStart() is called

+ * before the scheduler is started.

+ *

+ * @return pdFAIL will be returned if the start command could not be sent to

+ * the timer command queue even after xBlockTime ticks had passed.  pdPASS will

+ * be returned if the command was successfully sent to the timer command queue.

+ * When the command is actually processed will depend on the priority of the

+ * timer service/daemon task relative to other tasks in the system, although the

+ * timers expiry time is relative to when xTimerStart() is actually called.  The

+ * timer service/daemon task priority is set by the configTIMER_TASK_PRIORITY

+ * configuration constant.

+ *

+ * Example usage:

+ *

+ * See the xTimerCreate() API function example usage scenario.

+ *

+ */

+#define xTimerStart( xTimer, xBlockTime ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START, ( xTaskGetTickCount() ), NULL, ( xBlockTime ) )

+

+/**

+ * portBASE_TYPE xTimerStop( xTimerHandle xTimer, portTickType xBlockTime );

+ *

+ * Timer functionality is provided by a timer service/daemon task.  Many of the

+ * public FreeRTOS timer API functions send commands to the timer service task

+ * though a queue called the timer command queue.  The timer command queue is

+ * private to the kernel itself and is not directly accessible to application

+ * code.  The length of the timer command queue is set by the

+ * configTIMER_QUEUE_LENGTH configuration constant.

+ *

+ * xTimerStop() stops a timer that was previously started using either of the

+ * The xTimerStart(), xTimerReset(), xTimerStartFromISR(), xTimerResetFromISR(),

+ * xTimerChangePeriod() or xTimerChangePeriodFromISR() API functions.

+ *

+ * Stopping a timer ensures the timer is not in the active state.

+ *

+ * The configUSE_TIMERS configuration constant must be set to 1 for xTimerStop()

+ * to be available.

+ *

+ * @param xTimer The handle of the timer being stopped.

+ *

+ * @param xBlockTime Specifies the time, in ticks, that the calling task should

+ * be held in the Blocked state to wait for the stop command to be successfully

+ * sent to the timer command queue, should the queue already be full when

+ * xTimerStop() was called.  xBlockTime is ignored if xTimerStop() is called

+ * before the scheduler is started.

+ *

+ * @return pdFAIL will be returned if the stop command could not be sent to

+ * the timer command queue even after xBlockTime ticks had passed.  pdPASS will

+ * be returned if the command was successfully sent to the timer command queue.

+ * When the command is actually processed will depend on the priority of the

+ * timer service/daemon task relative to other tasks in the system.  The timer

+ * service/daemon task priority is set by the configTIMER_TASK_PRIORITY

+ * configuration constant.

+ *

+ * Example usage:

+ *

+ * See the xTimerCreate() API function example usage scenario.

+ *

+ */

+#define xTimerStop( xTimer, xBlockTime ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_STOP, 0U, NULL, ( xBlockTime ) )

+

+/**

+ * portBASE_TYPE xTimerChangePeriod( 	xTimerHandle xTimer,

+ *										portTickType xNewPeriod,

+ *										portTickType xBlockTime );

+ *

+ * Timer functionality is provided by a timer service/daemon task.  Many of the

+ * public FreeRTOS timer API functions send commands to the timer service task

+ * though a queue called the timer command queue.  The timer command queue is

+ * private to the kernel itself and is not directly accessible to application

+ * code.  The length of the timer command queue is set by the

+ * configTIMER_QUEUE_LENGTH configuration constant.

+ *

+ * xTimerChangePeriod() changes the period of a timer that was previously

+ * created using the xTimerCreate() API function.

+ *

+ * xTimerChangePeriod() can be called to change the period of an active or

+ * dormant state timer.

+ *

+ * The configUSE_TIMERS configuration constant must be set to 1 for

+ * xTimerChangePeriod() to be available.

+ *

+ * @param xTimer The handle of the timer that is having its period changed.

+ *

+ * @param xNewPeriod The new period for xTimer. Timer periods are specified in

+ * tick periods, so the constant portTICK_RATE_MS can be used to convert a time

+ * that has been specified in milliseconds.  For example, if the timer must

+ * expire after 100 ticks, then xNewPeriod should be set to 100.  Alternatively,

+ * if the timer must expire after 500ms, then xNewPeriod can be set to

+ * ( 500 / portTICK_RATE_MS ) provided configTICK_RATE_HZ is less than

+ * or equal to 1000.

+ *

+ * @param xBlockTime Specifies the time, in ticks, that the calling task should

+ * be held in the Blocked state to wait for the change period command to be

+ * successfully sent to the timer command queue, should the queue already be

+ * full when xTimerChangePeriod() was called.  xBlockTime is ignored if

+ * xTimerChangePeriod() is called before the scheduler is started.

+ *

+ * @return pdFAIL will be returned if the change period command could not be

+ * sent to the timer command queue even after xBlockTime ticks had passed.

+ * pdPASS will be returned if the command was successfully sent to the timer

+ * command queue.  When the command is actually processed will depend on the

+ * priority of the timer service/daemon task relative to other tasks in the

+ * system.  The timer service/daemon task priority is set by the

+ * configTIMER_TASK_PRIORITY configuration constant.

+ *

+ * Example usage:

+ *

+ * // This function assumes xTimer has already been created.  If the timer

+ * // referenced by xTimer is already active when it is called, then the timer

+ * // is deleted.  If the timer referenced by xTimer is not active when it is

+ * // called, then the period of the timer is set to 500ms and the timer is

+ * // started.

+ * void vAFunction( xTimerHandle xTimer )

+ * {

+ *     if( xTimerIsTimerActive( xTimer ) != pdFALSE ) // or more simply and equivalently "if( xTimerIsTimerActive( xTimer ) )"

+ *     {

+ *         // xTimer is already active - delete it.

+ *         xTimerDelete( xTimer );

+ *     }

+ *     else

+ *     {

+ *         // xTimer is not active, change its period to 500ms.  This will also

+ *         // cause the timer to start.  Block for a maximum of 100 ticks if the

+ *         // change period command cannot immediately be sent to the timer

+ *         // command queue.

+ *         if( xTimerChangePeriod( xTimer, 500 / portTICK_RATE_MS, 100 ) == pdPASS )

+ *         {

+ *             // The command was successfully sent.

+ *         }

+ *         else

+ *         {

+ *             // The command could not be sent, even after waiting for 100 ticks

+ *             // to pass.  Take appropriate action here.

+ *         }

+ *     }

+ * }

+ */

+ #define xTimerChangePeriod( xTimer, xNewPeriod, xBlockTime ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_CHANGE_PERIOD, ( xNewPeriod ), NULL, ( xBlockTime ) )

+

+/**

+ * portBASE_TYPE xTimerDelete( xTimerHandle xTimer, portTickType xBlockTime );

+ *

+ * Timer functionality is provided by a timer service/daemon task.  Many of the

+ * public FreeRTOS timer API functions send commands to the timer service task

+ * though a queue called the timer command queue.  The timer command queue is

+ * private to the kernel itself and is not directly accessible to application

+ * code.  The length of the timer command queue is set by the

+ * configTIMER_QUEUE_LENGTH configuration constant.

+ *

+ * xTimerDelete() deletes a timer that was previously created using the

+ * xTimerCreate() API function.

+ *

+ * The configUSE_TIMERS configuration constant must be set to 1 for

+ * xTimerDelete() to be available.

+ *

+ * @param xTimer The handle of the timer being deleted.

+ *

+ * @param xBlockTime Specifies the time, in ticks, that the calling task should

+ * be held in the Blocked state to wait for the delete command to be

+ * successfully sent to the timer command queue, should the queue already be

+ * full when xTimerDelete() was called.  xBlockTime is ignored if xTimerDelete()

+ * is called before the scheduler is started.

+ *

+ * @return pdFAIL will be returned if the delete command could not be sent to

+ * the timer command queue even after xBlockTime ticks had passed.  pdPASS will

+ * be returned if the command was successfully sent to the timer command queue.

+ * When the command is actually processed will depend on the priority of the

+ * timer service/daemon task relative to other tasks in the system.  The timer

+ * service/daemon task priority is set by the configTIMER_TASK_PRIORITY

+ * configuration constant.

+ *

+ * Example usage:

+ *

+ * See the xTimerChangePeriod() API function example usage scenario.

+ */

+#define xTimerDelete( xTimer, xBlockTime ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_DELETE, 0U, NULL, ( xBlockTime ) )

+

+/**

+ * portBASE_TYPE xTimerReset( xTimerHandle xTimer, portTickType xBlockTime );

+ *

+ * Timer functionality is provided by a timer service/daemon task.  Many of the

+ * public FreeRTOS timer API functions send commands to the timer service task

+ * though a queue called the timer command queue.  The timer command queue is

+ * private to the kernel itself and is not directly accessible to application

+ * code.  The length of the timer command queue is set by the

+ * configTIMER_QUEUE_LENGTH configuration constant.

+ *

+ * xTimerReset() re-starts a timer that was previously created using the

+ * xTimerCreate() API function.  If the timer had already been started and was

+ * already in the active state, then xTimerReset() will cause the timer to

+ * re-evaluate its expiry time so that it is relative to when xTimerReset() was

+ * called.  If the timer was in the dormant state then xTimerReset() has

+ * equivalent functionality to the xTimerStart() API function.

+ *

+ * Resetting a timer ensures the timer is in the active state.  If the timer

+ * is not stopped, deleted, or reset in the mean time, the callback function

+ * associated with the timer will get called 'n' ticks after xTimerReset() was

+ * called, where 'n' is the timers defined period.

+ *

+ * It is valid to call xTimerReset() before the scheduler has been started, but

+ * when this is done the timer will not actually start until the scheduler is

+ * started, and the timers expiry time will be relative to when the scheduler is

+ * started, not relative to when xTimerReset() was called.

+ *

+ * The configUSE_TIMERS configuration constant must be set to 1 for xTimerReset()

+ * to be available.

+ *

+ * @param xTimer The handle of the timer being reset/started/restarted.

+ *

+ * @param xBlockTime Specifies the time, in ticks, that the calling task should

+ * be held in the Blocked state to wait for the reset command to be successfully

+ * sent to the timer command queue, should the queue already be full when

+ * xTimerReset() was called.  xBlockTime is ignored if xTimerReset() is called

+ * before the scheduler is started.

+ *

+ * @return pdFAIL will be returned if the reset command could not be sent to

+ * the timer command queue even after xBlockTime ticks had passed.  pdPASS will

+ * be returned if the command was successfully sent to the timer command queue.

+ * When the command is actually processed will depend on the priority of the

+ * timer service/daemon task relative to other tasks in the system, although the

+ * timers expiry time is relative to when xTimerStart() is actually called.  The

+ * timer service/daemon task priority is set by the configTIMER_TASK_PRIORITY

+ * configuration constant.

+ *

+ * Example usage:

+ *

+ * // When a key is pressed, an LCD back-light is switched on.  If 5 seconds pass

+ * // without a key being pressed, then the LCD back-light is switched off.  In

+ * // this case, the timer is a one-shot timer.

+ *

+ * xTimerHandle xBacklightTimer = NULL;

+ *

+ * // The callback function assigned to the one-shot timer.  In this case the

+ * // parameter is not used.

+ * void vBacklightTimerCallback( xTimerHandle pxTimer )

+ * {

+ *     // The timer expired, therefore 5 seconds must have passed since a key

+ *     // was pressed.  Switch off the LCD back-light.

+ *     vSetBacklightState( BACKLIGHT_OFF );

+ * }

+ *

+ * // The key press event handler.

+ * void vKeyPressEventHandler( char cKey )

+ * {

+ *     // Ensure the LCD back-light is on, then reset the timer that is

+ *     // responsible for turning the back-light off after 5 seconds of

+ *     // key inactivity.  Wait 10 ticks for the command to be successfully sent

+ *     // if it cannot be sent immediately.

+ *     vSetBacklightState( BACKLIGHT_ON );

+ *     if( xTimerReset( xBacklightTimer, 100 ) != pdPASS )

+ *     {

+ *         // The reset command was not executed successfully.  Take appropriate

+ *         // action here.

+ *     }

+ *

+ *     // Perform the rest of the key processing here.

+ * }

+ *

+ * void main( void )

+ * {

+ * long x;

+ *

+ *     // Create then start the one-shot timer that is responsible for turning

+ *     // the back-light off if no keys are pressed within a 5 second period.

+ *     xBacklightTimer = xTimerCreate( "BacklightTimer",           // Just a text name, not used by the kernel.

+ *                                     ( 5000 / portTICK_RATE_MS), // The timer period in ticks.

+ *                                     pdFALSE,                    // The timer is a one-shot timer.

+ *                                     0,                          // The id is not used by the callback so can take any value.

+ *                                     vBacklightTimerCallback     // The callback function that switches the LCD back-light off.

+ *                                   );

+ *

+ *     if( xBacklightTimer == NULL )

+ *     {

+ *         // The timer was not created.

+ *     }

+ *     else

+ *     {

+ *         // Start the timer.  No block time is specified, and even if one was

+ *         // it would be ignored because the scheduler has not yet been

+ *         // started.

+ *         if( xTimerStart( xBacklightTimer, 0 ) != pdPASS )

+ *         {

+ *             // The timer could not be set into the Active state.

+ *         }

+ *     }

+ *

+ *     // ...

+ *     // Create tasks here.

+ *     // ...

+ *

+ *     // Starting the scheduler will start the timer running as it has already

+ *     // been set into the active state.

+ *     xTaskStartScheduler();

+ *

+ *     // Should not reach here.

+ *     for( ;; );

+ * }

+ */

+#define xTimerReset( xTimer, xBlockTime ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START, ( xTaskGetTickCount() ), NULL, ( xBlockTime ) )

+

+/**

+ * portBASE_TYPE xTimerStartFromISR( 	xTimerHandle xTimer,

+ *										portBASE_TYPE *pxHigherPriorityTaskWoken );

+ *

+ * A version of xTimerStart() that can be called from an interrupt service

+ * routine.

+ *

+ * @param xTimer The handle of the timer being started/restarted.

+ *

+ * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most

+ * of its time in the Blocked state, waiting for messages to arrive on the timer

+ * command queue.  Calling xTimerStartFromISR() writes a message to the timer

+ * command queue, so has the potential to transition the timer service/daemon

+ * task out of the Blocked state.  If calling xTimerStartFromISR() causes the

+ * timer service/daemon task to leave the Blocked state, and the timer service/

+ * daemon task has a priority equal to or greater than the currently executing

+ * task (the task that was interrupted), then *pxHigherPriorityTaskWoken will

+ * get set to pdTRUE internally within the xTimerStartFromISR() function.  If

+ * xTimerStartFromISR() sets this value to pdTRUE then a context switch should

+ * be performed before the interrupt exits.

+ *

+ * @return pdFAIL will be returned if the start command could not be sent to

+ * the timer command queue.  pdPASS will be returned if the command was

+ * successfully sent to the timer command queue.  When the command is actually

+ * processed will depend on the priority of the timer service/daemon task

+ * relative to other tasks in the system, although the timers expiry time is

+ * relative to when xTimerStartFromISR() is actually called.  The timer service/daemon

+ * task priority is set by the configTIMER_TASK_PRIORITY configuration constant.

+ *

+ * Example usage:

+ *

+ * // This scenario assumes xBacklightTimer has already been created.  When a

+ * // key is pressed, an LCD back-light is switched on.  If 5 seconds pass

+ * // without a key being pressed, then the LCD back-light is switched off.  In

+ * // this case, the timer is a one-shot timer, and unlike the example given for

+ * // the xTimerReset() function, the key press event handler is an interrupt

+ * // service routine.

+ *

+ * // The callback function assigned to the one-shot timer.  In this case the

+ * // parameter is not used.

+ * void vBacklightTimerCallback( xTimerHandle pxTimer )

+ * {

+ *     // The timer expired, therefore 5 seconds must have passed since a key

+ *     // was pressed.  Switch off the LCD back-light.

+ *     vSetBacklightState( BACKLIGHT_OFF );

+ * }

+ *

+ * // The key press interrupt service routine.

+ * void vKeyPressEventInterruptHandler( void )

+ * {

+ * portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;

+ *

+ *     // Ensure the LCD back-light is on, then restart the timer that is

+ *     // responsible for turning the back-light off after 5 seconds of

+ *     // key inactivity.  This is an interrupt service routine so can only

+ *     // call FreeRTOS API functions that end in "FromISR".

+ *     vSetBacklightState( BACKLIGHT_ON );

+ *

+ *     // xTimerStartFromISR() or xTimerResetFromISR() could be called here

+ *     // as both cause the timer to re-calculate its expiry time.

+ *     // xHigherPriorityTaskWoken was initialised to pdFALSE when it was

+ *     // declared (in this function).

+ *     if( xTimerStartFromISR( xBacklightTimer, &xHigherPriorityTaskWoken ) != pdPASS )

+ *     {

+ *         // The start command was not executed successfully.  Take appropriate

+ *         // action here.

+ *     }

+ *

+ *     // Perform the rest of the key processing here.

+ *

+ *     // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch

+ *     // should be performed.  The syntax required to perform a context switch

+ *     // from inside an ISR varies from port to port, and from compiler to

+ *     // compiler.  Inspect the demos for the port you are using to find the

+ *     // actual syntax required.

+ *     if( xHigherPriorityTaskWoken != pdFALSE )

+ *     {

+ *         // Call the interrupt safe yield function here (actual function

+ *         // depends on the FreeRTOS port being used.

+ *     }

+ * }

+ */

+#define xTimerStartFromISR( xTimer, pxHigherPriorityTaskWoken ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START, ( xTaskGetTickCountFromISR() ), ( pxHigherPriorityTaskWoken ), 0U )

+

+/**

+ * portBASE_TYPE xTimerStopFromISR( 	xTimerHandle xTimer,

+ *										portBASE_TYPE *pxHigherPriorityTaskWoken );

+ *

+ * A version of xTimerStop() that can be called from an interrupt service

+ * routine.

+ *

+ * @param xTimer The handle of the timer being stopped.

+ *

+ * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most

+ * of its time in the Blocked state, waiting for messages to arrive on the timer

+ * command queue.  Calling xTimerStopFromISR() writes a message to the timer

+ * command queue, so has the potential to transition the timer service/daemon

+ * task out of the Blocked state.  If calling xTimerStopFromISR() causes the

+ * timer service/daemon task to leave the Blocked state, and the timer service/

+ * daemon task has a priority equal to or greater than the currently executing

+ * task (the task that was interrupted), then *pxHigherPriorityTaskWoken will

+ * get set to pdTRUE internally within the xTimerStopFromISR() function.  If

+ * xTimerStopFromISR() sets this value to pdTRUE then a context switch should

+ * be performed before the interrupt exits.

+ *

+ * @return pdFAIL will be returned if the stop command could not be sent to

+ * the timer command queue.  pdPASS will be returned if the command was

+ * successfully sent to the timer command queue.  When the command is actually

+ * processed will depend on the priority of the timer service/daemon task

+ * relative to other tasks in the system.  The timer service/daemon task

+ * priority is set by the configTIMER_TASK_PRIORITY configuration constant.

+ *

+ * Example usage:

+ *

+ * // This scenario assumes xTimer has already been created and started.  When

+ * // an interrupt occurs, the timer should be simply stopped.

+ *

+ * // The interrupt service routine that stops the timer.

+ * void vAnExampleInterruptServiceRoutine( void )

+ * {

+ * portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;

+ *

+ *     // The interrupt has occurred - simply stop the timer.

+ *     // xHigherPriorityTaskWoken was set to pdFALSE where it was defined

+ *     // (within this function).  As this is an interrupt service routine, only

+ *     // FreeRTOS API functions that end in "FromISR" can be used.

+ *     if( xTimerStopFromISR( xTimer, &xHigherPriorityTaskWoken ) != pdPASS )

+ *     {

+ *         // The stop command was not executed successfully.  Take appropriate

+ *         // action here.

+ *     }

+ *

+ *     // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch

+ *     // should be performed.  The syntax required to perform a context switch

+ *     // from inside an ISR varies from port to port, and from compiler to

+ *     // compiler.  Inspect the demos for the port you are using to find the

+ *     // actual syntax required.

+ *     if( xHigherPriorityTaskWoken != pdFALSE )

+ *     {

+ *         // Call the interrupt safe yield function here (actual function

+ *         // depends on the FreeRTOS port being used.

+ *     }

+ * }

+ */

+#define xTimerStopFromISR( xTimer, pxHigherPriorityTaskWoken ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_STOP, 0, ( pxHigherPriorityTaskWoken ), 0U )

+

+/**

+ * portBASE_TYPE xTimerChangePeriodFromISR( xTimerHandle xTimer,

+ *											portTickType xNewPeriod,

+ *											portBASE_TYPE *pxHigherPriorityTaskWoken );

+ *

+ * A version of xTimerChangePeriod() that can be called from an interrupt

+ * service routine.

+ *

+ * @param xTimer The handle of the timer that is having its period changed.

+ *

+ * @param xNewPeriod The new period for xTimer. Timer periods are specified in

+ * tick periods, so the constant portTICK_RATE_MS can be used to convert a time

+ * that has been specified in milliseconds.  For example, if the timer must

+ * expire after 100 ticks, then xNewPeriod should be set to 100.  Alternatively,

+ * if the timer must expire after 500ms, then xNewPeriod can be set to

+ * ( 500 / portTICK_RATE_MS ) provided configTICK_RATE_HZ is less than

+ * or equal to 1000.

+ *

+ * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most

+ * of its time in the Blocked state, waiting for messages to arrive on the timer

+ * command queue.  Calling xTimerChangePeriodFromISR() writes a message to the

+ * timer command queue, so has the potential to transition the timer service/

+ * daemon task out of the Blocked state.  If calling xTimerChangePeriodFromISR()

+ * causes the timer service/daemon task to leave the Blocked state, and the

+ * timer service/daemon task has a priority equal to or greater than the

+ * currently executing task (the task that was interrupted), then

+ * *pxHigherPriorityTaskWoken will get set to pdTRUE internally within the

+ * xTimerChangePeriodFromISR() function.  If xTimerChangePeriodFromISR() sets

+ * this value to pdTRUE then a context switch should be performed before the

+ * interrupt exits.

+ *

+ * @return pdFAIL will be returned if the command to change the timers period

+ * could not be sent to the timer command queue.  pdPASS will be returned if the

+ * command was successfully sent to the timer command queue.  When the command

+ * is actually processed will depend on the priority of the timer service/daemon

+ * task relative to other tasks in the system.  The timer service/daemon task

+ * priority is set by the configTIMER_TASK_PRIORITY configuration constant.

+ *

+ * Example usage:

+ *

+ * // This scenario assumes xTimer has already been created and started.  When

+ * // an interrupt occurs, the period of xTimer should be changed to 500ms.

+ *

+ * // The interrupt service routine that changes the period of xTimer.

+ * void vAnExampleInterruptServiceRoutine( void )

+ * {

+ * portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;

+ *

+ *     // The interrupt has occurred - change the period of xTimer to 500ms.

+ *     // xHigherPriorityTaskWoken was set to pdFALSE where it was defined

+ *     // (within this function).  As this is an interrupt service routine, only

+ *     // FreeRTOS API functions that end in "FromISR" can be used.

+ *     if( xTimerChangePeriodFromISR( xTimer, &xHigherPriorityTaskWoken ) != pdPASS )

+ *     {

+ *         // The command to change the timers period was not executed

+ *         // successfully.  Take appropriate action here.

+ *     }

+ *

+ *     // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch

+ *     // should be performed.  The syntax required to perform a context switch

+ *     // from inside an ISR varies from port to port, and from compiler to

+ *     // compiler.  Inspect the demos for the port you are using to find the

+ *     // actual syntax required.

+ *     if( xHigherPriorityTaskWoken != pdFALSE )

+ *     {

+ *         // Call the interrupt safe yield function here (actual function

+ *         // depends on the FreeRTOS port being used.

+ *     }

+ * }

+ */

+#define xTimerChangePeriodFromISR( xTimer, xNewPeriod, pxHigherPriorityTaskWoken ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_CHANGE_PERIOD, ( xNewPeriod ), ( pxHigherPriorityTaskWoken ), 0U )

+

+/**

+ * portBASE_TYPE xTimerResetFromISR( 	xTimerHandle xTimer,

+ *										portBASE_TYPE *pxHigherPriorityTaskWoken );

+ *

+ * A version of xTimerReset() that can be called from an interrupt service

+ * routine.

+ *

+ * @param xTimer The handle of the timer that is to be started, reset, or

+ * restarted.

+ *

+ * @param pxHigherPriorityTaskWoken The timer service/daemon task spends most

+ * of its time in the Blocked state, waiting for messages to arrive on the timer

+ * command queue.  Calling xTimerResetFromISR() writes a message to the timer

+ * command queue, so has the potential to transition the timer service/daemon

+ * task out of the Blocked state.  If calling xTimerResetFromISR() causes the

+ * timer service/daemon task to leave the Blocked state, and the timer service/

+ * daemon task has a priority equal to or greater than the currently executing

+ * task (the task that was interrupted), then *pxHigherPriorityTaskWoken will

+ * get set to pdTRUE internally within the xTimerResetFromISR() function.  If

+ * xTimerResetFromISR() sets this value to pdTRUE then a context switch should

+ * be performed before the interrupt exits.

+ *

+ * @return pdFAIL will be returned if the reset command could not be sent to

+ * the timer command queue.  pdPASS will be returned if the command was

+ * successfully sent to the timer command queue.  When the command is actually

+ * processed will depend on the priority of the timer service/daemon task

+ * relative to other tasks in the system, although the timers expiry time is

+ * relative to when xTimerResetFromISR() is actually called.  The timer service/daemon

+ * task priority is set by the configTIMER_TASK_PRIORITY configuration constant.

+ *

+ * Example usage:

+ *

+ * // This scenario assumes xBacklightTimer has already been created.  When a

+ * // key is pressed, an LCD back-light is switched on.  If 5 seconds pass

+ * // without a key being pressed, then the LCD back-light is switched off.  In

+ * // this case, the timer is a one-shot timer, and unlike the example given for

+ * // the xTimerReset() function, the key press event handler is an interrupt

+ * // service routine.

+ *

+ * // The callback function assigned to the one-shot timer.  In this case the

+ * // parameter is not used.

+ * void vBacklightTimerCallback( xTimerHandle pxTimer )

+ * {

+ *     // The timer expired, therefore 5 seconds must have passed since a key

+ *     // was pressed.  Switch off the LCD back-light.

+ *     vSetBacklightState( BACKLIGHT_OFF );

+ * }

+ *

+ * // The key press interrupt service routine.

+ * void vKeyPressEventInterruptHandler( void )

+ * {

+ * portBASE_TYPE xHigherPriorityTaskWoken = pdFALSE;

+ *

+ *     // Ensure the LCD back-light is on, then reset the timer that is

+ *     // responsible for turning the back-light off after 5 seconds of

+ *     // key inactivity.  This is an interrupt service routine so can only

+ *     // call FreeRTOS API functions that end in "FromISR".

+ *     vSetBacklightState( BACKLIGHT_ON );

+ *

+ *     // xTimerStartFromISR() or xTimerResetFromISR() could be called here

+ *     // as both cause the timer to re-calculate its expiry time.

+ *     // xHigherPriorityTaskWoken was initialised to pdFALSE when it was

+ *     // declared (in this function).

+ *     if( xTimerResetFromISR( xBacklightTimer, &xHigherPriorityTaskWoken ) != pdPASS )

+ *     {

+ *         // The reset command was not executed successfully.  Take appropriate

+ *         // action here.

+ *     }

+ *

+ *     // Perform the rest of the key processing here.

+ *

+ *     // If xHigherPriorityTaskWoken equals pdTRUE, then a context switch

+ *     // should be performed.  The syntax required to perform a context switch

+ *     // from inside an ISR varies from port to port, and from compiler to

+ *     // compiler.  Inspect the demos for the port you are using to find the

+ *     // actual syntax required.

+ *     if( xHigherPriorityTaskWoken != pdFALSE )

+ *     {

+ *         // Call the interrupt safe yield function here (actual function

+ *         // depends on the FreeRTOS port being used.

+ *     }

+ * }

+ */

+#define xTimerResetFromISR( xTimer, pxHigherPriorityTaskWoken ) xTimerGenericCommand( ( xTimer ), tmrCOMMAND_START, ( xTaskGetTickCountFromISR() ), ( pxHigherPriorityTaskWoken ), 0U )

+

+/*

+ * Functions beyond this part are not part of the public API and are intended

+ * for use by the kernel only.

+ */

+portBASE_TYPE xTimerCreateTimerTask( void ) PRIVILEGED_FUNCTION;

+portBASE_TYPE xTimerGenericCommand( xTimerHandle xTimer, portBASE_TYPE xCommandID, portTickType xOptionalValue, signed portBASE_TYPE *pxHigherPriorityTaskWoken, portTickType xBlockTime ) PRIVILEGED_FUNCTION;

+

+#ifdef __cplusplus

+}

+#endif

+#endif /* TIMERS_H */

+

+

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/init.c b/FreeRTOSV7.2.0/FreeRTOS/Source/init.c
new file mode 100644
index 0000000..c88f053
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/init.c
@@ -0,0 +1,16 @@
+
+#include "FreeRTOS.h"
+// function declarations
+void xInitRTOS(void);
+void xInitQueues(void);
+void xInitTimers(void);
+void xInitTCBs(void);
+
+void xInitRTOS(void)
+{
+    xInitQueues();
+#if ( configUSE_TIMERS == 1 )
+    xInitTimers();
+#endif
+    xInitTCBs();
+}
diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/list.c b/FreeRTOSV7.2.0/FreeRTOS/Source/list.c
new file mode 100644
index 0000000..9ae5d86
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/list.c
@@ -0,0 +1,204 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+

+#include <stdlib.h>

+#include "FreeRTOS.h"

+#include "list.h"

+

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

+ * PUBLIC LIST API documented in list.h

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

+

+void vListInitialise( xList *pxList )

+{

+	/* The list structure contains a list item which is used to mark the

+	end of the list.  To initialise the list the list end is inserted

+	as the only list entry. */

+	pxList->pxIndex = ( xListItem * ) &( pxList->xListEnd );

+

+	/* The list end value is the highest possible value in the list to

+	ensure it remains at the end of the list. */

+	pxList->xListEnd.xItemValue = portMAX_DELAY;

+

+	/* The list end next and previous pointers point to itself so we know

+	when the list is empty. */

+	pxList->xListEnd.pxNext = ( xListItem * ) &( pxList->xListEnd );

+	pxList->xListEnd.pxPrevious = ( xListItem * ) &( pxList->xListEnd );

+

+	pxList->uxNumberOfItems = ( unsigned portBASE_TYPE ) 0U;

+}

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

+

+void vListInitialiseItem( xListItem *pxItem )

+{

+	/* Make sure the list item is not recorded as being on a list. */

+	pxItem->pvContainer = NULL;

+}

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

+

+void vListInsertEnd( xList *pxList, xListItem *pxNewListItem )

+{

+volatile xListItem * pxIndex;

+

+	/* Insert a new list item into pxList, but rather than sort the list,

+	makes the new list item the last item to be removed by a call to

+	pvListGetOwnerOfNextEntry.  This means it has to be the item pointed to by

+	the pxIndex member. */

+	pxIndex = pxList->pxIndex;

+

+	pxNewListItem->pxNext = pxIndex->pxNext;

+	pxNewListItem->pxPrevious = pxList->pxIndex;

+	pxIndex->pxNext->pxPrevious = ( volatile xListItem * ) pxNewListItem;

+	pxIndex->pxNext = ( volatile xListItem * ) pxNewListItem;

+	pxList->pxIndex = ( volatile xListItem * ) pxNewListItem;

+

+	/* Remember which list the item is in. */

+	pxNewListItem->pvContainer = ( void * ) pxList;

+

+	( pxList->uxNumberOfItems )++;

+}

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

+

+void vListInsert( xList *pxList, xListItem *pxNewListItem )

+{

+volatile xListItem *pxIterator;

+portTickType xValueOfInsertion;

+

+	/* Insert the new list item into the list, sorted in ulListItem order. */

+	xValueOfInsertion = pxNewListItem->xItemValue;

+

+	/* If the list already contains a list item with the same item value then

+	the new list item should be placed after it.  This ensures that TCB's which

+	are stored in ready lists (all of which have the same ulListItem value)

+	get an equal share of the CPU.  However, if the xItemValue is the same as

+	the back marker the iteration loop below will not end.  This means we need

+	to guard against this by checking the value first and modifying the

+	algorithm slightly if necessary. */

+	if( xValueOfInsertion == portMAX_DELAY )

+	{

+		pxIterator = pxList->xListEnd.pxPrevious;

+	}

+	else

+	{

+		/* *** NOTE ***********************************************************

+		If you find your application is crashing here then likely causes are:

+			1) Stack overflow -

+			   see http://www.freertos.org/Stacks-and-stack-overflow-checking.html

+			2) Incorrect interrupt priority assignment, especially on Cortex-M3

+			   parts where numerically high priority values denote low actual

+			   interrupt priories, which can seem counter intuitive.  See

+			   configMAX_SYSCALL_INTERRUPT_PRIORITY on http://www.freertos.org/a00110.html

+			3) Calling an API function from within a critical section or when

+			   the scheduler is suspended.

+			4) Using a queue or semaphore before it has been initialised or

+			   before the scheduler has been started (are interrupts firing

+			   before vTaskStartScheduler() has been called?).

+		See http://www.freertos.org/FAQHelp.html for more tips.

+		**********************************************************************/

+		

+		for( pxIterator = ( xListItem * ) &( pxList->xListEnd ); pxIterator->pxNext->xItemValue <= xValueOfInsertion; pxIterator = pxIterator->pxNext )

+		{

+			/* There is nothing to do here, we are just iterating to the

+			wanted insertion position. */

+		}

+	}

+

+	pxNewListItem->pxNext = pxIterator->pxNext;

+	pxNewListItem->pxNext->pxPrevious = ( volatile xListItem * ) pxNewListItem;

+	pxNewListItem->pxPrevious = pxIterator;

+	pxIterator->pxNext = ( volatile xListItem * ) pxNewListItem;

+

+	/* Remember which list the item is in.  This allows fast removal of the

+	item later. */

+	pxNewListItem->pvContainer = ( void * ) pxList;

+

+	( pxList->uxNumberOfItems )++;

+}

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

+

+void vListRemove( xListItem *pxItemToRemove )

+{

+xList * pxList;

+

+	pxItemToRemove->pxNext->pxPrevious = pxItemToRemove->pxPrevious;

+	pxItemToRemove->pxPrevious->pxNext = pxItemToRemove->pxNext;

+	

+	/* The list item knows which list it is in.  Obtain the list from the list

+	item. */

+	pxList = ( xList * ) pxItemToRemove->pvContainer;

+

+	/* Make sure the index is left pointing to a valid item. */

+	if( pxList->pxIndex == pxItemToRemove )

+	{

+		pxList->pxIndex = pxItemToRemove->pxPrevious;

+	}

+

+	pxItemToRemove->pvContainer = NULL;

+	( pxList->uxNumberOfItems )--;

+}

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

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/Flsh186/port.c b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/Flsh186/port.c
new file mode 100644
index 0000000..9f1e4a0
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/Flsh186/port.c
@@ -0,0 +1,282 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+/*

+Changes from V1.00:

+

+	+ Call to taskYIELD() from within tick ISR has been replaced by the more

+	  efficient portSWITCH_CONTEXT().

+	+ ISR function definitions renamed to include the prv prefix.

+

+Changes from V2.6.1

+

+	+ Replaced the sUsingPreemption variable with the configUSE_PREEMPTION

+	  macro to be consistent with the later ports.

+*/

+

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

+ * Implementation of functions defined in portable.h for the Flashlite 186

+ * port.

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

+

+#include <dos.h>

+#include <stdlib.h>

+#include <setjmp.h>

+

+#include "FreeRTOS.h"

+#include "task.h"

+#include "portasm.h"

+

+/*lint -e950 Non ANSI reserved words okay in this file only. */

+

+#define portTIMER_EOI_TYPE		( 8 )

+#define portRESET_PIC()			portOUTPUT_WORD( ( unsigned short ) 0xff22, portTIMER_EOI_TYPE )

+#define portTIMER_INT_NUMBER	0x12

+

+#define portTIMER_1_CONTROL_REGISTER	( ( unsigned short ) 0xff5e )

+#define portTIMER_0_CONTROL_REGISTER	( ( unsigned short ) 0xff56 )

+#define portTIMER_INTERRUPT_ENABLE		( ( unsigned short ) 0x2000 )

+

+/* Setup the hardware to generate the required tick frequency. */

+static void prvSetTickFrequency( unsigned long ulTickRateHz );

+

+/* Set the hardware back to the state as per before the scheduler started. */

+static void prvExitFunction( void );

+

+/* The ISR used depends on whether the preemptive or cooperative scheduler

+is being used. */

+#if( configUSE_PREEMPTION == 1 )

+	/* Tick service routine used by the scheduler when preemptive scheduling is

+	being used. */

+	static void __interrupt __far prvPreemptiveTick( void );

+#else

+	/* Tick service routine used by the scheduler when cooperative scheduling is

+	being used. */

+	static void __interrupt __far prvNonPreemptiveTick( void );

+#endif

+

+/* Trap routine used by taskYIELD() to manually cause a context switch. */

+static void __interrupt __far prvYieldProcessor( void );

+

+/*lint -e956 File scopes necessary here. */

+

+/* Set true when the vectors are set so the scheduler will service the tick. */

+static portBASE_TYPE xSchedulerRunning = pdFALSE;

+

+/* Points to the original routine installed on the vector we use for manual

+context switches.  This is then used to restore the original routine during

+prvExitFunction(). */

+static void ( __interrupt __far *pxOldSwitchISR )();

+

+/* Used to restore the original DOS context when the scheduler is ended. */

+static jmp_buf xJumpBuf;

+

+/*lint +e956 */

+

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

+portBASE_TYPE xPortStartScheduler( void )

+{

+	/* This is called with interrupts already disabled. */

+

+	/* Remember what was on the interrupts we are going to use

+	so we can put them back later if required. */

+	pxOldSwitchISR = _dos_getvect( portSWITCH_INT_NUMBER );

+

+	/* Put our manual switch (yield) function on a known

+	vector. */

+	_dos_setvect( portSWITCH_INT_NUMBER, prvYieldProcessor );

+

+	#if( configUSE_PREEMPTION == 1 )

+	{

+		/* Put our tick switch function on the timer interrupt. */

+		_dos_setvect( portTIMER_INT_NUMBER, prvPreemptiveTick );

+	}

+	#else

+	{

+		/* We want the timer interrupt to just increment the tick count. */

+		_dos_setvect( portTIMER_INT_NUMBER, prvNonPreemptiveTick );

+	}

+	#endif

+

+	prvSetTickFrequency( configTICK_RATE_HZ );

+

+	/* Clean up function if we want to return to DOS. */

+	if( setjmp( xJumpBuf ) != 0 )

+	{

+		prvExitFunction();

+		xSchedulerRunning = pdFALSE;

+	}

+	else

+	{

+		xSchedulerRunning = pdTRUE;

+

+		/* Kick off the scheduler by setting up the context of the first task. */

+		portFIRST_CONTEXT();

+	}

+

+	return xSchedulerRunning;

+}

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

+

+/* The ISR used depends on whether the preemptive or cooperative scheduler

+is being used. */

+#if( configUSE_PREEMPTION == 1 )

+	static void __interrupt __far prvPreemptiveTick( void )

+	{

+		/* Get the scheduler to update the task states following the tick. */

+		vTaskIncrementTick();

+

+		/* Switch in the context of the next task to be run. */

+		portSWITCH_CONTEXT();

+

+		/* Reset the PIC ready for the next time. */

+		portRESET_PIC();

+	}

+#else

+	static void __interrupt __far prvNonPreemptiveTick( void )

+	{

+		/* Same as preemptive tick, but the cooperative scheduler is being used

+		so we don't have to switch in the context of the next task. */

+		vTaskIncrementTick();

+		portRESET_PIC();

+	}

+#endif

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

+

+static void __interrupt __far prvYieldProcessor( void )

+{

+	/* Switch in the context of the next task to be run. */

+	portSWITCH_CONTEXT();

+}

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

+

+void vPortEndScheduler( void )

+{

+	/* Jump back to the processor state prior to starting the

+	scheduler.  This means we are not going to be using a

+	task stack frame so the task can be deleted. */

+	longjmp( xJumpBuf, 1 );

+}

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

+

+static void prvExitFunction( void )

+{

+const unsigned short usTimerDisable = 0x0000;

+unsigned short usTimer0Control;

+

+	/* Interrupts should be disabled here anyway - but no

+	harm in making sure. */

+	portDISABLE_INTERRUPTS();

+	if( xSchedulerRunning == pdTRUE )

+	{

+		/* Put back the switch interrupt routines that was in place

+		before the scheduler started. */

+		_dos_setvect( portSWITCH_INT_NUMBER, pxOldSwitchISR );

+	}

+

+	/* Disable the timer used for the tick to ensure the scheduler is

+	not called before restoring interrupts.  There was previously nothing

+	on this timer so there is no old ISR to restore. */

+	portOUTPUT_WORD( portTIMER_1_CONTROL_REGISTER, usTimerDisable );

+

+	/* Restart the DOS tick. */

+	usTimer0Control = portINPUT_WORD( portTIMER_0_CONTROL_REGISTER );

+	usTimer0Control |= portTIMER_INTERRUPT_ENABLE;

+	portOUTPUT_WORD( portTIMER_0_CONTROL_REGISTER, usTimer0Control );

+

+

+	portENABLE_INTERRUPTS();

+}

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

+

+static void prvSetTickFrequency( unsigned long ulTickRateHz )

+{

+const unsigned short usMaxCountRegister = 0xff5a;

+const unsigned short usTimerPriorityRegister = 0xff32;

+const unsigned short usTimerEnable = 0xC000;

+const unsigned short usRetrigger = 0x0001;

+const unsigned short usTimerHighPriority = 0x0000;

+unsigned short usTimer0Control;

+

+/* ( CPU frequency / 4 ) / clock 2 max count [inpw( 0xff62 ) = 7] */

+

+const unsigned long ulClockFrequency = ( unsigned long ) 0x7f31a0UL;

+

+unsigned long ulTimerCount = ulClockFrequency / ulTickRateHz;

+

+	portOUTPUT_WORD( portTIMER_1_CONTROL_REGISTER, usTimerEnable | portTIMER_INTERRUPT_ENABLE | usRetrigger );

+	portOUTPUT_WORD( usMaxCountRegister, ( unsigned short ) ulTimerCount );

+	portOUTPUT_WORD( usTimerPriorityRegister, usTimerHighPriority );

+

+	/* Stop the DOS tick - don't do this if you want to maintain a TOD clock. */

+	usTimer0Control = portINPUT_WORD( portTIMER_0_CONTROL_REGISTER );

+	usTimer0Control &= ~portTIMER_INTERRUPT_ENABLE;

+	portOUTPUT_WORD( portTIMER_0_CONTROL_REGISTER, usTimer0Control );

+}

+

+

+/*lint +e950 */

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/Flsh186/prtmacro.h b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/Flsh186/prtmacro.h
new file mode 100644
index 0000000..5e4990b
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/Flsh186/prtmacro.h
@@ -0,0 +1,132 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+#ifndef PORTMACRO_H

+#define PORTMACRO_H

+

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

+ * Port specific definitions.  

+ *

+ * The settings in this file configure FreeRTOS correctly for the

+ * given hardware and compiler.

+ *

+ * These settings should not be altered.

+ *-----------------------------------------------------------

+ */

+

+/* Type definitions. */

+#define portCHAR		char

+#define portFLOAT		float

+#define portDOUBLE		long

+#define portLONG		long

+#define portSHORT		int

+#define portSTACK_TYPE	unsigned portSHORT

+#define portBASE_TYPE	portSHORT

+

+#if( configUSE_16_BIT_TICKS == 1 )

+	typedef unsigned portSHORT portTickType;

+	#define portMAX_DELAY ( portTickType ) 0xffff

+#else

+	typedef unsigned portLONG portTickType;

+	#define portMAX_DELAY ( portTickType ) 0xffffffff

+#endif

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

+

+/* Critical section handling. */

+#define portENTER_CRITICAL()			__asm{ pushf }  \

+										__asm{ cli 	 }	\

+

+#define portEXIT_CRITICAL()				__asm{ popf }

+

+#define portDISABLE_INTERRUPTS()		__asm{ cli }

+

+#define portENABLE_INTERRUPTS()			__asm{ sti }

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

+

+/* Hardware specifics. */

+#define portNOP()						__asm{ nop }

+#define portSTACK_GROWTH				( -1 )

+#define portSWITCH_INT_NUMBER 			0x80

+#define portYIELD()						__asm{ int portSWITCH_INT_NUMBER } 

+#define portTICK_RATE_MS		( ( portTickType ) 1000 / configTICK_RATE_HZ )		

+#define portBYTE_ALIGNMENT      2

+#define portINITIAL_SW		( ( portSTACK_TYPE ) 0x0202 )	/* Start the tasks with interrupts enabled. */

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

+

+/* Compiler specifics. */

+#define portINPUT_BYTE( xAddr )				inp( xAddr )

+#define portOUTPUT_BYTE( xAddr, ucValue )	outp( xAddr, ucValue )

+#define portINPUT_WORD( xAddr )				inpw( xAddr )

+#define portOUTPUT_WORD( xAddr, usValue )	outpw( xAddr, usValue )

+

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

+

+/* Task function macros as described on the FreeRTOS.org WEB site. */

+#define portTASK_FUNCTION_PROTO( vTaskFunction, vParameters ) void vTaskFunction( void *pvParameters )

+#define portTASK_FUNCTION( vTaskFunction, vParameters ) void vTaskFunction( void *pvParameters )

+

+#endif /* PORTMACRO_H */

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/PC/port.c b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/PC/port.c
new file mode 100644
index 0000000..912708a
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/PC/port.c
@@ -0,0 +1,326 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+/*

+Changes from V2.6.1

+

+	+ Replaced the sUsingPreemption variable with the configUSE_PREEMPTION

+	  macro to be consistent with the later ports.

+

+Changes from V4.0.1

+	

+	+ Add function prvSetTickFrequencyDefault() to set the DOS tick back to

+	  its proper value when the scheduler exits. 

+*/

+

+#include <stdlib.h>

+#include <dos.h>

+#include <setjmp.h>

+

+#include "FreeRTOS.h"

+#include "task.h"

+#include "portasm.h"

+

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

+ * Implementation of functions defined in portable.h for the industrial

+ * PC port.

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

+

+/*lint -e950 Non ANSI reserved words okay in this file only. */

+

+#define portTIMER_INT_NUMBER	0x08

+

+/* Setup hardware for required tick interrupt rate. */

+static void prvSetTickFrequency( unsigned long ulTickRateHz );

+

+/* Restore hardware to as it was prior to starting the scheduler. */

+static void prvExitFunction( void );

+

+/* Either chain to the DOS tick (which itself clears the PIC) or clear the PIC

+directly.  We chain to the DOS tick as close as possible to the standard DOS

+tick rate. */

+static void prvPortResetPIC( void );

+

+/* The ISR used depends on whether the preemptive or cooperative

+scheduler is being used. */

+#if( configUSE_PREEMPTION == 1 )

+	/* Tick service routine used by the scheduler when preemptive scheduling is

+	being used. */

+	static void __interrupt __far prvPreemptiveTick( void );

+#else

+	/* Tick service routine used by the scheduler when cooperative scheduling is

+	being used. */

+	static void __interrupt __far prvNonPreemptiveTick( void );

+#endif

+

+/* Trap routine used by taskYIELD() to manually cause a context switch. */

+static void __interrupt __far prvYieldProcessor( void );

+

+/* Set the tick frequency back so the floppy drive works correctly when the

+scheduler exits. */

+static void prvSetTickFrequencyDefault( void );

+

+/*lint -e956 File scopes necessary here. */

+

+/* Used to signal when to chain to the DOS tick, and when to just clear the PIC ourselves. */

+static short sDOSTickCounter;

+

+/* Set true when the vectors are set so the scheduler will service the tick. */

+static portBASE_TYPE xSchedulerRunning = pdFALSE;				

+

+/* Points to the original routine installed on the vector we use for manual context switches.  This is then used to restore the original routine during prvExitFunction(). */

+static void ( __interrupt __far *pxOldSwitchISR )();		

+

+/* Points to the original routine installed on the vector we use to chain to the DOS tick.  This is then used to restore the original routine during prvExitFunction(). */

+static void ( __interrupt __far *pxOldSwitchISRPlus1 )();	

+

+/* Used to restore the original DOS context when the scheduler is ended. */

+static jmp_buf xJumpBuf;

+

+/*lint +e956 */

+

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

+portBASE_TYPE xPortStartScheduler( void )

+{

+pxISR pxOriginalTickISR;

+	

+	/* This is called with interrupts already disabled. */

+

+	/* Remember what was on the interrupts we are going to use

+	so we can put them back later if required. */

+	pxOldSwitchISR = _dos_getvect( portSWITCH_INT_NUMBER );

+	pxOriginalTickISR = _dos_getvect( portTIMER_INT_NUMBER );

+	pxOldSwitchISRPlus1 = _dos_getvect( portSWITCH_INT_NUMBER + 1 );

+

+	prvSetTickFrequency( configTICK_RATE_HZ );

+

+	/* Put our manual switch (yield) function on a known

+	vector. */

+	_dos_setvect( portSWITCH_INT_NUMBER, prvYieldProcessor );

+

+	/* Put the old tick on a different interrupt number so we can

+	call it when we want. */

+	_dos_setvect( portSWITCH_INT_NUMBER + 1, pxOriginalTickISR );

+

+	/* The ISR used depends on whether the preemptive or cooperative

+	scheduler is being used. */

+	#if( configUSE_PREEMPTION == 1 )

+	{

+		/* Put our tick switch function on the timer interrupt. */

+		_dos_setvect( portTIMER_INT_NUMBER, prvPreemptiveTick );

+	}

+	#else

+	{

+		/* We want the timer interrupt to just increment the tick count. */

+		_dos_setvect( portTIMER_INT_NUMBER, prvNonPreemptiveTick );

+	}

+    #endif

+

+	/* Setup a counter that is used to call the DOS interrupt as close

+	to it's original frequency as can be achieved given our chosen tick

+	frequency. */

+	sDOSTickCounter = portTICKS_PER_DOS_TICK;

+

+	/* Clean up function if we want to return to DOS. */

+	if( setjmp( xJumpBuf ) != 0 )

+	{

+		prvExitFunction();

+		xSchedulerRunning = pdFALSE;

+	}

+	else

+	{

+		xSchedulerRunning = pdTRUE;

+

+		/* Kick off the scheduler by setting up the context of the first task. */

+		portFIRST_CONTEXT();

+	}

+

+	return xSchedulerRunning;

+}

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

+

+/* The ISR used depends on whether the preemptive or cooperative

+scheduler is being used. */

+#if( configUSE_PREEMPTION == 1 )

+	static void __interrupt __far prvPreemptiveTick( void )

+	{

+		/* Get the scheduler to update the task states following the tick. */

+		vTaskIncrementTick();

+

+		/* Switch in the context of the next task to be run. */

+		portSWITCH_CONTEXT();

+

+		/* Reset the PIC ready for the next time. */

+		prvPortResetPIC();

+	}

+#else

+	static void __interrupt __far prvNonPreemptiveTick( void )

+	{

+		/* Same as preemptive tick, but the cooperative scheduler is being used

+		so we don't have to switch in the context of the next task. */

+		vTaskIncrementTick();

+		prvPortResetPIC();

+	}

+#endif

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

+

+static void __interrupt __far prvYieldProcessor( void )

+{

+	/* Switch in the context of the next task to be run. */

+	portSWITCH_CONTEXT();

+}

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

+

+static void prvPortResetPIC( void )

+{

+	/* We are going to call the DOS tick interrupt at as close a

+	frequency to the normal DOS tick as possible. */

+

+	/* WE SHOULD NOT DO THIS IF YIELD WAS CALLED. */

+	--sDOSTickCounter;

+	if( sDOSTickCounter <= 0 )

+	{

+		sDOSTickCounter = ( short ) portTICKS_PER_DOS_TICK;

+		__asm{ int	portSWITCH_INT_NUMBER + 1 };		 

+	}

+	else

+	{

+		/* Reset the PIC as the DOS tick is not being called to

+		do it. */

+		__asm

+		{

+			mov	al, 20H

+			out 20H, al

+		};

+	}

+}

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

+

+void vPortEndScheduler( void )

+{

+	/* Jump back to the processor state prior to starting the

+	scheduler.  This means we are not going to be using a

+	task stack frame so the task can be deleted. */

+	longjmp( xJumpBuf, 1 );

+}

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

+

+static void prvExitFunction( void )

+{

+void ( __interrupt __far *pxOriginalTickISR )();

+

+	/* Interrupts should be disabled here anyway - but no 

+	harm in making sure. */

+	portDISABLE_INTERRUPTS();

+	if( xSchedulerRunning == pdTRUE )

+	{

+		/* Set the DOS tick back onto the timer ticker. */

+		pxOriginalTickISR = _dos_getvect( portSWITCH_INT_NUMBER + 1 );

+		_dos_setvect( portTIMER_INT_NUMBER, pxOriginalTickISR );

+		prvSetTickFrequencyDefault();

+

+		/* Put back the switch interrupt routines that was in place

+		before the scheduler started. */

+		_dos_setvect( portSWITCH_INT_NUMBER, pxOldSwitchISR );

+		_dos_setvect( portSWITCH_INT_NUMBER + 1, pxOldSwitchISRPlus1 );

+	}

+	/* The tick timer is back how DOS wants it.  We can re-enable

+	interrupts without the scheduler being called. */

+	portENABLE_INTERRUPTS();

+}

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

+

+static void prvSetTickFrequency( unsigned long ulTickRateHz )

+{

+const unsigned short usPIT_MODE = ( unsigned short ) 0x43;

+const unsigned short usPIT0 = ( unsigned short ) 0x40;

+const unsigned long ulPIT_CONST = ( unsigned long ) 1193180UL;

+const unsigned short us8254_CTR0_MODE3 = ( unsigned short ) 0x36;

+unsigned long ulOutput;

+

+	/* Setup the 8245 to tick at the wanted frequency. */

+	portOUTPUT_BYTE( usPIT_MODE, us8254_CTR0_MODE3 );

+	ulOutput = ulPIT_CONST / ulTickRateHz;

+	portOUTPUT_BYTE( usPIT0, ( unsigned short )( ulOutput & ( unsigned long ) 0xff ) );

+	ulOutput >>= 8;

+	portOUTPUT_BYTE( usPIT0, ( unsigned short ) ( ulOutput & ( unsigned long ) 0xff ) );

+}

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

+

+static void prvSetTickFrequencyDefault( void )

+{

+const unsigned short usPIT_MODE = ( unsigned short ) 0x43;

+const unsigned short usPIT0 = ( unsigned short ) 0x40;

+const unsigned short us8254_CTR0_MODE3 = ( unsigned short ) 0x36;

+

+	portOUTPUT_BYTE( usPIT_MODE, us8254_CTR0_MODE3 );

+	portOUTPUT_BYTE( usPIT0,0 );

+	portOUTPUT_BYTE( usPIT0,0 );

+}

+

+

+/*lint +e950 */

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/PC/prtmacro.h b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/PC/prtmacro.h
new file mode 100644
index 0000000..5c980d3
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/PC/prtmacro.h
@@ -0,0 +1,132 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+#ifndef PORTMACRO_H

+#define PORTMACRO_H

+

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

+ * Port specific definitions.  

+ *

+ * The settings in this file configure FreeRTOS correctly for the

+ * given hardware and compiler.

+ *

+ * These settings should not be altered.

+ *-----------------------------------------------------------

+ */

+

+/* Type definitions. */

+#define portCHAR		char

+#define portFLOAT		long

+#define portDOUBLE		long

+#define portLONG		long

+#define portSHORT		int

+#define portSTACK_TYPE	unsigned portSHORT

+#define portBASE_TYPE	portSHORT

+

+#if( configUSE_16_BIT_TICKS == 1 )

+	typedef unsigned portSHORT portTickType;

+	#define portMAX_DELAY ( portTickType ) 0xffff

+#else

+	typedef unsigned portLONG portTickType;

+	#define portMAX_DELAY ( portTickType ) 0xffffffff

+#endif

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

+

+/* Critical section management. */

+#define portENTER_CRITICAL()			__asm{ pushf }  \

+										__asm{ cli 	 }	\

+

+#define portEXIT_CRITICAL()				__asm{ popf }

+

+#define portDISABLE_INTERRUPTS()		__asm{ cli }

+

+#define portENABLE_INTERRUPTS()			__asm{ sti }

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

+

+/* Hardware specifics. */

+#define portNOP()				__asm{ nop }

+#define portSTACK_GROWTH		( -1 )

+#define portSWITCH_INT_NUMBER 	0x80

+#define portYIELD()				__asm{ int portSWITCH_INT_NUMBER } 

+#define portDOS_TICK_RATE		( 18.20648 )

+#define portTICK_RATE_MS		( ( portTickType ) 1000 / configTICK_RATE_HZ )		

+#define portTICKS_PER_DOS_TICK	( ( unsigned portSHORT ) ( ( ( portDOUBLE ) configTICK_RATE_HZ / portDOS_TICK_RATE ) + 0.5 ) )

+#define portINITIAL_SW			( ( portSTACK_TYPE ) 0x0202 )	/* Start the tasks with interrupts enabled. */

+#define portBYTE_ALIGNMENT		( 2 )

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

+

+/* Compiler specifics. */

+#define portINPUT_BYTE( xAddr )				inp( xAddr )

+#define portOUTPUT_BYTE( xAddr, ucValue )	outp( xAddr, ucValue )

+

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

+

+/* Task function macros as described on the FreeRTOS.org WEB site. */

+#define portTASK_FUNCTION_PROTO( vTaskFunction, pvParameters ) void vTaskFunction( void *pvParameters )

+#define portTASK_FUNCTION( vTaskFunction, pvParameters ) void vTaskFunction( void *pvParameters )

+

+#endif /* PORTMACRO_H */

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/common/portasm.h b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/common/portasm.h
new file mode 100644
index 0000000..1142ea4
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/common/portasm.h
@@ -0,0 +1,126 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+#ifndef PORT_ASM_H

+#define PORT_ASM_H

+

+typedef void tskTCB;

+extern volatile tskTCB * volatile pxCurrentTCB;

+extern void vTaskSwitchContext( void );

+

+/*

+ * Saves the stack pointer for one task into its TCB, calls

+ * vTaskSwitchContext() to update the TCB being used, then restores the stack

+ * from the new TCB read to run the task.

+ */

+void portSWITCH_CONTEXT( void );

+

+/*

+ * Load the stack pointer from the TCB of the task which is going to be first

+ * to execute.  Then force an IRET so the registers and IP are popped off the

+ * stack.

+ */

+void portFIRST_CONTEXT( void );

+

+/* There are slightly different versions depending on whether you are building

+to include debugger information.  If debugger information is used then there

+are a couple of extra bytes left of the ISR stack (presumably for use by the

+debugger).  The true stack pointer is then stored in the bp register.  We add

+2 to the stack pointer to remove the extra bytes before we restore our context. */

+

+#define portSWITCH_CONTEXT()											\

+							asm { mov	ax, seg pxCurrentTCB		}	\

+							asm { mov	ds, ax						}	\

+							asm { les	bx, pxCurrentTCB			}	/* Save the stack pointer into the TCB. */		\

+							asm { mov	es:0x2[ bx ], ss			}	\

+							asm { mov	es:[ bx ], sp				}	\

+							asm { call  far ptr vTaskSwitchContext	}	/* Perform the switch. */						\

+							asm { mov	ax, seg pxCurrentTCB		}	/* Restore the stack pointer from the TCB. */	\

+							asm { mov	ds, ax						}	\

+							asm { les	bx, dword ptr pxCurrentTCB	}	\

+							asm { mov	ss, es:[ bx + 2 ]			}	\

+							asm { mov	sp, es:[ bx ]				}

+

+#define portFIRST_CONTEXT()												\

+							__asm { mov	ax, seg pxCurrentTCB		}	\

+							__asm { mov	ds, ax						}	\

+							__asm { les	bx, dword ptr pxCurrentTCB	}	\

+							__asm { mov	ss, es:[ bx + 2 ]			}	\

+							__asm { mov	sp, es:[ bx ]				}	\

+							__asm { pop	bp							}	\

+							__asm { pop	di							}	\

+							__asm { pop	si							}	\

+							__asm { pop	ds							}	\

+							__asm { pop	es							}	\

+							__asm { pop	dx							}	\

+							__asm { pop	cx							}	\

+							__asm { pop	bx							}	\

+							__asm { pop	ax							}	\

+							__asm { iret							}

+

+

+#endif

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/common/portcomn.c b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/common/portcomn.c
new file mode 100644
index 0000000..fc41a77
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/BCC/16BitDOS/common/portcomn.c
@@ -0,0 +1,159 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+/*

+Changes from V1.00:

+

+	+ pxPortInitialiseStack() now initialises the stack of new tasks to the

+	  same format used by the compiler.  This allows the compiler generated

+	  interrupt mechanism to be used for context switches.

+

+Changes from V2.6.1

+

+	+ Move usPortCheckFreeStackSpace() to tasks.c.

+*/

+

+

+#include <dos.h>

+#include <stdlib.h>

+#include "FreeRTOS.h"

+

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

+

+/* See header file for description. */

+portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE *pxTopOfStack, pdTASK_CODE pxCode, void *pvParameters )

+{

+portSTACK_TYPE DS_Reg = 0;

+

+	/* Place a few bytes of known values on the bottom of the stack.

+	This is just useful for debugging. */

+

+	*pxTopOfStack = 0x1111;

+	pxTopOfStack--;

+	*pxTopOfStack = 0x2222;

+	pxTopOfStack--;

+	*pxTopOfStack = 0x3333;

+	pxTopOfStack--;

+	*pxTopOfStack = 0x4444;

+	pxTopOfStack--;

+	*pxTopOfStack = 0x5555;

+	pxTopOfStack--;

+

+

+	/*lint -e950 -e611 -e923 Lint doesn't like this much - but nothing I can do about it. */

+

+	/* We are going to start the scheduler using a return from interrupt

+	instruction to load the program counter, so first there would be the

+	function call with parameters preamble. */

+	

+	*pxTopOfStack = FP_SEG( pvParameters );

+	pxTopOfStack--;

+	*pxTopOfStack = FP_OFF( pvParameters );

+	pxTopOfStack--;

+	*pxTopOfStack = FP_SEG( pxCode );

+	pxTopOfStack--;

+	*pxTopOfStack = FP_OFF( pxCode );

+	pxTopOfStack--;

+

+	/* Next the status register and interrupt return address. */

+	*pxTopOfStack = portINITIAL_SW; 

+	pxTopOfStack--;

+	*pxTopOfStack = FP_SEG( pxCode );

+	pxTopOfStack--;

+	*pxTopOfStack = FP_OFF( pxCode );

+	pxTopOfStack--;

+

+	/* The remaining registers would be pushed on the stack by our context

+	switch function.  These are loaded with values simply to make debugging

+	easier. */

+	*pxTopOfStack = ( portSTACK_TYPE ) 0xAAAA;	/* AX */

+	pxTopOfStack--;

+	*pxTopOfStack = ( portSTACK_TYPE ) 0xBBBB;	/* BX */

+	pxTopOfStack--;

+	*pxTopOfStack = ( portSTACK_TYPE ) 0xCCCC;	/* CX */

+	pxTopOfStack--;

+	*pxTopOfStack = ( portSTACK_TYPE ) 0xDDDD;	/* DX */

+	pxTopOfStack--;

+	*pxTopOfStack = ( portSTACK_TYPE ) 0xEEEE;	/* ES */

+	pxTopOfStack--;

+

+	/* We need the true data segment. */

+	__asm{	MOV DS_Reg, DS };

+

+	*pxTopOfStack = DS_Reg;						/* DS */

+	pxTopOfStack--;

+	*pxTopOfStack = ( portSTACK_TYPE ) 0x0123;	/* SI */

+	pxTopOfStack--;

+	*pxTopOfStack = ( portSTACK_TYPE ) 0xDDDD;	/* DI */

+	pxTopOfStack--;

+	*pxTopOfStack = ( portSTACK_TYPE ) 0xBBBB;	/* BP */

+

+	/*lint +e950 +e611 +e923 */

+

+	return pxTopOfStack;

+}

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

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CCS/MSP430X/data_model.h b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CCS/MSP430X/data_model.h
new file mode 100644
index 0000000..263a478
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CCS/MSP430X/data_model.h
@@ -0,0 +1,79 @@
+;/*

+;    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+;	

+;

+;    ***************************************************************************

+;     *                                                                       *

+;     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+;     *    Complete, revised, and edited pdf reference manuals are also       *

+;     *    available.                                                         *

+;     *                                                                       *

+;     *    Purchasing FreeRTOS documentation will not only help you, by       *

+;     *    ensuring you get running as quickly as possible and with an        *

+;     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+;     *    the FreeRTOS project to continue with its mission of providing     *

+;     *    professional grade, cross platform, de facto standard solutions    *

+;     *    for microcontrollers - completely free of charge!                  *

+;     *                                                                       *

+;     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+;     *                                                                       *

+;     *    Thank you for using FreeRTOS, and thank you for your support!      *

+;     *                                                                       *

+;    ***************************************************************************

+;

+;

+;    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.  See the GNU General Public License for

+;    more details. You should have received a copy of the GNU General Public

+;    License and the FreeRTOS license exception along with FreeRTOS; if not it

+;    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+;    by writing to Richard Barry, contact details for whom are available on the

+;    FreeRTOS WEB site.

+;

+;    1 tab == 4 spaces!

+;

+;    http://www.FreeRTOS.org - Documentation, latest information, license and

+;    contact details.

+;

+;    http://www.SafeRTOS.com - A version that is certified for use in safety

+;    critical systems.

+;

+;    http://www.OpenRTOS.com - Commercial support, development, porting,

+;    licensing and training services.

+;*/

+

+	.if $DEFINED( __LARGE_DATA_MODEL__ )

+		.define "pushm.a", pushm_x

+		.define "popm.a", popm_x

+		.define "push.a", push_x

+		.define "pop.a", pop_x

+		.define "mov.a", mov_x

+	.else

+		.define "pushm.w", pushm_x

+		.define "popm.w", popm_x

+		.define "push.w", push_x

+		.define "pop.w", pop_x

+		.define "mov.w", mov_x

+	.endif

+	

+	.if $DEFINED( __LARGE_CODE_MODEL__ )

+		.define "calla", call_x

+		.define "reta", ret_x

+	.else

+		.define "call", call_x

+		.define "ret", ret_x

+	.endif

+	

+

+

+

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CCS/MSP430X/port.c b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CCS/MSP430X/port.c
new file mode 100644
index 0000000..5753185
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CCS/MSP430X/port.c
@@ -0,0 +1,226 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+/* Scheduler includes. */

+#include "FreeRTOS.h"

+#include "task.h"

+

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

+ * Implementation of functions defined in portable.h for the MSP430X port.

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

+

+/* Constants required for hardware setup.  The tick ISR runs off the ACLK,

+not the MCLK. */

+#define portACLK_FREQUENCY_HZ			( ( portTickType ) 32768 )

+#define portINITIAL_CRITICAL_NESTING	( ( unsigned short ) 10 )

+#define portFLAGS_INT_ENABLED			( ( portSTACK_TYPE ) 0x08 )

+

+/* We require the address of the pxCurrentTCB variable, but don't want to know

+any details of its type. */

+typedef void tskTCB;

+extern volatile tskTCB * volatile pxCurrentTCB;

+

+/* Each task maintains a count of the critical section nesting depth.  Each

+time a critical section is entered the count is incremented.  Each time a

+critical section is exited the count is decremented - with interrupts only

+being re-enabled if the count is zero.

+

+usCriticalNesting will get set to zero when the scheduler starts, but must

+not be initialised to zero as this will cause problems during the startup

+sequence. */

+volatile unsigned short usCriticalNesting = portINITIAL_CRITICAL_NESTING;

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

+

+

+/*

+ * Sets up the periodic ISR used for the RTOS tick.  This uses timer 0, but

+ * could have alternatively used the watchdog timer or timer 1.

+ */

+void vPortSetupTimerInterrupt( void );

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

+

+/*

+ * Initialise the stack of a task to look exactly as if a call to

+ * portSAVE_CONTEXT had been called.

+ *

+ * See the header file portable.h.

+ */

+portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE *pxTopOfStack, pdTASK_CODE pxCode, void *pvParameters )

+{

+unsigned short *pusTopOfStack;

+unsigned long *pulTopOfStack, ulTemp;

+

+	/*

+		Place a few bytes of known values on the bottom of the stack.

+		This is just useful for debugging and can be included if required.

+

+		*pxTopOfStack = ( portSTACK_TYPE ) 0x1111;

+		pxTopOfStack--;

+		*pxTopOfStack = ( portSTACK_TYPE ) 0x2222;

+		pxTopOfStack--;

+		*pxTopOfStack = ( portSTACK_TYPE ) 0x3333;

+		pxTopOfStack--;

+	*/

+

+	/* Data types are need either 16 bits or 32 bits depending on the data 

+	and code model used. */

+	if( sizeof( pxCode ) == sizeof( unsigned short ) )

+	{

+		pusTopOfStack = ( unsigned short * ) pxTopOfStack;

+		ulTemp = ( unsigned long ) pxCode;

+		*pusTopOfStack = ( unsigned short ) ulTemp;

+	}

+	else

+	{

+		/* Make room for a 20 bit value stored as a 32 bit value. */

+		pusTopOfStack = ( unsigned short * ) pxTopOfStack;		

+		pusTopOfStack--;

+		pulTopOfStack = ( unsigned long * ) pusTopOfStack;

+		*pulTopOfStack = ( unsigned long ) pxCode;

+	}

+

+	pusTopOfStack--;

+	*pusTopOfStack = portFLAGS_INT_ENABLED;

+	pusTopOfStack -= ( sizeof( portSTACK_TYPE ) / 2 );

+	

+	/* From here on the size of stacked items depends on the memory model. */

+	pxTopOfStack = ( portSTACK_TYPE * ) pusTopOfStack;

+

+	/* Next the general purpose registers. */

+	#ifdef PRELOAD_REGISTER_VALUES

+		*pxTopOfStack = ( portSTACK_TYPE ) 0xffff;

+		pxTopOfStack--;

+		*pxTopOfStack = ( portSTACK_TYPE ) 0xeeee;

+		pxTopOfStack--;

+		*pxTopOfStack = ( portSTACK_TYPE ) 0xdddd;

+		pxTopOfStack--;

+		*pxTopOfStack = ( portSTACK_TYPE ) pvParameters;

+		pxTopOfStack--;

+		*pxTopOfStack = ( portSTACK_TYPE ) 0xbbbb;

+		pxTopOfStack--;

+		*pxTopOfStack = ( portSTACK_TYPE ) 0xaaaa;

+		pxTopOfStack--;

+		*pxTopOfStack = ( portSTACK_TYPE ) 0x9999;

+		pxTopOfStack--;

+		*pxTopOfStack = ( portSTACK_TYPE ) 0x8888;

+		pxTopOfStack--;	

+		*pxTopOfStack = ( portSTACK_TYPE ) 0x5555;

+		pxTopOfStack--;

+		*pxTopOfStack = ( portSTACK_TYPE ) 0x6666;

+		pxTopOfStack--;

+		*pxTopOfStack = ( portSTACK_TYPE ) 0x5555;

+		pxTopOfStack--;

+		*pxTopOfStack = ( portSTACK_TYPE ) 0x4444;

+		pxTopOfStack--;

+	#else

+		pxTopOfStack -= 3;

+		*pxTopOfStack = ( portSTACK_TYPE ) pvParameters;

+		pxTopOfStack -= 9;

+	#endif

+

+	/* A variable is used to keep track of the critical section nesting.

+	This variable has to be stored as part of the task context and is

+	initially set to zero. */

+	*pxTopOfStack = ( portSTACK_TYPE ) portNO_CRITICAL_SECTION_NESTING;	

+

+	/* Return a pointer to the top of the stack we have generated so this can

+	be stored in the task control block for the task. */

+	return pxTopOfStack;

+}

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

+

+void vPortEndScheduler( void )

+{

+	/* It is unlikely that the MSP430 port will get stopped.  If required simply

+	disable the tick interrupt here. */

+}

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

+

+/*

+ * Hardware initialisation to generate the RTOS tick.

+ */

+void vPortSetupTimerInterrupt( void )

+{

+	vApplicationSetupTimerInterrupt();

+}

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

+

+#pragma vector=configTICK_VECTOR

+interrupt void vTickISREntry( void )

+{

+extern void vPortTickISR( void );

+

+	__bic_SR_register_on_exit( SCG1 + SCG0 + OSCOFF + CPUOFF );

+	#if configUSE_PREEMPTION == 1

+		extern void vPortPreemptiveTickISR( void );

+		vPortPreemptiveTickISR();

+	#else

+		extern void vPortCooperativeTickISR( void );

+		vPortCooperativeTickISR();

+	#endif

+}

+

+	

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CCS/MSP430X/portext.asm b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CCS/MSP430X/portext.asm
new file mode 100644
index 0000000..092b525
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CCS/MSP430X/portext.asm
@@ -0,0 +1,184 @@
+;

+;/*

+;    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+;	

+;

+;    ***************************************************************************

+;     *                                                                       *

+;     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+;     *    Complete, revised, and edited pdf reference manuals are also       *

+;     *    available.                                                         *

+;     *                                                                       *

+;     *    Purchasing FreeRTOS documentation will not only help you, by       *

+;     *    ensuring you get running as quickly as possible and with an        *

+;     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+;     *    the FreeRTOS project to continue with its mission of providing     *

+;     *    professional grade, cross platform, de facto standard solutions    *

+;     *    for microcontrollers - completely free of charge!                  *

+;     *                                                                       *

+;     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+;     *                                                                       *

+;     *    Thank you for using FreeRTOS, and thank you for your support!      *

+;     *                                                                       *

+;    ***************************************************************************

+;

+;

+;    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.  See the GNU General Public License for

+;    more details. You should have received a copy of the GNU General Public

+;    License and the FreeRTOS license exception along with FreeRTOS; if not it

+;    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+;    by writing to Richard Barry, contact details for whom are available on the

+;    FreeRTOS WEB site.

+;

+;    1 tab == 4 spaces!

+;

+;    http://www.FreeRTOS.org - Documentation, latest information, license and

+;    contact details.

+;

+;    http://www.SafeRTOS.com - A version that is certified for use in safety

+;    critical systems.

+;

+;    http://www.OpenRTOS.com - Commercial support, development, porting,

+;    licensing and training services.

+;*/

+

+; * The definition of the "register test" tasks, as described at the top of

+; * main.c

+

+	.include data_model.h

+

+	.global vTaskIncrementTick

+	.global vTaskSwitchContext

+	.global vPortSetupTimerInterrupt

+	.global pxCurrentTCB

+	.global usCriticalNesting

+

+	.def vPortPreemptiveTickISR

+	.def vPortCooperativeTickISR

+	.def vPortYield

+	.def xPortStartScheduler

+

+;-----------------------------------------------------------

+

+portSAVE_CONTEXT .macro

+

+	;Save the remaining registers.

+	pushm_x	#12, r15

+	mov.w	&usCriticalNesting, r14

+	push_x r14

+	mov_x	&pxCurrentTCB, r12

+	mov_x	sp, 0( r12 )

+	.endm

+;-----------------------------------------------------------

+		

+portRESTORE_CONTEXT .macro

+

+	mov_x	&pxCurrentTCB, r12

+	mov_x	@r12, sp

+	pop_x	r15

+	mov.w	r15, &usCriticalNesting

+	popm_x	#12, r15

+	pop.w	sr

+	ret_x

+	.endm

+;-----------------------------------------------------------

+

+;*

+;* The RTOS tick ISR.

+;*

+;* If the cooperative scheduler is in use this simply increments the tick

+;* count.

+;*

+;* If the preemptive scheduler is in use a context switch can also occur.

+;*/

+	

+	.text

+	.align 2

+	

+vPortPreemptiveTickISR: .asmfunc

+	

+	; The sr is not saved in portSAVE_CONTEXT() because vPortYield() needs

+	;to save it manually before it gets modified (interrupts get disabled).

+	push.w sr

+	portSAVE_CONTEXT

+				

+	call_x	#vTaskIncrementTick

+	call_x	#vTaskSwitchContext

+		

+	portRESTORE_CONTEXT

+	.endasmfunc

+;-----------------------------------------------------------

+

+	.align 2

+	

+vPortCooperativeTickISR: .asmfunc

+	

+	; The sr is not saved in portSAVE_CONTEXT() because vPortYield() needs

+	;to save it manually before it gets modified (interrupts get disabled).

+	push.w sr

+	portSAVE_CONTEXT

+				

+	call_x	#vTaskIncrementTick

+		

+	portRESTORE_CONTEXT

+	

+	.endasmfunc

+;-----------------------------------------------------------

+

+;

+; Manual context switch called by the portYIELD() macro.

+;

+

+	.align 2

+

+vPortYield: .asmfunc

+

+	; The sr needs saving before it is modified.

+	push.w	sr

+	

+	; Now the SR is stacked we can disable interrupts.

+	dint	

+	nop

+				

+	; Save the context of the current task.

+	portSAVE_CONTEXT			

+

+	; Select the next task to run.

+	call_x	#vTaskSwitchContext		

+

+	; Restore the context of the new task.

+	portRESTORE_CONTEXT

+	.endasmfunc

+;-----------------------------------------------------------

+

+

+;

+; Start off the scheduler by initialising the RTOS tick timer, then restoring

+; the context of the first task.

+;

+

+	.align 2

+	

+xPortStartScheduler: .asmfunc

+

+	; Setup the hardware to generate the tick.  Interrupts are disabled

+	; when this function is called.

+	call_x	#vPortSetupTimerInterrupt

+

+	; Restore the context of the first task that is going to run.

+	portRESTORE_CONTEXT

+	.endasmfunc

+;-----------------------------------------------------------

+      		

+	.end

+		

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CCS/MSP430X/portmacro.h b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CCS/MSP430X/portmacro.h
new file mode 100644
index 0000000..f0e1b98
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CCS/MSP430X/portmacro.h
@@ -0,0 +1,177 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+#ifndef PORTMACRO_H

+#define PORTMACRO_H

+

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

+ * Port specific definitions.

+ *

+ * The settings in this file configure FreeRTOS correctly for the

+ * given hardware and compiler.

+ *

+ * These settings should not be altered.

+ *-----------------------------------------------------------

+ */

+

+/* Hardware includes. */

+#include "msp430.h"

+

+/* Type definitions. */

+#define portCHAR		char

+#define portFLOAT		float

+#define portDOUBLE		double

+#define portLONG		long

+#define portSHORT		int

+#define portBASE_TYPE	portSHORT

+

+/* The stack type changes depending on the data model. */

+#ifdef __LARGE_DATA_MODEL__

+	#define portSTACK_TYPE unsigned long

+#else

+	#define portSTACK_TYPE unsigned short

+#endif

+

+#if( configUSE_16_BIT_TICKS == 1 )

+	typedef unsigned portSHORT portTickType;

+	#define portMAX_DELAY ( portTickType ) 0xffff

+#else

+	typedef unsigned portLONG portTickType;

+	#define portMAX_DELAY ( portTickType ) 0xffffffff

+#endif

+

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

+

+/* Interrupt control macros. */

+#define portDISABLE_INTERRUPTS()	_disable_interrupt(); _nop()

+#define portENABLE_INTERRUPTS()		_enable_interrupt()

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

+

+/* Critical section control macros. */

+#define portNO_CRITICAL_SECTION_NESTING		( ( unsigned portSHORT ) 0 )

+

+#define portENTER_CRITICAL()													\

+{																				\

+extern volatile unsigned short usCriticalNesting;								\

+																				\

+	portDISABLE_INTERRUPTS();													\

+																				\

+	/* Now interrupts are disabled usCriticalNesting can be accessed */			\

+	/* directly.  Increment ulCriticalNesting to keep a count of how many */	\

+	/* times portENTER_CRITICAL() has been called. */							\

+	usCriticalNesting++;														\

+}

+

+#define portEXIT_CRITICAL()														\

+{																				\

+extern volatile unsigned short usCriticalNesting;								\

+																				\

+	if( usCriticalNesting > portNO_CRITICAL_SECTION_NESTING )					\

+	{																			\

+		/* Decrement the nesting count as we are leaving a critical section. */	\

+		usCriticalNesting--;													\

+																				\

+		/* If the nesting level has reached zero then interrupts should be */	\

+		/* re-enabled. */														\

+		if( usCriticalNesting == portNO_CRITICAL_SECTION_NESTING )				\

+		{																		\

+			portENABLE_INTERRUPTS();											\

+		}																		\

+	}																			\

+}

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

+

+/* Task utilities. */

+

+/*

+ * Manual context switch called by portYIELD or taskYIELD.

+ */

+extern void vPortYield( void );

+#define portYIELD() vPortYield()

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

+

+/* Hardware specifics. */

+#define portBYTE_ALIGNMENT			2

+#define portSTACK_GROWTH			( -1 )

+#define portTICK_RATE_MS			( ( portTickType ) 1000 / configTICK_RATE_HZ )	

+#define portNOP()					__no_operation()	

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

+

+/* Task function macros as described on the FreeRTOS.org WEB site. */

+#define portTASK_FUNCTION_PROTO( vFunction, pvParameters ) void vFunction( void *pvParameters )

+#define portTASK_FUNCTION( vFunction, pvParameters ) void vFunction( void *pvParameters )

+

+extern void vTaskSwitchContext( void );

+#define portYIELD_FROM_ISR( x ) if( x ) vPortYield()

+	

+void vApplicationSetupTimerInterrupt( void );

+

+/* sizeof( int ) != sizeof( long ) so a full printf() library is required if

+run time stats information is to be displayed. */

+#define portLU_PRINTF_SPECIFIER_REQUIRED

+

+#endif /* PORTMACRO_H */

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V1/port.c b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V1/port.c
new file mode 100644
index 0000000..354746c
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V1/port.c
@@ -0,0 +1,227 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+/* Kernel includes. */

+#include "FreeRTOS.h"

+#include "task.h"

+

+

+#define portINITIAL_FORMAT_VECTOR		( ( portSTACK_TYPE ) 0x4000 )

+

+/* Supervisor mode set. */

+#define portINITIAL_STATUS_REGISTER		( ( portSTACK_TYPE ) 0x2000)

+

+/* The clock prescale into the timer peripheral. */

+#define portPRESCALE_VALUE				( ( unsigned char ) 10 )

+

+/* The clock frequency into the RTC. */

+#define portRTC_CLOCK_HZ				( ( unsigned long ) 1000 )

+

+asm void interrupt VectorNumber_VL1swi vPortYieldISR( void );

+static void prvSetupTimerInterrupt( void );

+

+/* Used to keep track of the number of nested calls to taskENTER_CRITICAL().  This

+will be set to 0 prior to the first task being started. */

+static unsigned long ulCriticalNesting = 0x9999UL;

+

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

+

+portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE * pxTopOfStack, pdTASK_CODE pxCode, void *pvParameters )

+{

+

+unsigned long ulOriginalA5;

+

+	__asm{ MOVE.L A5, ulOriginalA5 };

+

+

+	*pxTopOfStack = (portSTACK_TYPE) 0xDEADBEEF;

+	pxTopOfStack--;

+

+	/* Exception stack frame starts with the return address. */

+	*pxTopOfStack = ( portSTACK_TYPE ) pxCode;

+	pxTopOfStack--;

+

+	*pxTopOfStack = ( portINITIAL_FORMAT_VECTOR << 16UL ) | ( portINITIAL_STATUS_REGISTER );

+	pxTopOfStack--;

+

+	*pxTopOfStack = ( portSTACK_TYPE ) 0x0; /*FP*/

+	pxTopOfStack -= 14; /* A5 to D0. */

+

+	/* Parameter in A0. */

+	*( pxTopOfStack + 8 ) = ( portSTACK_TYPE ) pvParameters;

+

+	/* A5 must be maintained as it is resurved by the compiler. */

+	*( pxTopOfStack + 13 ) = ulOriginalA5;

+

+	return pxTopOfStack;  

+}

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

+

+portBASE_TYPE xPortStartScheduler( void )

+{

+extern void vPortStartFirstTask( void );

+

+	ulCriticalNesting = 0UL;

+

+	/* Configure a timer to generate the tick interrupt. */

+	prvSetupTimerInterrupt();

+

+	/* Start the first task executing. */

+	vPortStartFirstTask();

+

+	return pdFALSE;

+}

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

+

+static void prvSetupTimerInterrupt( void )

+{				

+	/* Prescale by 1 - ie no prescale. */

+	RTCSC |= 8;

+	

+	/* Compare match value. */

+	RTCMOD = portRTC_CLOCK_HZ / configTICK_RATE_HZ;

+	

+	/* Enable the RTC to generate interrupts - interrupts are already disabled

+	when this code executes. */

+	RTCSC_RTIE = 1;

+}

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

+

+void vPortEndScheduler( void )

+{

+	/* Not implemented as there is nothing to return to. */

+}

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

+

+void vPortEnterCritical( void )

+{

+	if( ulCriticalNesting == 0UL )

+	{

+		/* Guard against context switches being pended simultaneously with a

+		critical section being entered. */

+		do

+		{

+			portDISABLE_INTERRUPTS();

+			if( INTC_FRC == 0UL )

+			{

+				break;

+			}

+

+			portENABLE_INTERRUPTS();

+

+		} while( 1 );

+	}

+	ulCriticalNesting++;

+}

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

+

+void vPortExitCritical( void )

+{

+	ulCriticalNesting--;

+	if( ulCriticalNesting == 0 )

+	{

+		portENABLE_INTERRUPTS();

+	}

+}

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

+

+void vPortYieldHandler( void )

+{

+unsigned long ulSavedInterruptMask;

+

+	ulSavedInterruptMask = portSET_INTERRUPT_MASK_FROM_ISR();

+	{

+		/* Note this will clear all forced interrupts - this is done for speed. */

+		INTC_CFRC = 0x3E;

+		vTaskSwitchContext();

+	}

+	portCLEAR_INTERRUPT_MASK_FROM_ISR( ulSavedInterruptMask );

+}

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

+

+void interrupt VectorNumber_Vrtc vPortTickISR( void )

+{

+unsigned long ulSavedInterruptMask;

+

+	/* Clear the interrupt. */

+	RTCSC |= RTCSC_RTIF_MASK;

+

+	/* Increment the RTOS tick. */

+	ulSavedInterruptMask = portSET_INTERRUPT_MASK_FROM_ISR();

+	{

+		vTaskIncrementTick();

+	}

+	portCLEAR_INTERRUPT_MASK_FROM_ISR( ulSavedInterruptMask );

+

+	/* If we are using the pre-emptive scheduler then also request a

+	context switch as incrementing the tick could have unblocked a task. */

+	#if configUSE_PREEMPTION == 1

+	{

+		taskYIELD();

+	}

+	#endif

+}

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V1/portasm.S b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V1/portasm.S
new file mode 100644
index 0000000..04b4173
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V1/portasm.S
@@ -0,0 +1,169 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+/*

+ * Purpose: Lowest level routines for all ColdFire processors.

+ *

+ * Notes:

+ * 

+ * ulPortSetIPL() and mcf5xxx_wr_cacr() copied with permission from FreeScale

+ * supplied source files.

+ */

+

+    .global ulPortSetIPL

+    .global _ulPortSetIPL

+    .global mcf5xxx_wr_cacrx

+    .global _mcf5xxx_wr_cacrx

+    .global vPortYieldISR

+    .global _vPortYieldISR

+    .global vPortStartFirstTask

+    .global _vPortStartFirstTask

+    .extern _pxCurrentTCB

+    .extern _vPortYieldHandler

+

+    .text

+

+.macro portSAVE_CONTEXT

+

+	lea.l		(-60, sp), sp

+	movem.l		d0-a6, (sp)

+	move.l		_pxCurrentTCB, a0

+	move.l		sp, (a0)

+

+	.endm

+

+.macro portRESTORE_CONTEXT

+

+	move.l		_pxCurrentTCB, a0

+	move.l		(a0), sp

+	movem.l		(sp), d0-a6

+	lea.l		(60, sp), sp

+	rte

+

+	.endm

+

+/********************************************************************/

+/*

+ * This routines changes the IPL to the value passed into the routine.

+ * It also returns the old IPL value back.

+ * Calling convention from C:

+ *   old_ipl = asm_set_ipl(new_ipl);

+ * For the Diab Data C compiler, it passes return value thru D0.

+ * Note that only the least significant three bits of the passed

+ * value are used.

+ */

+

+ulPortSetIPL:

+_ulPortSetIPL:

+    link    A6,#-8

+    movem.l D6-D7,(SP)

+

+    move.w  SR,D7       /* current sr    */

+

+    move.l  D7,D6       /* prepare return value  */

+    andi.l  #0x0700,D6  /* mask out IPL  */

+    lsr.l   #8,D6       /* IPL   */

+

+    andi.l  #0x07,D0    /* least significant three bits  */

+    lsl.l   #8,D0       /* move over to make mask    */

+

+    andi.l  #0x0000F8FF,D7  /* zero out current IPL  */

+    or.l    D0,D7           /* place new IPL in sr   */

+    move.w  D7,SR

+

+	move.l	D6, D0		/* Return value in D0. */

+    movem.l (SP),D6-D7

+    lea     8(SP),SP

+    unlk    A6

+    rts

+/********************************************************************/

+

+mcf5xxx_wr_cacrx:

+_mcf5xxx_wr_cacrx:

+    move.l  4(sp),d0

+    .long   0x4e7b0002  /* movec d0,cacr   */

+    nop

+    rts

+

+/********************************************************************/

+

+/* Yield interrupt. */

+_vPortYieldISR:

+vPortYieldISR:

+	portSAVE_CONTEXT

+	jsr _vPortYieldHandler

+	portRESTORE_CONTEXT

+

+/********************************************************************/

+

+

+vPortStartFirstTask:

+_vPortStartFirstTask:

+	portRESTORE_CONTEXT

+

+    .end

+

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V1/portmacro.h b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V1/portmacro.h
new file mode 100644
index 0000000..11227d1
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V1/portmacro.h
@@ -0,0 +1,149 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+#ifndef PORTMACRO_H

+#define PORTMACRO_H

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

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

+ * Port specific definitions.

+ *

+ * The settings in this file configure FreeRTOS correctly for the

+ * given hardware and compiler.

+ *

+ * These settings should not be altered.

+ *-----------------------------------------------------------

+ */

+

+/* Type definitions. */

+#define portCHAR		char

+#define portFLOAT		float

+#define portDOUBLE		double

+#define portLONG		long

+#define portSHORT		short

+#define portSTACK_TYPE	unsigned long

+#define portBASE_TYPE	long

+

+#if( configUSE_16_BIT_TICKS == 1 )

+	typedef unsigned portSHORT portTickType;

+	#define portMAX_DELAY ( portTickType ) 0xffff

+#else

+	typedef unsigned portLONG portTickType;

+	#define portMAX_DELAY ( portTickType ) 0xffffffff

+#endif

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

+

+/* Hardware specifics. */

+#define portBYTE_ALIGNMENT			4

+#define portSTACK_GROWTH			-1

+#define portTICK_RATE_MS			( ( portTickType ) 1000 / configTICK_RATE_HZ )

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

+

+unsigned portLONG ulPortSetIPL( unsigned portLONG );

+#define portDISABLE_INTERRUPTS()	ulPortSetIPL( configMAX_SYSCALL_INTERRUPT_PRIORITY )

+#define portENABLE_INTERRUPTS()		ulPortSetIPL( 0 )

+

+

+extern void vPortEnterCritical( void );

+extern void vPortExitCritical( void );

+#define portENTER_CRITICAL()		vPortEnterCritical()

+#define portEXIT_CRITICAL()			vPortExitCritical()

+

+extern unsigned portBASE_TYPE uxPortSetInterruptMaskFromISR( void );

+extern void vPortClearInterruptMaskFromISR( unsigned portBASE_TYPE );

+#define portSET_INTERRUPT_MASK_FROM_ISR()	ulPortSetIPL( configMAX_SYSCALL_INTERRUPT_PRIORITY )

+#define portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedStatusRegister ) ulPortSetIPL( uxSavedStatusRegister )

+

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

+

+/* Task utilities. */

+#define portNOP()	asm volatile ( "nop" )

+

+/* Context switches are requested using the force register. */

+#define portYIELD()	INTC_SFRC = 0x3E; portNOP(); portNOP(); portNOP(); portNOP(); portNOP()

+

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

+

+/* Task function macros as described on the FreeRTOS.org WEB site. */

+#define portTASK_FUNCTION_PROTO( vFunction, pvParameters ) void vFunction( void *pvParameters ) __attribute__((noreturn))

+#define portTASK_FUNCTION( vFunction, pvParameters ) void vFunction( void *pvParameters )

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

+

+#define portEND_SWITCHING_ISR( xSwitchRequired )	if( xSwitchRequired != pdFALSE )	\

+													{									\

+														portYIELD();					\

+													}

+

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif /* PORTMACRO_H */

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V2/port.c b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V2/port.c
new file mode 100644
index 0000000..f8d149e
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V2/port.c
@@ -0,0 +1,186 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+/* Kernel includes. */

+#include "FreeRTOS.h"

+#include "task.h"

+

+

+#define portINITIAL_FORMAT_VECTOR		( ( portSTACK_TYPE ) 0x4000 )

+

+/* Supervisor mode set. */

+#define portINITIAL_STATUS_REGISTER		( ( portSTACK_TYPE ) 0x2000)

+

+/* Used to keep track of the number of nested calls to taskENTER_CRITICAL().  This

+will be set to 0 prior to the first task being started. */

+static unsigned long ulCriticalNesting = 0x9999UL;

+

+

+#define portSAVE_CONTEXT()				\

+	lea.l		(-60, %sp), %sp;		\

+	movem.l		%d0-%fp, (%sp);			\

+	move.l		pxCurrentTCB, %a0;		\

+	move.l		%sp, (%a0);

+

+#define portRESTORE_CONTEXT()			\

+	move.l		pxCurrentTCB, %a0;		\

+	move.l		(%a0), %sp;				\

+	movem.l		(%sp), %d0-%fp;			\

+	lea.l		%sp@(60), %sp;			\

+	rte

+

+

+

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

+

+portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE * pxTopOfStack, pdTASK_CODE pxCode, void *pvParameters )

+{

+	*pxTopOfStack = ( portSTACK_TYPE ) pvParameters;

+	pxTopOfStack--;

+

+	*pxTopOfStack = (portSTACK_TYPE) 0xDEADBEEF;

+	pxTopOfStack--;

+

+	/* Exception stack frame starts with the return address. */

+	*pxTopOfStack = ( portSTACK_TYPE ) pxCode;

+	pxTopOfStack--;

+

+	*pxTopOfStack = ( portINITIAL_FORMAT_VECTOR << 16UL ) | ( portINITIAL_STATUS_REGISTER );

+	pxTopOfStack--;

+

+	*pxTopOfStack = ( portSTACK_TYPE ) 0x0; /*FP*/

+	pxTopOfStack -= 14; /* A5 to D0. */

+

+    return pxTopOfStack;

+}

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

+

+portBASE_TYPE xPortStartScheduler( void )

+{

+extern void vPortStartFirstTask( void );

+

+	ulCriticalNesting = 0UL;

+

+	/* Configure the interrupts used by this port. */

+	vApplicationSetupInterrupts();

+

+	/* Start the first task executing. */

+	vPortStartFirstTask();

+

+	return pdFALSE;

+}

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

+

+void vPortEndScheduler( void )

+{

+	/* Not implemented as there is nothing to return to. */

+}

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

+

+void vPortEnterCritical( void )

+{

+	if( ulCriticalNesting == 0UL )

+	{

+		/* Guard against context switches being pended simultaneously with a

+		critical section being entered. */

+		do

+		{

+			portDISABLE_INTERRUPTS();

+			if( MCF_INTC0_INTFRCH == 0UL )

+			{

+				break;

+			}

+

+			portENABLE_INTERRUPTS();

+

+		} while( 1 );

+	}

+	ulCriticalNesting++;

+}

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

+

+void vPortExitCritical( void )

+{

+	ulCriticalNesting--;

+	if( ulCriticalNesting == 0 )

+	{

+		portENABLE_INTERRUPTS();

+	}

+}

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

+

+void vPortYieldHandler( void )

+{

+unsigned long ulSavedInterruptMask;

+

+	ulSavedInterruptMask = portSET_INTERRUPT_MASK_FROM_ISR();

+		/* Note this will clear all forced interrupts - this is done for speed. */

+		MCF_INTC0_INTFRCL = 0;

+		vTaskSwitchContext();

+	portCLEAR_INTERRUPT_MASK_FROM_ISR( ulSavedInterruptMask );

+}

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

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V2/portasm.S b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V2/portasm.S
new file mode 100644
index 0000000..eeada6c
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V2/portasm.S
@@ -0,0 +1,169 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+/*

+ * Purpose: Lowest level routines for all ColdFire processors.

+ *

+ * Notes:

+ * 

+ * ulPortSetIPL() and mcf5xxx_wr_cacr() copied with permission from FreeScale

+ * supplied source files.

+ */

+

+    .global ulPortSetIPL

+    .global _ulPortSetIPL

+    .global mcf5xxx_wr_cacrx

+    .global _mcf5xxx_wr_cacrx

+    .global vPortYieldISR

+    .global _vPortYieldISR

+    .global vPortStartFirstTask

+    .global _vPortStartFirstTask

+    .extern _pxCurrentTCB

+    .extern _vPortYieldHandler

+

+    .text

+

+.macro portSAVE_CONTEXT

+

+	lea.l		(-60, sp), sp

+	movem.l		d0-a6, (sp)

+	move.l		_pxCurrentTCB, a0

+	move.l		sp, (a0)

+

+	.endm

+

+.macro portRESTORE_CONTEXT

+

+	move.l		_pxCurrentTCB, a0

+	move.l		(a0), sp

+	movem.l		(sp), d0-a6

+	lea.l		(60, sp), sp

+	rte

+

+	.endm

+

+/********************************************************************/

+/*

+ * This routines changes the IPL to the value passed into the routine.

+ * It also returns the old IPL value back.

+ * Calling convention from C:

+ *   old_ipl = asm_set_ipl(new_ipl);

+ * For the Diab Data C compiler, it passes return value thru D0.

+ * Note that only the least significant three bits of the passed

+ * value are used.

+ */

+

+ulPortSetIPL:

+_ulPortSetIPL:

+    link    A6,#-8

+    movem.l D6-D7,(SP)

+

+    move.w  SR,D7       /* current sr    */

+

+    move.l  D7,D0       /* prepare return value  */

+    andi.l  #0x0700,D0  /* mask out IPL  */

+    lsr.l   #8,D0       /* IPL   */

+

+    move.l  8(A6),D6    /* get argument  */

+    andi.l  #0x07,D6    /* least significant three bits  */

+    lsl.l   #8,D6       /* move over to make mask    */

+

+    andi.l  #0x0000F8FF,D7  /* zero out current IPL  */

+    or.l    D6,D7           /* place new IPL in sr   */

+    move.w  D7,SR

+

+    movem.l (SP),D6-D7

+    lea     8(SP),SP

+    unlk    A6

+    rts

+/********************************************************************/

+

+mcf5xxx_wr_cacrx:

+_mcf5xxx_wr_cacrx:

+    move.l  4(sp),d0

+    .long   0x4e7b0002  /* movec d0,cacr   */

+    nop

+    rts

+

+/********************************************************************/

+

+/* Yield interrupt. */

+_vPortYieldISR:

+vPortYieldISR:

+	portSAVE_CONTEXT

+	jsr _vPortYieldHandler

+	portRESTORE_CONTEXT

+

+/********************************************************************/

+

+

+vPortStartFirstTask:

+_vPortStartFirstTask:

+	portRESTORE_CONTEXT

+

+    .end

+

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V2/portmacro.h b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V2/portmacro.h
new file mode 100644
index 0000000..215b62d
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/ColdFire_V2/portmacro.h
@@ -0,0 +1,149 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+#ifndef PORTMACRO_H

+#define PORTMACRO_H

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

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

+ * Port specific definitions.

+ *

+ * The settings in this file configure FreeRTOS correctly for the

+ * given hardware and compiler.

+ *

+ * These settings should not be altered.

+ *-----------------------------------------------------------

+ */

+

+/* Type definitions. */

+#define portCHAR		char

+#define portFLOAT		float

+#define portDOUBLE		double

+#define portLONG		long

+#define portSHORT		short

+#define portSTACK_TYPE	unsigned long

+#define portBASE_TYPE	long

+

+#if( configUSE_16_BIT_TICKS == 1 )

+	typedef unsigned portSHORT portTickType;

+	#define portMAX_DELAY ( portTickType ) 0xffff

+#else

+	typedef unsigned portLONG portTickType;

+	#define portMAX_DELAY ( portTickType ) 0xffffffff

+#endif

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

+

+/* Hardware specifics. */

+#define portBYTE_ALIGNMENT			4

+#define portSTACK_GROWTH			-1

+#define portTICK_RATE_MS			( ( portTickType ) 1000 / configTICK_RATE_HZ )

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

+unsigned portLONG ulPortSetIPL( unsigned portLONG );

+#define portDISABLE_INTERRUPTS()	ulPortSetIPL( configMAX_SYSCALL_INTERRUPT_PRIORITY )

+#define portENABLE_INTERRUPTS()		ulPortSetIPL( 0 )

+

+

+extern void vPortEnterCritical( void );

+extern void vPortExitCritical( void );

+#define portENTER_CRITICAL()		vPortEnterCritical()

+#define portEXIT_CRITICAL()			vPortExitCritical()

+

+extern unsigned portBASE_TYPE uxPortSetInterruptMaskFromISR( void );

+extern void vPortClearInterruptMaskFromISR( unsigned portBASE_TYPE );

+#define portSET_INTERRUPT_MASK_FROM_ISR()	ulPortSetIPL( configMAX_SYSCALL_INTERRUPT_PRIORITY )

+#define portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedStatusRegister ) ulPortSetIPL( uxSavedStatusRegister )

+

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

+

+/* Task utilities. */

+

+#define portNOP()	asm volatile ( 	"nop" )

+

+/* Note this will overwrite all other bits in the force register, it is done this way for speed. */

+#define portYIELD()			MCF_INTC0_INTFRCL = ( 1UL << configYIELD_INTERRUPT_VECTOR ); portNOP(); portNOP() /* -32 as we are using the high word of the 64bit mask. */

+

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

+

+/* Task function macros as described on the FreeRTOS.org WEB site. */

+#define portTASK_FUNCTION_PROTO( vFunction, pvParameters ) void vFunction( void *pvParameters ) __attribute__((noreturn))

+#define portTASK_FUNCTION( vFunction, pvParameters ) void vFunction( void *pvParameters )

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

+

+#define portEND_SWITCHING_ISR( xSwitchRequired )	if( xSwitchRequired != pdFALSE )	\

+													{									\

+														portYIELD();					\

+													}

+

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif /* PORTMACRO_H */

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/HCS12/port.c b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/HCS12/port.c
new file mode 100644
index 0000000..212ec5d
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/HCS12/port.c
@@ -0,0 +1,277 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+/* Scheduler includes. */

+#include "FreeRTOS.h"

+#include "task.h"

+

+

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

+ * Implementation of functions defined in portable.h for the HCS12 port.

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

+

+

+/*

+ * Configure a timer to generate the RTOS tick at the frequency specified 

+ * within FreeRTOSConfig.h.

+ */

+static void prvSetupTimerInterrupt( void );

+

+/* Interrupt service routines have to be in non-banked memory - as does the

+scheduler startup function. */

+#pragma CODE_SEG __NEAR_SEG NON_BANKED

+

+	/* Manual context switch function.  This is the SWI ISR. */

+	void interrupt vPortYield( void );

+

+	/* Tick context switch function.  This is the timer ISR. */

+	void interrupt vPortTickInterrupt( void );

+	

+	/* Simply called by xPortStartScheduler().  xPortStartScheduler() does not

+	start the scheduler directly because the header file containing the 

+	xPortStartScheduler() prototype is part of the common kernel code, and 

+	therefore cannot use the CODE_SEG pragma. */

+	static portBASE_TYPE xBankedStartScheduler( void );

+

+#pragma CODE_SEG DEFAULT

+

+/* Calls to portENTER_CRITICAL() can be nested.  When they are nested the 

+critical section should not be left (i.e. interrupts should not be re-enabled)

+until the nesting depth reaches 0.  This variable simply tracks the nesting 

+depth.  Each task maintains it's own critical nesting depth variable so 

+uxCriticalNesting is saved and restored from the task stack during a context

+switch. */

+volatile unsigned portBASE_TYPE uxCriticalNesting = 0xff;

+

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

+

+/* 

+ * See header file for description. 

+ */

+portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE *pxTopOfStack, pdTASK_CODE pxCode, void *pvParameters )

+{

+	/* 

+		Place a few bytes of known values on the bottom of the stack.

+		This can be uncommented to provide useful stack markers when debugging.

+

+		*pxTopOfStack = ( portSTACK_TYPE ) 0x11;

+		pxTopOfStack--;

+		*pxTopOfStack = ( portSTACK_TYPE ) 0x22;

+		pxTopOfStack--;

+		*pxTopOfStack = ( portSTACK_TYPE ) 0x33;

+		pxTopOfStack--;

+	*/

+

+

+

+	/* Setup the initial stack of the task.  The stack is set exactly as 

+	expected by the portRESTORE_CONTEXT() macro.  In this case the stack as

+	expected by the HCS12 RTI instruction. */

+

+

+	/* The address of the task function is placed in the stack byte at a time. */

+	*pxTopOfStack = ( portSTACK_TYPE ) *( ((portSTACK_TYPE *) (&pxCode) ) + 1 );

+	pxTopOfStack--;

+	*pxTopOfStack = ( portSTACK_TYPE ) *( ((portSTACK_TYPE *) (&pxCode) ) + 0 );

+	pxTopOfStack--;

+

+	/* Next are all the registers that form part of the task context. */

+

+	/* Y register */

+	*pxTopOfStack = ( portSTACK_TYPE ) 0xff;

+	pxTopOfStack--;

+	*pxTopOfStack = ( portSTACK_TYPE ) 0xee;

+	pxTopOfStack--;

+

+	/* X register */

+	*pxTopOfStack = ( portSTACK_TYPE ) 0xdd;

+	pxTopOfStack--;

+	*pxTopOfStack = ( portSTACK_TYPE ) 0xcc;

+	pxTopOfStack--;

+ 

+	/* A register contains parameter high byte. */

+	*pxTopOfStack = ( portSTACK_TYPE ) *( ((portSTACK_TYPE *) (&pvParameters) ) + 0 );

+	pxTopOfStack--;

+

+	/* B register contains parameter low byte. */

+	*pxTopOfStack = ( portSTACK_TYPE ) *( ((portSTACK_TYPE *) (&pvParameters) ) + 1 );

+	pxTopOfStack--;

+

+	/* CCR: Note that when the task starts interrupts will be enabled since

+	"I" bit of CCR is cleared */

+	*pxTopOfStack = ( portSTACK_TYPE ) 0x00;

+	pxTopOfStack--;

+	

+	#ifdef BANKED_MODEL

+		/* The page of the task. */

+		*pxTopOfStack = ( portSTACK_TYPE ) ( ( int ) pxCode );

+		pxTopOfStack--;

+	#endif

+	

+	/* Finally the critical nesting depth is initialised with 0 (not within

+	a critical section). */

+	*pxTopOfStack = ( portSTACK_TYPE ) 0x00;

+

+	return pxTopOfStack;

+}

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

+

+void vPortEndScheduler( void )

+{

+	/* It is unlikely that the HCS12 port will get stopped. */

+}

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

+

+static void prvSetupTimerInterrupt( void )

+{

+	TickTimer_SetFreqHz( configTICK_RATE_HZ );

+	TickTimer_Enable();

+}

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

+

+portBASE_TYPE xPortStartScheduler( void )

+{

+	/* xPortStartScheduler() does not start the scheduler directly because 

+	the header file containing the xPortStartScheduler() prototype is part 

+	of the common kernel code, and therefore cannot use the CODE_SEG pragma. 

+	Instead it simply calls the locally defined xBankedStartScheduler() - 

+	which does use the CODE_SEG pragma. */

+

+	return xBankedStartScheduler();

+}

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

+

+#pragma CODE_SEG __NEAR_SEG NON_BANKED

+

+static portBASE_TYPE xBankedStartScheduler( void )

+{

+	/* Configure the timer that will generate the RTOS tick.  Interrupts are

+	disabled when this function is called. */

+	prvSetupTimerInterrupt();

+

+	/* Restore the context of the first task. */

+	portRESTORE_CONTEXT();

+

+	/* Simulate the end of an interrupt to start the scheduler off. */

+	__asm( "rti" );

+

+	/* Should not get here! */

+	return pdFALSE;

+}

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

+

+/*

+ * Context switch functions.  These are both interrupt service routines.

+ */

+

+/*

+ * Manual context switch forced by calling portYIELD().  This is the SWI

+ * handler.

+ */

+void interrupt vPortYield( void )

+{

+	portSAVE_CONTEXT();

+	vTaskSwitchContext();

+	portRESTORE_CONTEXT();

+}

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

+

+/*

+ * RTOS tick interrupt service routine.  If the cooperative scheduler is 

+ * being used then this simply increments the tick count.  If the 

+ * preemptive scheduler is being used a context switch can occur.

+ */

+void interrupt vPortTickInterrupt( void )

+{

+	#if configUSE_PREEMPTION == 1

+	{

+		/* A context switch might happen so save the context. */

+		portSAVE_CONTEXT();

+

+		/* Increment the tick ... */

+		vTaskIncrementTick();

+

+		/* ... then see if the new tick value has necessitated a

+		context switch. */

+		vTaskSwitchContext();

+

+		TFLG1 = 1;								   

+

+		/* Restore the context of a task - which may be a different task

+		to that interrupted. */

+		portRESTORE_CONTEXT();	

+	}

+	#else

+	{

+		vTaskIncrementTick();

+		TFLG1 = 1;

+	}

+	#endif

+}

+

+#pragma CODE_SEG DEFAULT

+

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/HCS12/portmacro.h b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/HCS12/portmacro.h
new file mode 100644
index 0000000..96035f1
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/CodeWarrior/HCS12/portmacro.h
@@ -0,0 +1,237 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+

+#ifndef PORTMACRO_H

+#define PORTMACRO_H

+

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

+ * Port specific definitions.  

+ *

+ * The settings in this file configure FreeRTOS correctly for the

+ * given hardware and compiler.

+ *

+ * These settings should not be altered.

+ *-----------------------------------------------------------

+ */

+

+/* Type definitions. */

+#define portCHAR		char

+#define portFLOAT		float

+#define portDOUBLE		double

+#define portLONG		long

+#define portSHORT		short

+#define portSTACK_TYPE	unsigned portCHAR

+#define portBASE_TYPE	char

+

+#if( configUSE_16_BIT_TICKS == 1 )

+	typedef unsigned portSHORT portTickType;

+	#define portMAX_DELAY ( portTickType ) 0xffff

+#else

+	typedef unsigned portLONG portTickType;

+	#define portMAX_DELAY ( portTickType ) 0xffffffff

+#endif

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

+

+/* Hardware specifics. */

+#define portBYTE_ALIGNMENT			1

+#define portSTACK_GROWTH			( -1 )

+#define portTICK_RATE_MS			( ( portTickType ) 1000 / configTICK_RATE_HZ )		

+#define portYIELD()					__asm( "swi" );

+#define portNOP()					__asm( "nop" );

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

+

+/* Critical section handling. */

+#define portENABLE_INTERRUPTS()				__asm( "cli" )	

+#define portDISABLE_INTERRUPTS()			__asm( "sei" )

+

+/*

+ * Disable interrupts before incrementing the count of critical section nesting.

+ * The nesting count is maintained so we know when interrupts should be

+ * re-enabled.  Once interrupts are disabled the nesting count can be accessed

+ * directly.  Each task maintains its own nesting count.

+ */

+#define portENTER_CRITICAL()  									\

+{																\

+	extern volatile unsigned portBASE_TYPE uxCriticalNesting;	\

+																\

+	portDISABLE_INTERRUPTS();									\

+	uxCriticalNesting++;										\

+}

+

+/*

+ * Interrupts are disabled so we can access the nesting count directly.  If the

+ * nesting is found to be 0 (no nesting) then we are leaving the critical 

+ * section and interrupts can be re-enabled.

+ */

+#define  portEXIT_CRITICAL()									\

+{																\

+	extern volatile unsigned portBASE_TYPE uxCriticalNesting;	\

+																\

+	uxCriticalNesting--;										\

+	if( uxCriticalNesting == 0 )								\

+	{															\

+		portENABLE_INTERRUPTS();								\

+	}															\

+}

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

+

+/* Task utilities. */

+

+/* 

+ * These macros are very simple as the processor automatically saves and 

+ * restores its registers as interrupts are entered and exited.  In

+ * addition to the (automatically stacked) registers we also stack the 

+ * critical nesting count.  Each task maintains its own critical nesting

+ * count as it is legitimate for a task to yield from within a critical

+ * section.  If the banked memory model is being used then the PPAGE

+ * register is also stored as part of the tasks context.

+ */

+

+#ifdef BANKED_MODEL

+	/* 

+	 * Load the stack pointer for the task, then pull the critical nesting

+	 * count and PPAGE register from the stack.  The remains of the 

+	 * context are restored by the RTI instruction.

+	 */

+	#define portRESTORE_CONTEXT()									\

+	{																\

+		extern volatile void * pxCurrentTCB;						\

+		extern volatile unsigned portBASE_TYPE uxCriticalNesting;	\

+																	\

+		__asm( "ldx pxCurrentTCB" );								\

+		__asm( "lds 0, x" );										\

+		__asm( "pula" );											\

+		__asm( "staa uxCriticalNesting" );							\

+		__asm( "pula" );											\

+		__asm( "staa 0x30" ); /* 0x30 = PPAGE */					\

+	}

+

+	/* 

+	 * By the time this macro is called the processor has already stacked the

+	 * registers.  Simply stack the nesting count and PPAGE value, then save 

+	 * the task stack pointer.

+	 */

+	#define portSAVE_CONTEXT()										\

+	{																\

+		extern volatile void * pxCurrentTCB;						\

+		extern volatile unsigned portBASE_TYPE uxCriticalNesting;	\

+																	\

+		__asm( "ldaa 0x30" );  /* 0x30 = PPAGE */					\

+		__asm( "psha" );											\

+		__asm( "ldaa uxCriticalNesting" );							\

+		__asm( "psha" );											\

+		__asm( "ldx pxCurrentTCB" );								\

+		__asm( "sts 0, x" );										\

+	}

+#else

+

+	/* 

+	 * These macros are as per the BANKED versions above, but without saving

+	 * and restoring the PPAGE register.

+	 */

+

+	#define portRESTORE_CONTEXT()									\

+	{																\

+		extern volatile void * pxCurrentTCB;						\

+		extern volatile unsigned portBASE_TYPE uxCriticalNesting;	\

+																	\

+		__asm( "ldx pxCurrentTCB" );								\

+		__asm( "lds 0, x" );										\

+		__asm( "pula" );											\

+		__asm( "staa uxCriticalNesting" );							\

+	}

+

+	#define portSAVE_CONTEXT()										\

+	{																\

+		extern volatile void * pxCurrentTCB;						\

+		extern volatile unsigned portBASE_TYPE uxCriticalNesting;	\

+																	\

+		__asm( "ldaa uxCriticalNesting" );							\

+		__asm( "psha" );											\

+		__asm( "ldx pxCurrentTCB" );								\

+		__asm( "sts 0, x" );										\

+	}

+#endif

+

+/*

+ * Utility macro to call macros above in correct order in order to perform a

+ * task switch from within a standard ISR.  This macro can only be used if

+ * the ISR does not use any local (stack) variables.  If the ISR uses stack

+ * variables portYIELD() should be used in it's place.

+ */

+#define portTASK_SWITCH_FROM_ISR()								\

+	portSAVE_CONTEXT();											\

+	vTaskSwitchContext();										\

+	portRESTORE_CONTEXT();

+

+

+/* Task function macros as described on the FreeRTOS.org WEB site. */

+#define portTASK_FUNCTION_PROTO( vFunction, pvParameters ) void vFunction( void *pvParameters )

+#define portTASK_FUNCTION( vFunction, pvParameters ) void vFunction( void *pvParameters )

+

+#endif /* PORTMACRO_H */

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/GCC/ARM7_AT91FR40008/port.c b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/GCC/ARM7_AT91FR40008/port.c
new file mode 100644
index 0000000..5948ac3
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/GCC/ARM7_AT91FR40008/port.c
@@ -0,0 +1,277 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+

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

+ * Implementation of functions defined in portable.h for the Atmel AT91R40008

+ * port.

+ *

+ * Components that can be compiled to either ARM or THUMB mode are

+ * contained in this file.  The ISR routines, which can only be compiled

+ * to ARM mode are contained in portISR.c.

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

+

+/* Standard includes. */

+#include <stdlib.h>

+

+/* Scheduler includes. */

+#include "FreeRTOS.h"

+#include "task.h"

+

+/* Hardware specific definitions. */

+#include "AT91R40008.h"

+#include "pio.h"

+#include "aic.h"

+#include "tc.h"

+

+/* Constants required to setup the task context. */

+#define portINITIAL_SPSR				( ( portSTACK_TYPE ) 0x1f ) /* System mode, ARM mode, interrupts enabled. */

+#define portTHUMB_MODE_BIT				( ( portSTACK_TYPE ) 0x20 )

+#define portINSTRUCTION_SIZE			( ( portSTACK_TYPE ) 4 )

+#define portNO_CRITICAL_SECTION_NESTING	( ( portSTACK_TYPE ) 0 )

+#define portTICK_PRIORITY_6				( 6 )

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

+

+/* Setup the timer to generate the tick interrupts. */

+static void prvSetupTimerInterrupt( void );

+

+/* 

+ * The scheduler can only be started from ARM mode, so 

+ * vPortISRStartFirstSTask() is defined in portISR.c. 

+ */

+extern void vPortISRStartFirstTask( void );

+

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

+

+/* 

+ * Initialise the stack of a task to look exactly as if a call to 

+ * portSAVE_CONTEXT had been called.

+ *

+ * See header file for description. 

+ */

+portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE *pxTopOfStack, pdTASK_CODE pxCode, void *pvParameters )

+{

+portSTACK_TYPE *pxOriginalTOS;

+

+	pxOriginalTOS = pxTopOfStack;

+	

+	/* To ensure asserts in tasks.c don't fail, although in this case the assert

+	is not really required. */

+	pxTopOfStack--;

+

+	/* Setup the initial stack of the task.  The stack is set exactly as 

+	expected by the portRESTORE_CONTEXT() macro. */

+

+	/* First on the stack is the return address - which in this case is the

+	start of the task.  The offset is added to make the return address appear

+	as it would within an IRQ ISR. */

+	*pxTopOfStack = ( portSTACK_TYPE ) pxCode + portINSTRUCTION_SIZE;		

+	pxTopOfStack--;

+

+	*pxTopOfStack = ( portSTACK_TYPE ) 0xaaaaaaaa;	/* R14 */

+	pxTopOfStack--;	

+	*pxTopOfStack = ( portSTACK_TYPE ) pxOriginalTOS; /* Stack used when task starts goes in R13. */

+	pxTopOfStack--;

+	*pxTopOfStack = ( portSTACK_TYPE ) 0x12121212;	/* R12 */

+	pxTopOfStack--;	

+	*pxTopOfStack = ( portSTACK_TYPE ) 0x11111111;	/* R11 */

+	pxTopOfStack--;	

+	*pxTopOfStack = ( portSTACK_TYPE ) 0x10101010;	/* R10 */

+	pxTopOfStack--;	

+	*pxTopOfStack = ( portSTACK_TYPE ) 0x09090909;	/* R9 */

+	pxTopOfStack--;	

+	*pxTopOfStack = ( portSTACK_TYPE ) 0x08080808;	/* R8 */

+	pxTopOfStack--;	

+	*pxTopOfStack = ( portSTACK_TYPE ) 0x07070707;	/* R7 */

+	pxTopOfStack--;	

+	*pxTopOfStack = ( portSTACK_TYPE ) 0x06060606;	/* R6 */

+	pxTopOfStack--;	

+	*pxTopOfStack = ( portSTACK_TYPE ) 0x05050505;	/* R5 */

+	pxTopOfStack--;	

+	*pxTopOfStack = ( portSTACK_TYPE ) 0x04040404;	/* R4 */

+	pxTopOfStack--;	

+	*pxTopOfStack = ( portSTACK_TYPE ) 0x03030303;	/* R3 */

+	pxTopOfStack--;	

+	*pxTopOfStack = ( portSTACK_TYPE ) 0x02020202;	/* R2 */

+	pxTopOfStack--;	

+	*pxTopOfStack = ( portSTACK_TYPE ) 0x01010101;	/* R1 */

+	pxTopOfStack--;	

+

+	/* When the task starts is will expect to find the function parameter in

+	R0. */

+	*pxTopOfStack = ( portSTACK_TYPE ) pvParameters; /* R0 */

+	pxTopOfStack--;

+

+	/* The last thing onto the stack is the status register, which is set for

+	system mode, with interrupts enabled. */

+	*pxTopOfStack = ( portSTACK_TYPE ) portINITIAL_SPSR;

+

+	#ifdef THUMB_INTERWORK

+	{

+		/* We want the task to start in thumb mode. */

+		*pxTopOfStack |= portTHUMB_MODE_BIT;

+	}

+	#endif

+

+	pxTopOfStack--;

+

+	/* Some optimisation levels use the stack differently to others.  This 

+	means the interrupt flags cannot always be stored on the stack and will

+	instead be stored in a variable, which is then saved as part of the

+	tasks context. */

+	*pxTopOfStack = portNO_CRITICAL_SECTION_NESTING;

+

+	return pxTopOfStack;

+}

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

+

+portBASE_TYPE xPortStartScheduler( void )

+{

+	/* Start the timer that generates the tick ISR.  Interrupts are disabled

+	here already. */

+	prvSetupTimerInterrupt();

+

+	/* Start the first task. */

+	vPortISRStartFirstTask();	

+

+	/* Should not get here! */

+	return 0;

+}

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

+

+void vPortEndScheduler( void )

+{

+	/* It is unlikely that the ARM port will require this function as there

+	is nothing to return to.  */

+}

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

+

+/*

+ * Setup the tick timer to generate the tick interrupts at the required frequency.

+ */

+static void prvSetupTimerInterrupt( void )

+{

+volatile unsigned long ulDummy;

+

+	/* Enable clock to the tick timer... */

+	AT91C_BASE_PS->PS_PCER = portTIMER_CLK_ENABLE_BIT;

+

+	/* Stop the tick timer... */

+	portTIMER_REG_BASE_PTR->TC_CCR = TC_CLKDIS;

+

+	/* Start with tick timer interrupts disabled... */

+	portTIMER_REG_BASE_PTR->TC_IDR = 0xFFFFFFFF;

+

+	/* Clear any pending tick timer interrupts... */

+	ulDummy = portTIMER_REG_BASE_PTR->TC_SR;

+

+	/* Store interrupt handler function address in tick timer vector register...

+	The ISR installed depends on whether the preemptive or cooperative

+	scheduler is being used. */

+	#if configUSE_PREEMPTION == 1

+	{

+		extern void ( vPreemptiveTick )( void );

+		AT91C_BASE_AIC->AIC_SVR[portTIMER_AIC_CHANNEL] = ( unsigned long ) vPreemptiveTick;

+	}

+	#else  // else use cooperative scheduler

+	{

+		extern void ( vNonPreemptiveTick )( void );

+		AT91C_BASE_AIC->AIC_SVR[portTIMER_AIC_CHANNEL] = ( unsigned long ) vNonPreemptiveTick;

+	}

+	#endif

+

+	/* Tick timer interrupt level-sensitive, priority 6... */

+	AT91C_BASE_AIC->AIC_SMR[ portTIMER_AIC_CHANNEL ] = AIC_SRCTYPE_INT_LEVEL_SENSITIVE | portTICK_PRIORITY_6;

+

+	/* Enable the tick timer interrupt...

+

+	First at timer level */

+	portTIMER_REG_BASE_PTR->TC_IER = TC_CPCS;

+

+	/* Then at the AIC level. */

+	AT91C_BASE_AIC->AIC_IECR = (1 << portTIMER_AIC_CHANNEL);

+

+	/* Calculate timer compare value to achieve the desired tick rate... */

+	if( (configCPU_CLOCK_HZ / (configTICK_RATE_HZ * 2) ) <= 0xFFFF )

+	{

+		/* The tick rate is fast enough for us to use the faster timer input

+		clock (main clock / 2). */

+		portTIMER_REG_BASE_PTR->TC_CMR = TC_WAVE | TC_CLKS_MCK2 | TC_BURST_NONE | TC_CPCTRG;

+		portTIMER_REG_BASE_PTR->TC_RC  = configCPU_CLOCK_HZ / (configTICK_RATE_HZ * 2);

+	}

+	else

+	{

+		/* We must use a slower timer input clock (main clock / 8) because the

+		tick rate is too slow for the faster input clock. */

+		portTIMER_REG_BASE_PTR->TC_CMR = TC_WAVE | TC_CLKS_MCK8 | TC_BURST_NONE | TC_CPCTRG;

+		portTIMER_REG_BASE_PTR->TC_RC  = configCPU_CLOCK_HZ / (configTICK_RATE_HZ * 8);

+	}

+

+	/* Start tick timer... */

+	portTIMER_REG_BASE_PTR->TC_CCR = TC_SWTRG | TC_CLKEN;

+}

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

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/GCC/ARM7_AT91FR40008/portISR.c b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/GCC/ARM7_AT91FR40008/portISR.c
new file mode 100644
index 0000000..8699ce4
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/GCC/ARM7_AT91FR40008/portISR.c
@@ -0,0 +1,270 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+

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

+ * Components that can be compiled to either ARM or THUMB mode are

+ * contained in port.c  The ISR routines, which can only be compiled

+ * to ARM mode, are contained in this file.

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

+

+/*

+	Changes from V3.2.4

+

+	+ The assembler statements are now included in a single asm block rather

+	  than each line having its own asm block.

+*/

+

+

+/* Scheduler includes. */

+#include "FreeRTOS.h"

+#include "task.h"

+

+/* Constants required to handle interrupts. */

+#define portCLEAR_AIC_INTERRUPT		( ( unsigned long ) 0 )

+

+/* Constants required to handle critical sections. */

+#define portNO_CRITICAL_NESTING		( ( unsigned long ) 0 )

+volatile unsigned long ulCriticalNesting = 9999UL;

+

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

+

+/* ISR to handle manual context switches (from a call to taskYIELD()). */

+void vPortYieldProcessor( void ) __attribute__((interrupt("SWI"), naked));

+

+/* 

+ * The scheduler can only be started from ARM mode, hence the inclusion of this

+ * function here.

+ */

+void vPortISRStartFirstTask( void );

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

+

+void vPortISRStartFirstTask( void )

+{

+	/* Simply start the scheduler.  This is included here as it can only be

+	called from ARM mode. */

+	portRESTORE_CONTEXT();

+}

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

+

+/*

+ * Called by portYIELD() or taskYIELD() to manually force a context switch.

+ *

+ * When a context switch is performed from the task level the saved task 

+ * context is made to look as if it occurred from within the tick ISR.  This

+ * way the same restore context function can be used when restoring the context

+ * saved from the ISR or that saved from a call to vPortYieldProcessor.

+ */

+void vPortYieldProcessor( void )

+{

+	/* Within an IRQ ISR the link register has an offset from the true return 

+	address, but an SWI ISR does not.  Add the offset manually so the same 

+	ISR return code can be used in both cases. */

+	asm volatile ( "ADD		LR, LR, #4" );

+

+	/* Perform the context switch.  First save the context of the current task. */

+	portSAVE_CONTEXT();

+

+	/* Find the highest priority task that is ready to run. */

+	vTaskSwitchContext();

+

+	/* Restore the context of the new task. */

+	portRESTORE_CONTEXT();	

+}

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

+

+/* 

+ * The ISR used for the scheduler tick depends on whether the cooperative or

+ * the preemptive scheduler is being used.

+ */

+

+#if configUSE_PREEMPTION == 0

+

+	/* The cooperative scheduler requires a normal IRQ service routine to 

+	simply increment the system tick. */

+	void vNonPreemptiveTick( void ) __attribute__ ((interrupt ("IRQ")));

+	void vNonPreemptiveTick( void )

+	{		

+	static volatile unsigned long ulDummy;

+

+		/* Clear tick timer interrupt indication. */

+		ulDummy = portTIMER_REG_BASE_PTR->TC_SR;  

+

+		vTaskIncrementTick();

+

+		/* Acknowledge the interrupt at AIC level... */

+		AT91C_BASE_AIC->AIC_EOICR = portCLEAR_AIC_INTERRUPT;

+	}

+

+#else  /* else preemption is turned on */

+

+	/* The preemptive scheduler is defined as "naked" as the full context is

+	saved on entry as part of the context switch. */

+	void vPreemptiveTick( void ) __attribute__((naked));

+	void vPreemptiveTick( void )

+	{

+		/* Save the context of the interrupted task. */

+		portSAVE_CONTEXT();	

+

+		/* WARNING - Do not use local (stack) variables here.  Use globals

+					 if you must! */

+		static volatile unsigned long ulDummy;

+

+		/* Clear tick timer interrupt indication. */

+		ulDummy = portTIMER_REG_BASE_PTR->TC_SR;  

+

+		/* Increment the RTOS tick count, then look for the highest priority 

+		task that is ready to run. */

+		vTaskIncrementTick();

+		vTaskSwitchContext();

+

+		/* Acknowledge the interrupt at AIC level... */

+		AT91C_BASE_AIC->AIC_EOICR = portCLEAR_AIC_INTERRUPT;

+

+		/* Restore the context of the new task. */

+		portRESTORE_CONTEXT();

+	}

+

+#endif

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

+

+/*

+ * The interrupt management utilities can only be called from ARM mode.  When

+ * THUMB_INTERWORK is defined the utilities are defined as functions here to

+ * ensure a switch to ARM mode.  When THUMB_INTERWORK is not defined then

+ * the utilities are defined as macros in portmacro.h - as per other ports.

+ */

+#ifdef THUMB_INTERWORK

+

+	void vPortDisableInterruptsFromThumb( void ) __attribute__ ((naked));

+	void vPortEnableInterruptsFromThumb( void ) __attribute__ ((naked));

+

+	void vPortDisableInterruptsFromThumb( void )

+	{

+		asm volatile ( 

+			"STMDB	SP!, {R0}		\n\t"	/* Push R0.									*/

+			"MRS	R0, CPSR		\n\t"	/* Get CPSR.								*/

+			"ORR	R0, R0, #0xC0	\n\t"	/* Disable IRQ, FIQ.						*/

+			"MSR	CPSR, R0		\n\t"	/* Write back modified value.				*/

+			"LDMIA	SP!, {R0}		\n\t"	/* Pop R0.									*/

+			"BX		R14" );					/* Return back to thumb.					*/

+	}

+			

+	void vPortEnableInterruptsFromThumb( void )

+	{

+		asm volatile ( 

+			"STMDB	SP!, {R0}		\n\t"	/* Push R0.									*/	

+			"MRS	R0, CPSR		\n\t"	/* Get CPSR.								*/	

+			"BIC	R0, R0, #0xC0	\n\t"	/* Enable IRQ, FIQ.							*/	

+			"MSR	CPSR, R0		\n\t"	/* Write back modified value.				*/	

+			"LDMIA	SP!, {R0}		\n\t"	/* Pop R0.									*/

+			"BX		R14" );					/* Return back to thumb.					*/

+	}

+

+#endif /* THUMB_INTERWORK */

+

+/* The code generated by the GCC compiler uses the stack in different ways at

+different optimisation levels.  The interrupt flags can therefore not always

+be saved to the stack.  Instead the critical section nesting level is stored

+in a variable, which is then saved as part of the stack context. */

+void vPortEnterCritical( void )

+{

+	/* Disable interrupts as per portDISABLE_INTERRUPTS(); 							*/

+	asm volatile ( 

+		"STMDB	SP!, {R0}			\n\t"	/* Push R0.								*/

+		"MRS	R0, CPSR			\n\t"	/* Get CPSR.							*/

+		"ORR	R0, R0, #0xC0		\n\t"	/* Disable IRQ, FIQ.					*/

+		"MSR	CPSR, R0			\n\t"	/* Write back modified value.			*/

+		"LDMIA	SP!, {R0}" );				/* Pop R0.								*/

+

+	/* Now interrupts are disabled ulCriticalNesting can be accessed 

+	directly.  Increment ulCriticalNesting to keep a count of how many times

+	portENTER_CRITICAL() has been called. */

+	ulCriticalNesting++;

+}

+

+void vPortExitCritical( void )

+{

+	if( ulCriticalNesting > portNO_CRITICAL_NESTING )

+	{

+		/* Decrement the nesting count as we are leaving a critical section. */

+		ulCriticalNesting--;

+

+		/* If the nesting level has reached zero then interrupts should be

+		re-enabled. */

+		if( ulCriticalNesting == portNO_CRITICAL_NESTING )

+		{

+			/* Enable interrupts as per portEXIT_CRITICAL().				*/

+			asm volatile ( 

+				"STMDB	SP!, {R0}		\n\t"	/* Push R0.						*/	

+				"MRS	R0, CPSR		\n\t"	/* Get CPSR.					*/	

+				"BIC	R0, R0, #0xC0	\n\t"	/* Enable IRQ, FIQ.				*/	

+				"MSR	CPSR, R0		\n\t"	/* Write back modified value.	*/	

+				"LDMIA	SP!, {R0}" );			/* Pop R0.						*/

+		}

+	}

+}

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/GCC/ARM7_AT91FR40008/portmacro.h b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/GCC/ARM7_AT91FR40008/portmacro.h
new file mode 100644
index 0000000..c31aae2
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/GCC/ARM7_AT91FR40008/portmacro.h
@@ -0,0 +1,290 @@
+/*

+    FreeRTOS V7.2.0 - Copyright (C) 2012 Real Time Engineers Ltd.

+	

+

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

+     *                                                                       *

+     *    FreeRTOS tutorial books are available in pdf and paperback.        *

+     *    Complete, revised, and edited pdf reference manuals are also       *

+     *    available.                                                         *

+     *                                                                       *

+     *    Purchasing FreeRTOS documentation will not only help you, by       *

+     *    ensuring you get running as quickly as possible and with an        *

+     *    in-depth knowledge of how to use FreeRTOS, it will also help       *

+     *    the FreeRTOS project to continue with its mission of providing     *

+     *    professional grade, cross platform, de facto standard solutions    *

+     *    for microcontrollers - completely free of charge!                  *

+     *                                                                       *

+     *    >>> See http://www.FreeRTOS.org/Documentation for details. <<<     *

+     *                                                                       *

+     *    Thank you for using FreeRTOS, and thank you for your support!      *

+     *                                                                       *

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

+

+

+    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.  See the GNU General Public License for

+    more details. You should have received a copy of the GNU General Public

+    License and the FreeRTOS license exception along with FreeRTOS; if not it

+    can be viewed here: http://www.freertos.org/a00114.html and also obtained

+    by writing to Richard Barry, contact details for whom are available on the

+    FreeRTOS WEB site.

+

+    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, training, latest information, 

+    license and contact details.

+    

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

+    including FreeRTOS+Trace - an indispensable productivity tool.

+

+    Real Time Engineers ltd license FreeRTOS to High Integrity Systems, who sell 

+    the code with commercial support, indemnification, and middleware, under 

+    the OpenRTOS brand: http://www.OpenRTOS.com.  High Integrity Systems also

+    provide a safety engineered and independently SIL3 certified version under 

+    the SafeRTOS brand: http://www.SafeRTOS.com.

+*/

+

+/*

+	Changes from V3.2.3

+	

+	+ Modified portENTER_SWITCHING_ISR() to allow use with GCC V4.0.1.

+

+	Changes from V3.2.4

+

+	+ Removed the use of the %0 parameter within the assembler macros and 

+	  replaced them with hard coded registers.  This will ensure the

+	  assembler does not select the link register as the temp register as

+	  was occasionally happening previously.

+

+	+ The assembler statements are now included in a single asm block rather

+	  than each line having its own asm block.

+

+	Changes from V4.5.0

+

+	+ Removed the portENTER_SWITCHING_ISR() and portEXIT_SWITCHING_ISR() macros

+	  and replaced them with portYIELD_FROM_ISR() macro.  Application code 

+	  should now make use of the portSAVE_CONTEXT() and portRESTORE_CONTEXT()

+	  macros as per the V4.5.1 demo code.

+*/

+

+#ifndef PORTMACRO_H

+#define PORTMACRO_H

+

+#ifdef __cplusplus

+extern "C" {

+#endif

+

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

+ * Port specific definitions.  

+ *

+ * The settings in this file configure FreeRTOS correctly for the

+ * given hardware and compiler.

+ *

+ * These settings should not be altered.

+ *-----------------------------------------------------------

+ */

+

+/* Type definitions. */

+#define portCHAR		char

+#define portFLOAT		float

+#define portDOUBLE		double

+#define portLONG		long

+#define portSHORT		short

+#define portSTACK_TYPE	unsigned portLONG

+#define portBASE_TYPE	long

+

+#if( configUSE_16_BIT_TICKS == 1 )

+	typedef unsigned portSHORT portTickType;

+	#define portMAX_DELAY ( portTickType ) 0xffff

+#else

+	typedef unsigned portLONG portTickType;

+	#define portMAX_DELAY ( portTickType ) 0xffffffff

+#endif

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

+

+/* Hardware specifics. */

+#define portSTACK_GROWTH			( -1 )

+#define portTICK_RATE_MS			( ( portTickType ) 1000 / configTICK_RATE_HZ )		

+#define portBYTE_ALIGNMENT			8

+#define portYIELD()					asm volatile ( "SWI 0" )

+#define portNOP()					asm volatile ( "NOP" )

+

+/*

+ * These define the timer to use for generating the tick interrupt.

+ * They are put in this file so they can be shared between "port.c"

+ * and "portisr.c".

+ */

+#define portTIMER_REG_BASE_PTR		AT91C_BASE_TC0

+#define portTIMER_CLK_ENABLE_BIT	AT91C_PS_TC0

+#define portTIMER_AIC_CHANNEL		( ( unsigned portLONG ) 4 )

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

+

+/* Task utilities. */

+

+/*

+ * portRESTORE_CONTEXT, portRESTORE_CONTEXT, portENTER_SWITCHING_ISR

+ * and portEXIT_SWITCHING_ISR can only be called from ARM mode, but

+ * are included here for efficiency.  An attempt to call one from

+ * THUMB mode code will result in a compile time error.

+ */

+

+#define portRESTORE_CONTEXT()											\

+{																		\

+extern volatile void * volatile pxCurrentTCB;							\

+extern volatile unsigned portLONG ulCriticalNesting;					\

+																		\

+	/* Set the LR to the task stack. */									\

+	asm volatile (														\

+	"LDR		R0, =pxCurrentTCB								\n\t"	\

+	"LDR		R0, [R0]										\n\t"	\

+	"LDR		LR, [R0]										\n\t"	\

+																		\

+	/* The critical nesting depth is the first item on the stack. */	\

+	/* Load it into the ulCriticalNesting variable. */					\

+	"LDR		R0, =ulCriticalNesting							\n\t"	\

+	"LDMFD	LR!, {R1}											\n\t"	\

+	"STR		R1, [R0]										\n\t"	\

+																		\

+	/* Get the SPSR from the stack. */									\

+	"LDMFD	LR!, {R0}											\n\t"	\

+	"MSR		SPSR, R0										\n\t"	\

+																		\

+	/* Restore all system mode registers for the task. */				\

+	"LDMFD	LR, {R0-R14}^										\n\t"	\

+	"NOP														\n\t"	\

+																		\

+	/* Restore the return address. */									\

+	"LDR		LR, [LR, #+60]									\n\t"	\

+																		\

+	/* And return - correcting the offset in the LR to obtain the */	\

+	/* correct address. */												\

+	"SUBS	PC, LR, #4											\n\t"	\

+	);																	\

+	( void ) ulCriticalNesting;											\

+	( void ) pxCurrentTCB;												\

+}

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

+

+#define portSAVE_CONTEXT()												\

+{																		\

+extern volatile void * volatile pxCurrentTCB;							\

+extern volatile unsigned portLONG ulCriticalNesting;					\

+																		\

+	/* Push R0 as we are going to use the register. */					\

+	asm volatile (														\

+	"STMDB	SP!, {R0}											\n\t"	\

+																		\

+	/* Set R0 to point to the task stack pointer. */					\

+	"STMDB	SP,{SP}^											\n\t"	\

+	"NOP														\n\t"	\

+	"SUB	SP, SP, #4											\n\t"	\

+	"LDMIA	SP!,{R0}											\n\t"	\

+																		\

+	/* Push the return address onto the stack. */						\

+	"STMDB	R0!, {LR}											\n\t"	\

+																		\

+	/* Now we have saved LR we can use it instead of R0. */				\

+	"MOV	LR, R0												\n\t"	\

+																		\

+	/* Pop R0 so we can save it onto the system mode stack. */			\

+	"LDMIA	SP!, {R0}											\n\t"	\

+																		\

+	/* Push all the system mode registers onto the task stack. */		\

+	"STMDB	LR,{R0-LR}^											\n\t"	\

+	"NOP														\n\t"	\

+	"SUB	LR, LR, #60											\n\t"	\

+																		\

+	/* Push the SPSR onto the task stack. */							\

+	"MRS	R0, SPSR											\n\t"	\

+	"STMDB	LR!, {R0}											\n\t"	\

+																		\

+	"LDR	R0, =ulCriticalNesting								\n\t"	\

+	"LDR	R0, [R0]											\n\t"	\

+	"STMDB	LR!, {R0}											\n\t"	\

+																		\

+	/* Store the new top of stack for the task. */						\

+	"LDR	R0, =pxCurrentTCB									\n\t"	\

+	"LDR	R0, [R0]											\n\t"	\

+	"STR	LR, [R0]											\n\t"	\

+	);																	\

+	( void ) ulCriticalNesting;											\

+	( void ) pxCurrentTCB;												\

+}

+

+#define portYIELD_FROM_ISR() vTaskSwitchContext()

+

+/* Critical section handling. */

+

+/*

+ * The interrupt management utilities can only be called from ARM mode.  When

+ * THUMB_INTERWORK is defined the utilities are defined as functions in 

+ * portISR.c to ensure a switch to ARM mode.  When THUMB_INTERWORK is not 

+ * defined then the utilities are defined as macros here - as per other ports.

+ */

+

+#ifdef THUMB_INTERWORK

+

+	extern void vPortDisableInterruptsFromThumb( void ) __attribute__ ((naked));

+	extern void vPortEnableInterruptsFromThumb( void ) __attribute__ ((naked));

+

+	#define portDISABLE_INTERRUPTS()	vPortDisableInterruptsFromThumb()

+	#define portENABLE_INTERRUPTS()		vPortEnableInterruptsFromThumb()

+	

+#else

+

+	#define portDISABLE_INTERRUPTS()											\

+		asm volatile (															\

+			"STMDB	SP!, {R0}		\n\t"	/* Push R0.						*/	\

+			"MRS	R0, CPSR		\n\t"	/* Get CPSR.					*/	\

+			"ORR	R0, R0, #0xC0	\n\t"	/* Disable IRQ, FIQ.			*/	\

+			"MSR	CPSR, R0		\n\t"	/* Write back modified value.	*/	\

+			"LDMIA	SP!, {R0}			" )	/* Pop R0.						*/

+			

+	#define portENABLE_INTERRUPTS()												\

+		asm volatile (															\

+			"STMDB	SP!, {R0}		\n\t"	/* Push R0.						*/	\

+			"MRS	R0, CPSR		\n\t"	/* Get CPSR.					*/	\

+			"BIC	R0, R0, #0xC0	\n\t"	/* Enable IRQ, FIQ.				*/	\

+			"MSR	CPSR, R0		\n\t"	/* Write back modified value.	*/	\

+			"LDMIA	SP!, {R0}			" )	/* Pop R0.						*/

+

+#endif /* THUMB_INTERWORK */

+

+extern void vPortEnterCritical( void );

+extern void vPortExitCritical( void );

+

+#define portENTER_CRITICAL()		vPortEnterCritical();

+#define portEXIT_CRITICAL()			vPortExitCritical();

+

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

+

+/* Task function macros as described on the FreeRTOS.org WEB site. */

+#define portTASK_FUNCTION_PROTO( vFunction, pvParameters ) void vFunction( void *pvParameters )

+#define portTASK_FUNCTION( vFunction, pvParameters ) void vFunction( void *pvParameters )

+

+#ifdef __cplusplus

+}

+#endif

+

+#endif /* PORTMACRO_H */

+

diff --git a/FreeRTOSV7.2.0/FreeRTOS/Source/portable/GCC/ARM7_AT91SAM7S/AT91SAM7X256.h b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/GCC/ARM7_AT91SAM7S/AT91SAM7X256.h
new file mode 100644
index 0000000..a14279e
--- /dev/null
+++ b/FreeRTOSV7.2.0/FreeRTOS/Source/portable/GCC/ARM7_AT91SAM7S/AT91SAM7X256.h
@@ -0,0 +1,2731 @@
+//  ----------------------------------------------------------------------------

+//          ATMEL Microcontroller Software Support  -  ROUSSET  -

+//  ----------------------------------------------------------------------------

+//  DISCLAIMER:  THIS SOFTWARE IS PROVIDED BY ATMEL "AS IS" AND ANY EXPRESS OR

+//  IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF

+//  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT ARE

+//  DISCLAIMED. IN NO EVENT SHALL ATMEL BE LIABLE FOR ANY DIRECT, INDIRECT,

+//  INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT

+//  LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA,

+//  OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF

+//  LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING

+//  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,

+//  EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

+//  ----------------------------------------------------------------------------

+// File Name           : AT91SAM7X256.h

+// Object              : AT91SAM7X256 definitions

+// Generated           : AT91 SW Application Group  05/20/2005 (16:22:29)

+// 

+// CVS Reference       : /AT91SAM7X256.pl/1.11/Tue May 10 12:15:32 2005//

+// CVS Reference       : /SYS_SAM7X.pl/1.3/Tue Feb  1 17:01:43 2005//

+// CVS Reference       : /MC_SAM7X.pl/1.2/Fri May 20 14:13:04 2005//

+// CVS Reference       : /PMC_SAM7X.pl/1.4/Tue Feb  8 13:58:10 2005//

+// CVS Reference       : /RSTC_SAM7X.pl/1.1/Tue Feb  1 16:16:26 2005//

+// CVS Reference       : /UDP_SAM7X.pl/1.1/Tue May 10 11:35:35 2005//

+// CVS Reference       : /PWM_SAM7X.pl/1.1/Tue May 10 11:53:07 2005//

+// CVS Reference       : /AIC_6075B.pl/1.3/Fri May 20 14:01:30 2005//

+// CVS Reference       : /PIO_6057A.pl/1.2/Thu Feb  3 10:18:28 2005//

+// CVS Reference       : /RTTC_6081A.pl/1.2/Tue Nov  9 14:43:58 2004//

+// CVS Reference       : /PITC_6079A.pl/1.2/Tue Nov  9 14:43:56 2004//

+// CVS Reference       : /WDTC_6080A.pl/1.3/Tue Nov  9 14:44:00 2004//

+// CVS Reference       : /VREG_6085B.pl/1.1/Tue Feb  1 16:05:48 2005//

+// CVS Reference       : /PDC_6074C.pl/1.2/Thu Feb  3 08:48:54 2005//

+// CVS Reference       : /DBGU_6059D.pl/1.1/Mon Jan 31 13:15:32 2005//

+// CVS Reference       : /SPI_6088D.pl/1.3/Fri May 20 14:08:59 2005//

+// CVS Reference       : /US_6089C.pl/1.1/Mon Jul 12 18:23:26 2004//

+// CVS Reference       : /SSC_6078A.pl/1.1/Tue Jul 13 07:45:40 2004//

+// CVS Reference       : /TWI_6061A.pl/1.1/Tue Jul 13 07:38:06 2004//

+// CVS Reference       : /TC_6082A.pl/1.7/Fri Mar 11 12:52:17 2005//

+// CVS Reference       : /CAN_6019B.pl/1.1/Tue Mar  8 12:42:22 2005//

+// CVS Reference       : /EMACB_6119A.pl/1.5/Thu Feb  3 15:52:04 2005//

+// CVS Reference       : /ADC_6051C.pl/1.1/Fri Oct 17 09:12:38 2003//

+// CVS Reference       : /AES_6149A.pl/1.10/Mon Feb  7 09:44:25 2005//

+// CVS Reference       : /DES3_6150A.pl/1.1/Mon Jan 17 08:34:31 2005//

+//  ----------------------------------------------------------------------------

+

+#ifndef AT91SAM7X256_H

+#define AT91SAM7X256_H

+

+typedef volatile unsigned int AT91_REG;// Hardware register definition

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR System Peripherals

+// *****************************************************************************

+typedef struct _AT91S_SYS {

+	AT91_REG	 AIC_SMR[32]; 	// Source Mode Register

+	AT91_REG	 AIC_SVR[32]; 	// Source Vector Register

+	AT91_REG	 AIC_IVR; 	// IRQ Vector Register

+	AT91_REG	 AIC_FVR; 	// FIQ Vector Register

+	AT91_REG	 AIC_ISR; 	// Interrupt Status Register

+	AT91_REG	 AIC_IPR; 	// Interrupt Pending Register

+	AT91_REG	 AIC_IMR; 	// Interrupt Mask Register

+	AT91_REG	 AIC_CISR; 	// Core Interrupt Status Register

+	AT91_REG	 Reserved0[2]; 	// 

+	AT91_REG	 AIC_IECR; 	// Interrupt Enable Command Register

+	AT91_REG	 AIC_IDCR; 	// Interrupt Disable Command Register

+	AT91_REG	 AIC_ICCR; 	// Interrupt Clear Command Register

+	AT91_REG	 AIC_ISCR; 	// Interrupt Set Command Register

+	AT91_REG	 AIC_EOICR; 	// End of Interrupt Command Register

+	AT91_REG	 AIC_SPU; 	// Spurious Vector Register

+	AT91_REG	 AIC_DCR; 	// Debug Control Register (Protect)

+	AT91_REG	 Reserved1[1]; 	// 

+	AT91_REG	 AIC_FFER; 	// Fast Forcing Enable Register

+	AT91_REG	 AIC_FFDR; 	// Fast Forcing Disable Register

+	AT91_REG	 AIC_FFSR; 	// Fast Forcing Status Register

+	AT91_REG	 Reserved2[45]; 	// 

+	AT91_REG	 DBGU_CR; 	// Control Register

+	AT91_REG	 DBGU_MR; 	// Mode Register

+	AT91_REG	 DBGU_IER; 	// Interrupt Enable Register

+	AT91_REG	 DBGU_IDR; 	// Interrupt Disable Register

+	AT91_REG	 DBGU_IMR; 	// Interrupt Mask Register

+	AT91_REG	 DBGU_CSR; 	// Channel Status Register

+	AT91_REG	 DBGU_RHR; 	// Receiver Holding Register

+	AT91_REG	 DBGU_THR; 	// Transmitter Holding Register

+	AT91_REG	 DBGU_BRGR; 	// Baud Rate Generator Register

+	AT91_REG	 Reserved3[7]; 	// 

+	AT91_REG	 DBGU_CIDR; 	// Chip ID Register

+	AT91_REG	 DBGU_EXID; 	// Chip ID Extension Register

+	AT91_REG	 DBGU_FNTR; 	// Force NTRST Register

+	AT91_REG	 Reserved4[45]; 	// 

+	AT91_REG	 DBGU_RPR; 	// Receive Pointer Register

+	AT91_REG	 DBGU_RCR; 	// Receive Counter Register

+	AT91_REG	 DBGU_TPR; 	// Transmit Pointer Register

+	AT91_REG	 DBGU_TCR; 	// Transmit Counter Register

+	AT91_REG	 DBGU_RNPR; 	// Receive Next Pointer Register

+	AT91_REG	 DBGU_RNCR; 	// Receive Next Counter Register

+	AT91_REG	 DBGU_TNPR; 	// Transmit Next Pointer Register

+	AT91_REG	 DBGU_TNCR; 	// Transmit Next Counter Register

+	AT91_REG	 DBGU_PTCR; 	// PDC Transfer Control Register

+	AT91_REG	 DBGU_PTSR; 	// PDC Transfer Status Register

+	AT91_REG	 Reserved5[54]; 	// 

+	AT91_REG	 PIOA_PER; 	// PIO Enable Register

+	AT91_REG	 PIOA_PDR; 	// PIO Disable Register

+	AT91_REG	 PIOA_PSR; 	// PIO Status Register

+	AT91_REG	 Reserved6[1]; 	// 

+	AT91_REG	 PIOA_OER; 	// Output Enable Register

+	AT91_REG	 PIOA_ODR; 	// Output Disable Registerr

+	AT91_REG	 PIOA_OSR; 	// Output Status Register

+	AT91_REG	 Reserved7[1]; 	// 

+	AT91_REG	 PIOA_IFER; 	// Input Filter Enable Register

+	AT91_REG	 PIOA_IFDR; 	// Input Filter Disable Register

+	AT91_REG	 PIOA_IFSR; 	// Input Filter Status Register

+	AT91_REG	 Reserved8[1]; 	// 

+	AT91_REG	 PIOA_SODR; 	// Set Output Data Register

+	AT91_REG	 PIOA_CODR; 	// Clear Output Data Register

+	AT91_REG	 PIOA_ODSR; 	// Output Data Status Register

+	AT91_REG	 PIOA_PDSR; 	// Pin Data Status Register

+	AT91_REG	 PIOA_IER; 	// Interrupt Enable Register

+	AT91_REG	 PIOA_IDR; 	// Interrupt Disable Register

+	AT91_REG	 PIOA_IMR; 	// Interrupt Mask Register

+	AT91_REG	 PIOA_ISR; 	// Interrupt Status Register

+	AT91_REG	 PIOA_MDER; 	// Multi-driver Enable Register

+	AT91_REG	 PIOA_MDDR; 	// Multi-driver Disable Register

+	AT91_REG	 PIOA_MDSR; 	// Multi-driver Status Register

+	AT91_REG	 Reserved9[1]; 	// 

+	AT91_REG	 PIOA_PPUDR; 	// Pull-up Disable Register

+	AT91_REG	 PIOA_PPUER; 	// Pull-up Enable Register

+	AT91_REG	 PIOA_PPUSR; 	// Pull-up Status Register

+	AT91_REG	 Reserved10[1]; 	// 

+	AT91_REG	 PIOA_ASR; 	// Select A Register

+	AT91_REG	 PIOA_BSR; 	// Select B Register

+	AT91_REG	 PIOA_ABSR; 	// AB Select Status Register

+	AT91_REG	 Reserved11[9]; 	// 

+	AT91_REG	 PIOA_OWER; 	// Output Write Enable Register

+	AT91_REG	 PIOA_OWDR; 	// Output Write Disable Register

+	AT91_REG	 PIOA_OWSR; 	// Output Write Status Register

+	AT91_REG	 Reserved12[85]; 	// 

+	AT91_REG	 PIOB_PER; 	// PIO Enable Register

+	AT91_REG	 PIOB_PDR; 	// PIO Disable Register

+	AT91_REG	 PIOB_PSR; 	// PIO Status Register

+	AT91_REG	 Reserved13[1]; 	// 

+	AT91_REG	 PIOB_OER; 	// Output Enable Register

+	AT91_REG	 PIOB_ODR; 	// Output Disable Registerr

+	AT91_REG	 PIOB_OSR; 	// Output Status Register

+	AT91_REG	 Reserved14[1]; 	// 

+	AT91_REG	 PIOB_IFER; 	// Input Filter Enable Register

+	AT91_REG	 PIOB_IFDR; 	// Input Filter Disable Register

+	AT91_REG	 PIOB_IFSR; 	// Input Filter Status Register

+	AT91_REG	 Reserved15[1]; 	// 

+	AT91_REG	 PIOB_SODR; 	// Set Output Data Register

+	AT91_REG	 PIOB_CODR; 	// Clear Output Data Register

+	AT91_REG	 PIOB_ODSR; 	// Output Data Status Register

+	AT91_REG	 PIOB_PDSR; 	// Pin Data Status Register

+	AT91_REG	 PIOB_IER; 	// Interrupt Enable Register

+	AT91_REG	 PIOB_IDR; 	// Interrupt Disable Register

+	AT91_REG	 PIOB_IMR; 	// Interrupt Mask Register

+	AT91_REG	 PIOB_ISR; 	// Interrupt Status Register

+	AT91_REG	 PIOB_MDER; 	// Multi-driver Enable Register

+	AT91_REG	 PIOB_MDDR; 	// Multi-driver Disable Register

+	AT91_REG	 PIOB_MDSR; 	// Multi-driver Status Register

+	AT91_REG	 Reserved16[1]; 	// 

+	AT91_REG	 PIOB_PPUDR; 	// Pull-up Disable Register

+	AT91_REG	 PIOB_PPUER; 	// Pull-up Enable Register

+	AT91_REG	 PIOB_PPUSR; 	// Pull-up Status Register

+	AT91_REG	 Reserved17[1]; 	// 

+	AT91_REG	 PIOB_ASR; 	// Select A Register

+	AT91_REG	 PIOB_BSR; 	// Select B Register

+	AT91_REG	 PIOB_ABSR; 	// AB Select Status Register

+	AT91_REG	 Reserved18[9]; 	// 

+	AT91_REG	 PIOB_OWER; 	// Output Write Enable Register

+	AT91_REG	 PIOB_OWDR; 	// Output Write Disable Register

+	AT91_REG	 PIOB_OWSR; 	// Output Write Status Register

+	AT91_REG	 Reserved19[341]; 	// 

+	AT91_REG	 PMC_SCER; 	// System Clock Enable Register

+	AT91_REG	 PMC_SCDR; 	// System Clock Disable Register

+	AT91_REG	 PMC_SCSR; 	// System Clock Status Register

+	AT91_REG	 Reserved20[1]; 	// 

+	AT91_REG	 PMC_PCER; 	// Peripheral Clock Enable Register

+	AT91_REG	 PMC_PCDR; 	// Peripheral Clock Disable Register

+	AT91_REG	 PMC_PCSR; 	// Peripheral Clock Status Register

+	AT91_REG	 Reserved21[1]; 	// 

+	AT91_REG	 PMC_MOR; 	// Main Oscillator Register

+	AT91_REG	 PMC_MCFR; 	// Main Clock  Frequency Register

+	AT91_REG	 Reserved22[1]; 	// 

+	AT91_REG	 PMC_PLLR; 	// PLL Register

+	AT91_REG	 PMC_MCKR; 	// Master Clock Register

+	AT91_REG	 Reserved23[3]; 	// 

+	AT91_REG	 PMC_PCKR[4]; 	// Programmable Clock Register

+	AT91_REG	 Reserved24[4]; 	// 

+	AT91_REG	 PMC_IER; 	// Interrupt Enable Register

+	AT91_REG	 PMC_IDR; 	// Interrupt Disable Register

+	AT91_REG	 PMC_SR; 	// Status Register

+	AT91_REG	 PMC_IMR; 	// Interrupt Mask Register

+	AT91_REG	 Reserved25[36]; 	// 

+	AT91_REG	 RSTC_RCR; 	// Reset Control Register

+	AT91_REG	 RSTC_RSR; 	// Reset Status Register

+	AT91_REG	 RSTC_RMR; 	// Reset Mode Register

+	AT91_REG	 Reserved26[5]; 	// 

+	AT91_REG	 RTTC_RTMR; 	// Real-time Mode Register

+	AT91_REG	 RTTC_RTAR; 	// Real-time Alarm Register

+	AT91_REG	 RTTC_RTVR; 	// Real-time Value Register

+	AT91_REG	 RTTC_RTSR; 	// Real-time Status Register

+	AT91_REG	 PITC_PIMR; 	// Period Interval Mode Register

+	AT91_REG	 PITC_PISR; 	// Period Interval Status Register

+	AT91_REG	 PITC_PIVR; 	// Period Interval Value Register

+	AT91_REG	 PITC_PIIR; 	// Period Interval Image Register

+	AT91_REG	 WDTC_WDCR; 	// Watchdog Control Register

+	AT91_REG	 WDTC_WDMR; 	// Watchdog Mode Register

+	AT91_REG	 WDTC_WDSR; 	// Watchdog Status Register

+	AT91_REG	 Reserved27[5]; 	// 

+	AT91_REG	 VREG_MR; 	// Voltage Regulator Mode Register

+} AT91S_SYS, *AT91PS_SYS;

+

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR Advanced Interrupt Controller

+// *****************************************************************************

+typedef struct _AT91S_AIC {

+	AT91_REG	 AIC_SMR[32]; 	// Source Mode Register

+	AT91_REG	 AIC_SVR[32]; 	// Source Vector Register

+	AT91_REG	 AIC_IVR; 	// IRQ Vector Register

+	AT91_REG	 AIC_FVR; 	// FIQ Vector Register

+	AT91_REG	 AIC_ISR; 	// Interrupt Status Register

+	AT91_REG	 AIC_IPR; 	// Interrupt Pending Register

+	AT91_REG	 AIC_IMR; 	// Interrupt Mask Register

+	AT91_REG	 AIC_CISR; 	// Core Interrupt Status Register

+	AT91_REG	 Reserved0[2]; 	// 

+	AT91_REG	 AIC_IECR; 	// Interrupt Enable Command Register

+	AT91_REG	 AIC_IDCR; 	// Interrupt Disable Command Register

+	AT91_REG	 AIC_ICCR; 	// Interrupt Clear Command Register

+	AT91_REG	 AIC_ISCR; 	// Interrupt Set Command Register

+	AT91_REG	 AIC_EOICR; 	// End of Interrupt Command Register

+	AT91_REG	 AIC_SPU; 	// Spurious Vector Register

+	AT91_REG	 AIC_DCR; 	// Debug Control Register (Protect)

+	AT91_REG	 Reserved1[1]; 	// 

+	AT91_REG	 AIC_FFER; 	// Fast Forcing Enable Register

+	AT91_REG	 AIC_FFDR; 	// Fast Forcing Disable Register

+	AT91_REG	 AIC_FFSR; 	// Fast Forcing Status Register

+} AT91S_AIC, *AT91PS_AIC;

+

+// -------- AIC_SMR : (AIC Offset: 0x0) Control Register -------- 

+#define AT91C_AIC_PRIOR       ((unsigned int) 0x7 <<  0) // (AIC) Priority Level

+#define 	AT91C_AIC_PRIOR_LOWEST               ((unsigned int) 0x0) // (AIC) Lowest priority level

+#define 	AT91C_AIC_PRIOR_HIGHEST              ((unsigned int) 0x7) // (AIC) Highest priority level

+#define AT91C_AIC_SRCTYPE     ((unsigned int) 0x3 <<  5) // (AIC) Interrupt Source Type

+#define 	AT91C_AIC_SRCTYPE_INT_HIGH_LEVEL       ((unsigned int) 0x0 <<  5) // (AIC) Internal Sources Code Label High-level Sensitive

+#define 	AT91C_AIC_SRCTYPE_EXT_LOW_LEVEL        ((unsigned int) 0x0 <<  5) // (AIC) External Sources Code Label Low-level Sensitive

+#define 	AT91C_AIC_SRCTYPE_INT_POSITIVE_EDGE    ((unsigned int) 0x1 <<  5) // (AIC) Internal Sources Code Label Positive Edge triggered

+#define 	AT91C_AIC_SRCTYPE_EXT_NEGATIVE_EDGE    ((unsigned int) 0x1 <<  5) // (AIC) External Sources Code Label Negative Edge triggered

+#define 	AT91C_AIC_SRCTYPE_HIGH_LEVEL           ((unsigned int) 0x2 <<  5) // (AIC) Internal Or External Sources Code Label High-level Sensitive

+#define 	AT91C_AIC_SRCTYPE_POSITIVE_EDGE        ((unsigned int) 0x3 <<  5) // (AIC) Internal Or External Sources Code Label Positive Edge triggered

+// -------- AIC_CISR : (AIC Offset: 0x114) AIC Core Interrupt Status Register -------- 

+#define AT91C_AIC_NFIQ        ((unsigned int) 0x1 <<  0) // (AIC) NFIQ Status

+#define AT91C_AIC_NIRQ        ((unsigned int) 0x1 <<  1) // (AIC) NIRQ Status

+// -------- AIC_DCR : (AIC Offset: 0x138) AIC Debug Control Register (Protect) -------- 

+#define AT91C_AIC_DCR_PROT    ((unsigned int) 0x1 <<  0) // (AIC) Protection Mode

+#define AT91C_AIC_DCR_GMSK    ((unsigned int) 0x1 <<  1) // (AIC) General Mask

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR Peripheral DMA Controller

+// *****************************************************************************

+typedef struct _AT91S_PDC {

+	AT91_REG	 PDC_RPR; 	// Receive Pointer Register

+	AT91_REG	 PDC_RCR; 	// Receive Counter Register

+	AT91_REG	 PDC_TPR; 	// Transmit Pointer Register

+	AT91_REG	 PDC_TCR; 	// Transmit Counter Register

+	AT91_REG	 PDC_RNPR; 	// Receive Next Pointer Register

+	AT91_REG	 PDC_RNCR; 	// Receive Next Counter Register

+	AT91_REG	 PDC_TNPR; 	// Transmit Next Pointer Register

+	AT91_REG	 PDC_TNCR; 	// Transmit Next Counter Register

+	AT91_REG	 PDC_PTCR; 	// PDC Transfer Control Register

+	AT91_REG	 PDC_PTSR; 	// PDC Transfer Status Register

+} AT91S_PDC, *AT91PS_PDC;

+

+// -------- PDC_PTCR : (PDC Offset: 0x20) PDC Transfer Control Register -------- 

+#define AT91C_PDC_RXTEN       ((unsigned int) 0x1 <<  0) // (PDC) Receiver Transfer Enable

+#define AT91C_PDC_RXTDIS      ((unsigned int) 0x1 <<  1) // (PDC) Receiver Transfer Disable

+#define AT91C_PDC_TXTEN       ((unsigned int) 0x1 <<  8) // (PDC) Transmitter Transfer Enable

+#define AT91C_PDC_TXTDIS      ((unsigned int) 0x1 <<  9) // (PDC) Transmitter Transfer Disable

+// -------- PDC_PTSR : (PDC Offset: 0x24) PDC Transfer Status Register -------- 

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR Debug Unit

+// *****************************************************************************

+typedef struct _AT91S_DBGU {

+	AT91_REG	 DBGU_CR; 	// Control Register

+	AT91_REG	 DBGU_MR; 	// Mode Register

+	AT91_REG	 DBGU_IER; 	// Interrupt Enable Register

+	AT91_REG	 DBGU_IDR; 	// Interrupt Disable Register

+	AT91_REG	 DBGU_IMR; 	// Interrupt Mask Register

+	AT91_REG	 DBGU_CSR; 	// Channel Status Register

+	AT91_REG	 DBGU_RHR; 	// Receiver Holding Register

+	AT91_REG	 DBGU_THR; 	// Transmitter Holding Register

+	AT91_REG	 DBGU_BRGR; 	// Baud Rate Generator Register

+	AT91_REG	 Reserved0[7]; 	// 

+	AT91_REG	 DBGU_CIDR; 	// Chip ID Register

+	AT91_REG	 DBGU_EXID; 	// Chip ID Extension Register

+	AT91_REG	 DBGU_FNTR; 	// Force NTRST Register

+	AT91_REG	 Reserved1[45]; 	// 

+	AT91_REG	 DBGU_RPR; 	// Receive Pointer Register

+	AT91_REG	 DBGU_RCR; 	// Receive Counter Register

+	AT91_REG	 DBGU_TPR; 	// Transmit Pointer Register

+	AT91_REG	 DBGU_TCR; 	// Transmit Counter Register

+	AT91_REG	 DBGU_RNPR; 	// Receive Next Pointer Register

+	AT91_REG	 DBGU_RNCR; 	// Receive Next Counter Register

+	AT91_REG	 DBGU_TNPR; 	// Transmit Next Pointer Register

+	AT91_REG	 DBGU_TNCR; 	// Transmit Next Counter Register

+	AT91_REG	 DBGU_PTCR; 	// PDC Transfer Control Register

+	AT91_REG	 DBGU_PTSR; 	// PDC Transfer Status Register

+} AT91S_DBGU, *AT91PS_DBGU;

+

+// -------- DBGU_CR : (DBGU Offset: 0x0) Debug Unit Control Register -------- 

+#define AT91C_US_RSTRX        ((unsigned int) 0x1 <<  2) // (DBGU) Reset Receiver

+#define AT91C_US_RSTTX        ((unsigned int) 0x1 <<  3) // (DBGU) Reset Transmitter

+#define AT91C_US_RXEN         ((unsigned int) 0x1 <<  4) // (DBGU) Receiver Enable

+#define AT91C_US_RXDIS        ((unsigned int) 0x1 <<  5) // (DBGU) Receiver Disable

+#define AT91C_US_TXEN         ((unsigned int) 0x1 <<  6) // (DBGU) Transmitter Enable

+#define AT91C_US_TXDIS        ((unsigned int) 0x1 <<  7) // (DBGU) Transmitter Disable

+#define AT91C_US_RSTSTA       ((unsigned int) 0x1 <<  8) // (DBGU) Reset Status Bits

+// -------- DBGU_MR : (DBGU Offset: 0x4) Debug Unit Mode Register -------- 

+#define AT91C_US_PAR          ((unsigned int) 0x7 <<  9) // (DBGU) Parity type

+#define 	AT91C_US_PAR_EVEN                 ((unsigned int) 0x0 <<  9) // (DBGU) Even Parity

+#define 	AT91C_US_PAR_ODD                  ((unsigned int) 0x1 <<  9) // (DBGU) Odd Parity

+#define 	AT91C_US_PAR_SPACE                ((unsigned int) 0x2 <<  9) // (DBGU) Parity forced to 0 (Space)

+#define 	AT91C_US_PAR_MARK                 ((unsigned int) 0x3 <<  9) // (DBGU) Parity forced to 1 (Mark)

+#define 	AT91C_US_PAR_NONE                 ((unsigned int) 0x4 <<  9) // (DBGU) No Parity

+#define 	AT91C_US_PAR_MULTI_DROP           ((unsigned int) 0x6 <<  9) // (DBGU) Multi-drop mode

+#define AT91C_US_CHMODE       ((unsigned int) 0x3 << 14) // (DBGU) Channel Mode

+#define 	AT91C_US_CHMODE_NORMAL               ((unsigned int) 0x0 << 14) // (DBGU) Normal Mode: The USART channel operates as an RX/TX USART.

+#define 	AT91C_US_CHMODE_AUTO                 ((unsigned int) 0x1 << 14) // (DBGU) Automatic Echo: Receiver Data Input is connected to the TXD pin.

+#define 	AT91C_US_CHMODE_LOCAL                ((unsigned int) 0x2 << 14) // (DBGU) Local Loopback: Transmitter Output Signal is connected to Receiver Input Signal.

+#define 	AT91C_US_CHMODE_REMOTE               ((unsigned int) 0x3 << 14) // (DBGU) Remote Loopback: RXD pin is internally connected to TXD pin.

+// -------- DBGU_IER : (DBGU Offset: 0x8) Debug Unit Interrupt Enable Register -------- 

+#define AT91C_US_RXRDY        ((unsigned int) 0x1 <<  0) // (DBGU) RXRDY Interrupt

+#define AT91C_US_TXRDY        ((unsigned int) 0x1 <<  1) // (DBGU) TXRDY Interrupt

+#define AT91C_US_ENDRX        ((unsigned int) 0x1 <<  3) // (DBGU) End of Receive Transfer Interrupt

+#define AT91C_US_ENDTX        ((unsigned int) 0x1 <<  4) // (DBGU) End of Transmit Interrupt

+#define AT91C_US_OVRE         ((unsigned int) 0x1 <<  5) // (DBGU) Overrun Interrupt

+#define AT91C_US_FRAME        ((unsigned int) 0x1 <<  6) // (DBGU) Framing Error Interrupt

+#define AT91C_US_PARE         ((unsigned int) 0x1 <<  7) // (DBGU) Parity Error Interrupt

+#define AT91C_US_TXEMPTY      ((unsigned int) 0x1 <<  9) // (DBGU) TXEMPTY Interrupt

+#define AT91C_US_TXBUFE       ((unsigned int) 0x1 << 11) // (DBGU) TXBUFE Interrupt

+#define AT91C_US_RXBUFF       ((unsigned int) 0x1 << 12) // (DBGU) RXBUFF Interrupt

+#define AT91C_US_COMM_TX      ((unsigned int) 0x1 << 30) // (DBGU) COMM_TX Interrupt

+#define AT91C_US_COMM_RX      ((unsigned int) 0x1 << 31) // (DBGU) COMM_RX Interrupt

+// -------- DBGU_IDR : (DBGU Offset: 0xc) Debug Unit Interrupt Disable Register -------- 

+// -------- DBGU_IMR : (DBGU Offset: 0x10) Debug Unit Interrupt Mask Register -------- 

+// -------- DBGU_CSR : (DBGU Offset: 0x14) Debug Unit Channel Status Register -------- 

+// -------- DBGU_FNTR : (DBGU Offset: 0x48) Debug Unit FORCE_NTRST Register -------- 

+#define AT91C_US_FORCE_NTRST  ((unsigned int) 0x1 <<  0) // (DBGU) Force NTRST in JTAG

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR Parallel Input Output Controler

+// *****************************************************************************

+typedef struct _AT91S_PIO {

+	AT91_REG	 PIO_PER; 	// PIO Enable Register

+	AT91_REG	 PIO_PDR; 	// PIO Disable Register

+	AT91_REG	 PIO_PSR; 	// PIO Status Register

+	AT91_REG	 Reserved0[1]; 	// 

+	AT91_REG	 PIO_OER; 	// Output Enable Register

+	AT91_REG	 PIO_ODR; 	// Output Disable Registerr

+	AT91_REG	 PIO_OSR; 	// Output Status Register

+	AT91_REG	 Reserved1[1]; 	// 

+	AT91_REG	 PIO_IFER; 	// Input Filter Enable Register

+	AT91_REG	 PIO_IFDR; 	// Input Filter Disable Register

+	AT91_REG	 PIO_IFSR; 	// Input Filter Status Register

+	AT91_REG	 Reserved2[1]; 	// 

+	AT91_REG	 PIO_SODR; 	// Set Output Data Register

+	AT91_REG	 PIO_CODR; 	// Clear Output Data Register

+	AT91_REG	 PIO_ODSR; 	// Output Data Status Register

+	AT91_REG	 PIO_PDSR; 	// Pin Data Status Register

+	AT91_REG	 PIO_IER; 	// Interrupt Enable Register

+	AT91_REG	 PIO_IDR; 	// Interrupt Disable Register

+	AT91_REG	 PIO_IMR; 	// Interrupt Mask Register

+	AT91_REG	 PIO_ISR; 	// Interrupt Status Register

+	AT91_REG	 PIO_MDER; 	// Multi-driver Enable Register

+	AT91_REG	 PIO_MDDR; 	// Multi-driver Disable Register

+	AT91_REG	 PIO_MDSR; 	// Multi-driver Status Register

+	AT91_REG	 Reserved3[1]; 	// 

+	AT91_REG	 PIO_PPUDR; 	// Pull-up Disable Register

+	AT91_REG	 PIO_PPUER; 	// Pull-up Enable Register

+	AT91_REG	 PIO_PPUSR; 	// Pull-up Status Register

+	AT91_REG	 Reserved4[1]; 	// 

+	AT91_REG	 PIO_ASR; 	// Select A Register

+	AT91_REG	 PIO_BSR; 	// Select B Register

+	AT91_REG	 PIO_ABSR; 	// AB Select Status Register

+	AT91_REG	 Reserved5[9]; 	// 

+	AT91_REG	 PIO_OWER; 	// Output Write Enable Register

+	AT91_REG	 PIO_OWDR; 	// Output Write Disable Register

+	AT91_REG	 PIO_OWSR; 	// Output Write Status Register

+} AT91S_PIO, *AT91PS_PIO;

+

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR Clock Generator Controler

+// *****************************************************************************

+typedef struct _AT91S_CKGR {

+	AT91_REG	 CKGR_MOR; 	// Main Oscillator Register

+	AT91_REG	 CKGR_MCFR; 	// Main Clock  Frequency Register

+	AT91_REG	 Reserved0[1]; 	// 

+	AT91_REG	 CKGR_PLLR; 	// PLL Register

+} AT91S_CKGR, *AT91PS_CKGR;

+

+// -------- CKGR_MOR : (CKGR Offset: 0x0) Main Oscillator Register -------- 

+#define AT91C_CKGR_MOSCEN     ((unsigned int) 0x1 <<  0) // (CKGR) Main Oscillator Enable

+#define AT91C_CKGR_OSCBYPASS  ((unsigned int) 0x1 <<  1) // (CKGR) Main Oscillator Bypass

+#define AT91C_CKGR_OSCOUNT    ((unsigned int) 0xFF <<  8) // (CKGR) Main Oscillator Start-up Time

+// -------- CKGR_MCFR : (CKGR Offset: 0x4) Main Clock Frequency Register -------- 

+#define AT91C_CKGR_MAINF      ((unsigned int) 0xFFFF <<  0) // (CKGR) Main Clock Frequency

+#define AT91C_CKGR_MAINRDY    ((unsigned int) 0x1 << 16) // (CKGR) Main Clock Ready

+// -------- CKGR_PLLR : (CKGR Offset: 0xc) PLL B Register -------- 

+#define AT91C_CKGR_DIV        ((unsigned int) 0xFF <<  0) // (CKGR) Divider Selected

+#define 	AT91C_CKGR_DIV_0                    ((unsigned int) 0x0) // (CKGR) Divider output is 0

+#define 	AT91C_CKGR_DIV_BYPASS               ((unsigned int) 0x1) // (CKGR) Divider is bypassed

+#define AT91C_CKGR_PLLCOUNT   ((unsigned int) 0x3F <<  8) // (CKGR) PLL Counter

+#define AT91C_CKGR_OUT        ((unsigned int) 0x3 << 14) // (CKGR) PLL Output Frequency Range

+#define 	AT91C_CKGR_OUT_0                    ((unsigned int) 0x0 << 14) // (CKGR) Please refer to the PLL datasheet

+#define 	AT91C_CKGR_OUT_1                    ((unsigned int) 0x1 << 14) // (CKGR) Please refer to the PLL datasheet

+#define 	AT91C_CKGR_OUT_2                    ((unsigned int) 0x2 << 14) // (CKGR) Please refer to the PLL datasheet

+#define 	AT91C_CKGR_OUT_3                    ((unsigned int) 0x3 << 14) // (CKGR) Please refer to the PLL datasheet

+#define AT91C_CKGR_MUL        ((unsigned int) 0x7FF << 16) // (CKGR) PLL Multiplier

+#define AT91C_CKGR_USBDIV     ((unsigned int) 0x3 << 28) // (CKGR) Divider for USB Clocks

+#define 	AT91C_CKGR_USBDIV_0                    ((unsigned int) 0x0 << 28) // (CKGR) Divider output is PLL clock output

+#define 	AT91C_CKGR_USBDIV_1                    ((unsigned int) 0x1 << 28) // (CKGR) Divider output is PLL clock output divided by 2

+#define 	AT91C_CKGR_USBDIV_2                    ((unsigned int) 0x2 << 28) // (CKGR) Divider output is PLL clock output divided by 4

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR Power Management Controler

+// *****************************************************************************

+typedef struct _AT91S_PMC {

+	AT91_REG	 PMC_SCER; 	// System Clock Enable Register

+	AT91_REG	 PMC_SCDR; 	// System Clock Disable Register

+	AT91_REG	 PMC_SCSR; 	// System Clock Status Register

+	AT91_REG	 Reserved0[1]; 	// 

+	AT91_REG	 PMC_PCER; 	// Peripheral Clock Enable Register

+	AT91_REG	 PMC_PCDR; 	// Peripheral Clock Disable Register

+	AT91_REG	 PMC_PCSR; 	// Peripheral Clock Status Register

+	AT91_REG	 Reserved1[1]; 	// 

+	AT91_REG	 PMC_MOR; 	// Main Oscillator Register

+	AT91_REG	 PMC_MCFR; 	// Main Clock  Frequency Register

+	AT91_REG	 Reserved2[1]; 	// 

+	AT91_REG	 PMC_PLLR; 	// PLL Register

+	AT91_REG	 PMC_MCKR; 	// Master Clock Register

+	AT91_REG	 Reserved3[3]; 	// 

+	AT91_REG	 PMC_PCKR[4]; 	// Programmable Clock Register

+	AT91_REG	 Reserved4[4]; 	// 

+	AT91_REG	 PMC_IER; 	// Interrupt Enable Register

+	AT91_REG	 PMC_IDR; 	// Interrupt Disable Register

+	AT91_REG	 PMC_SR; 	// Status Register

+	AT91_REG	 PMC_IMR; 	// Interrupt Mask Register

+} AT91S_PMC, *AT91PS_PMC;

+

+// -------- PMC_SCER : (PMC Offset: 0x0) System Clock Enable Register -------- 

+#define AT91C_PMC_PCK         ((unsigned int) 0x1 <<  0) // (PMC) Processor Clock

+#define AT91C_PMC_UDP         ((unsigned int) 0x1 <<  7) // (PMC) USB Device Port Clock

+#define AT91C_PMC_PCK0        ((unsigned int) 0x1 <<  8) // (PMC) Programmable Clock Output

+#define AT91C_PMC_PCK1        ((unsigned int) 0x1 <<  9) // (PMC) Programmable Clock Output

+#define AT91C_PMC_PCK2        ((unsigned int) 0x1 << 10) // (PMC) Programmable Clock Output

+#define AT91C_PMC_PCK3        ((unsigned int) 0x1 << 11) // (PMC) Programmable Clock Output

+// -------- PMC_SCDR : (PMC Offset: 0x4) System Clock Disable Register -------- 

+// -------- PMC_SCSR : (PMC Offset: 0x8) System Clock Status Register -------- 

+// -------- CKGR_MOR : (PMC Offset: 0x20) Main Oscillator Register -------- 

+// -------- CKGR_MCFR : (PMC Offset: 0x24) Main Clock Frequency Register -------- 

+// -------- CKGR_PLLR : (PMC Offset: 0x2c) PLL B Register -------- 

+// -------- PMC_MCKR : (PMC Offset: 0x30) Master Clock Register -------- 

+#define AT91C_PMC_CSS         ((unsigned int) 0x3 <<  0) // (PMC) Programmable Clock Selection

+#define 	AT91C_PMC_CSS_SLOW_CLK             ((unsigned int) 0x0) // (PMC) Slow Clock is selected

+#define 	AT91C_PMC_CSS_MAIN_CLK             ((unsigned int) 0x1) // (PMC) Main Clock is selected

+#define 	AT91C_PMC_CSS_PLL_CLK              ((unsigned int) 0x3) // (PMC) Clock from PLL is selected

+#define AT91C_PMC_PRES        ((unsigned int) 0x7 <<  2) // (PMC) Programmable Clock Prescaler

+#define 	AT91C_PMC_PRES_CLK                  ((unsigned int) 0x0 <<  2) // (PMC) Selected clock

+#define 	AT91C_PMC_PRES_CLK_2                ((unsigned int) 0x1 <<  2) // (PMC) Selected clock divided by 2

+#define 	AT91C_PMC_PRES_CLK_4                ((unsigned int) 0x2 <<  2) // (PMC) Selected clock divided by 4

+#define 	AT91C_PMC_PRES_CLK_8                ((unsigned int) 0x3 <<  2) // (PMC) Selected clock divided by 8

+#define 	AT91C_PMC_PRES_CLK_16               ((unsigned int) 0x4 <<  2) // (PMC) Selected clock divided by 16

+#define 	AT91C_PMC_PRES_CLK_32               ((unsigned int) 0x5 <<  2) // (PMC) Selected clock divided by 32

+#define 	AT91C_PMC_PRES_CLK_64               ((unsigned int) 0x6 <<  2) // (PMC) Selected clock divided by 64

+// -------- PMC_PCKR : (PMC Offset: 0x40) Programmable Clock Register -------- 

+// -------- PMC_IER : (PMC Offset: 0x60) PMC Interrupt Enable Register -------- 

+#define AT91C_PMC_MOSCS       ((unsigned int) 0x1 <<  0) // (PMC) MOSC Status/Enable/Disable/Mask

+#define AT91C_PMC_LOCK        ((unsigned int) 0x1 <<  2) // (PMC) PLL Status/Enable/Disable/Mask

+#define AT91C_PMC_MCKRDY      ((unsigned int) 0x1 <<  3) // (PMC) MCK_RDY Status/Enable/Disable/Mask

+#define AT91C_PMC_PCK0RDY     ((unsigned int) 0x1 <<  8) // (PMC) PCK0_RDY Status/Enable/Disable/Mask

+#define AT91C_PMC_PCK1RDY     ((unsigned int) 0x1 <<  9) // (PMC) PCK1_RDY Status/Enable/Disable/Mask

+#define AT91C_PMC_PCK2RDY     ((unsigned int) 0x1 << 10) // (PMC) PCK2_RDY Status/Enable/Disable/Mask

+#define AT91C_PMC_PCK3RDY     ((unsigned int) 0x1 << 11) // (PMC) PCK3_RDY Status/Enable/Disable/Mask

+// -------- PMC_IDR : (PMC Offset: 0x64) PMC Interrupt Disable Register -------- 

+// -------- PMC_SR : (PMC Offset: 0x68) PMC Status Register -------- 

+// -------- PMC_IMR : (PMC Offset: 0x6c) PMC Interrupt Mask Register -------- 

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR Reset Controller Interface

+// *****************************************************************************

+typedef struct _AT91S_RSTC {

+	AT91_REG	 RSTC_RCR; 	// Reset Control Register

+	AT91_REG	 RSTC_RSR; 	// Reset Status Register

+	AT91_REG	 RSTC_RMR; 	// Reset Mode Register

+} AT91S_RSTC, *AT91PS_RSTC;

+

+// -------- RSTC_RCR : (RSTC Offset: 0x0) Reset Control Register -------- 

+#define AT91C_RSTC_PROCRST    ((unsigned int) 0x1 <<  0) // (RSTC) Processor Reset

+#define AT91C_RSTC_PERRST     ((unsigned int) 0x1 <<  2) // (RSTC) Peripheral Reset

+#define AT91C_RSTC_EXTRST     ((unsigned int) 0x1 <<  3) // (RSTC) External Reset

+#define AT91C_RSTC_KEY        ((unsigned int) 0xFF << 24) // (RSTC) Password

+// -------- RSTC_RSR : (RSTC Offset: 0x4) Reset Status Register -------- 

+#define AT91C_RSTC_URSTS      ((unsigned int) 0x1 <<  0) // (RSTC) User Reset Status

+#define AT91C_RSTC_BODSTS     ((unsigned int) 0x1 <<  1) // (RSTC) Brownout Detection Status

+#define AT91C_RSTC_RSTTYP     ((unsigned int) 0x7 <<  8) // (RSTC) Reset Type

+#define 	AT91C_RSTC_RSTTYP_POWERUP              ((unsigned int) 0x0 <<  8) // (RSTC) Power-up Reset. VDDCORE rising.

+#define 	AT91C_RSTC_RSTTYP_WAKEUP               ((unsigned int) 0x1 <<  8) // (RSTC) WakeUp Reset. VDDCORE rising.

+#define 	AT91C_RSTC_RSTTYP_WATCHDOG             ((unsigned int) 0x2 <<  8) // (RSTC) Watchdog Reset. Watchdog overflow occured.

+#define 	AT91C_RSTC_RSTTYP_SOFTWARE             ((unsigned int) 0x3 <<  8) // (RSTC) Software Reset. Processor reset required by the software.

+#define 	AT91C_RSTC_RSTTYP_USER                 ((unsigned int) 0x4 <<  8) // (RSTC) User Reset. NRST pin detected low.

+#define 	AT91C_RSTC_RSTTYP_BROWNOUT             ((unsigned int) 0x5 <<  8) // (RSTC) Brownout Reset occured.

+#define AT91C_RSTC_NRSTL      ((unsigned int) 0x1 << 16) // (RSTC) NRST pin level

+#define AT91C_RSTC_SRCMP      ((unsigned int) 0x1 << 17) // (RSTC) Software Reset Command in Progress.

+// -------- RSTC_RMR : (RSTC Offset: 0x8) Reset Mode Register -------- 

+#define AT91C_RSTC_URSTEN     ((unsigned int) 0x1 <<  0) // (RSTC) User Reset Enable

+#define AT91C_RSTC_URSTIEN    ((unsigned int) 0x1 <<  4) // (RSTC) User Reset Interrupt Enable

+#define AT91C_RSTC_ERSTL      ((unsigned int) 0xF <<  8) // (RSTC) User Reset Enable

+#define AT91C_RSTC_BODIEN     ((unsigned int) 0x1 << 16) // (RSTC) Brownout Detection Interrupt Enable

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR Real Time Timer Controller Interface

+// *****************************************************************************

+typedef struct _AT91S_RTTC {

+	AT91_REG	 RTTC_RTMR; 	// Real-time Mode Register

+	AT91_REG	 RTTC_RTAR; 	// Real-time Alarm Register

+	AT91_REG	 RTTC_RTVR; 	// Real-time Value Register

+	AT91_REG	 RTTC_RTSR; 	// Real-time Status Register

+} AT91S_RTTC, *AT91PS_RTTC;

+

+// -------- RTTC_RTMR : (RTTC Offset: 0x0) Real-time Mode Register -------- 

+#define AT91C_RTTC_RTPRES     ((unsigned int) 0xFFFF <<  0) // (RTTC) Real-time Timer Prescaler Value

+#define AT91C_RTTC_ALMIEN     ((unsigned int) 0x1 << 16) // (RTTC) Alarm Interrupt Enable

+#define AT91C_RTTC_RTTINCIEN  ((unsigned int) 0x1 << 17) // (RTTC) Real Time Timer Increment Interrupt Enable

+#define AT91C_RTTC_RTTRST     ((unsigned int) 0x1 << 18) // (RTTC) Real Time Timer Restart

+// -------- RTTC_RTAR : (RTTC Offset: 0x4) Real-time Alarm Register -------- 

+#define AT91C_RTTC_ALMV       ((unsigned int) 0x0 <<  0) // (RTTC) Alarm Value

+// -------- RTTC_RTVR : (RTTC Offset: 0x8) Current Real-time Value Register -------- 

+#define AT91C_RTTC_CRTV       ((unsigned int) 0x0 <<  0) // (RTTC) Current Real-time Value

+// -------- RTTC_RTSR : (RTTC Offset: 0xc) Real-time Status Register -------- 

+#define AT91C_RTTC_ALMS       ((unsigned int) 0x1 <<  0) // (RTTC) Real-time Alarm Status

+#define AT91C_RTTC_RTTINC     ((unsigned int) 0x1 <<  1) // (RTTC) Real-time Timer Increment

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR Periodic Interval Timer Controller Interface

+// *****************************************************************************

+typedef struct _AT91S_PITC {

+	AT91_REG	 PITC_PIMR; 	// Period Interval Mode Register

+	AT91_REG	 PITC_PISR; 	// Period Interval Status Register

+	AT91_REG	 PITC_PIVR; 	// Period Interval Value Register

+	AT91_REG	 PITC_PIIR; 	// Period Interval Image Register

+} AT91S_PITC, *AT91PS_PITC;

+

+// -------- PITC_PIMR : (PITC Offset: 0x0) Periodic Interval Mode Register -------- 

+#define AT91C_PITC_PIV        ((unsigned int) 0xFFFFF <<  0) // (PITC) Periodic Interval Value

+#define AT91C_PITC_PITEN      ((unsigned int) 0x1 << 24) // (PITC) Periodic Interval Timer Enabled

+#define AT91C_PITC_PITIEN     ((unsigned int) 0x1 << 25) // (PITC) Periodic Interval Timer Interrupt Enable

+// -------- PITC_PISR : (PITC Offset: 0x4) Periodic Interval Status Register -------- 

+#define AT91C_PITC_PITS       ((unsigned int) 0x1 <<  0) // (PITC) Periodic Interval Timer Status

+// -------- PITC_PIVR : (PITC Offset: 0x8) Periodic Interval Value Register -------- 

+#define AT91C_PITC_CPIV       ((unsigned int) 0xFFFFF <<  0) // (PITC) Current Periodic Interval Value

+#define AT91C_PITC_PICNT      ((unsigned int) 0xFFF << 20) // (PITC) Periodic Interval Counter

+// -------- PITC_PIIR : (PITC Offset: 0xc) Periodic Interval Image Register -------- 

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR Watchdog Timer Controller Interface

+// *****************************************************************************

+typedef struct _AT91S_WDTC {

+	AT91_REG	 WDTC_WDCR; 	// Watchdog Control Register

+	AT91_REG	 WDTC_WDMR; 	// Watchdog Mode Register

+	AT91_REG	 WDTC_WDSR; 	// Watchdog Status Register

+} AT91S_WDTC, *AT91PS_WDTC;

+

+// -------- WDTC_WDCR : (WDTC Offset: 0x0) Periodic Interval Image Register -------- 

+#define AT91C_WDTC_WDRSTT     ((unsigned int) 0x1 <<  0) // (WDTC) Watchdog Restart

+#define AT91C_WDTC_KEY        ((unsigned int) 0xFF << 24) // (WDTC) Watchdog KEY Password

+// -------- WDTC_WDMR : (WDTC Offset: 0x4) Watchdog Mode Register -------- 

+#define AT91C_WDTC_WDV        ((unsigned int) 0xFFF <<  0) // (WDTC) Watchdog Timer Restart

+#define AT91C_WDTC_WDFIEN     ((unsigned int) 0x1 << 12) // (WDTC) Watchdog Fault Interrupt Enable

+#define AT91C_WDTC_WDRSTEN    ((unsigned int) 0x1 << 13) // (WDTC) Watchdog Reset Enable

+#define AT91C_WDTC_WDRPROC    ((unsigned int) 0x1 << 14) // (WDTC) Watchdog Timer Restart

+#define AT91C_WDTC_WDDIS      ((unsigned int) 0x1 << 15) // (WDTC) Watchdog Disable

+#define AT91C_WDTC_WDD        ((unsigned int) 0xFFF << 16) // (WDTC) Watchdog Delta Value

+#define AT91C_WDTC_WDDBGHLT   ((unsigned int) 0x1 << 28) // (WDTC) Watchdog Debug Halt

+#define AT91C_WDTC_WDIDLEHLT  ((unsigned int) 0x1 << 29) // (WDTC) Watchdog Idle Halt

+// -------- WDTC_WDSR : (WDTC Offset: 0x8) Watchdog Status Register -------- 

+#define AT91C_WDTC_WDUNF      ((unsigned int) 0x1 <<  0) // (WDTC) Watchdog Underflow

+#define AT91C_WDTC_WDERR      ((unsigned int) 0x1 <<  1) // (WDTC) Watchdog Error

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR Voltage Regulator Mode Controller Interface

+// *****************************************************************************

+typedef struct _AT91S_VREG {

+	AT91_REG	 VREG_MR; 	// Voltage Regulator Mode Register

+} AT91S_VREG, *AT91PS_VREG;

+

+// -------- VREG_MR : (VREG Offset: 0x0) Voltage Regulator Mode Register -------- 

+#define AT91C_VREG_PSTDBY     ((unsigned int) 0x1 <<  0) // (VREG) Voltage Regulator Power Standby Mode

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR Memory Controller Interface

+// *****************************************************************************

+typedef struct _AT91S_MC {

+	AT91_REG	 MC_RCR; 	// MC Remap Control Register

+	AT91_REG	 MC_ASR; 	// MC Abort Status Register

+	AT91_REG	 MC_AASR; 	// MC Abort Address Status Register

+	AT91_REG	 Reserved0[21]; 	// 

+	AT91_REG	 MC_FMR; 	// MC Flash Mode Register

+	AT91_REG	 MC_FCR; 	// MC Flash Command Register

+	AT91_REG	 MC_FSR; 	// MC Flash Status Register

+} AT91S_MC, *AT91PS_MC;

+

+// -------- MC_RCR : (MC Offset: 0x0) MC Remap Control Register -------- 

+#define AT91C_MC_RCB          ((unsigned int) 0x1 <<  0) // (MC) Remap Command Bit

+// -------- MC_ASR : (MC Offset: 0x4) MC Abort Status Register -------- 

+#define AT91C_MC_UNDADD       ((unsigned int) 0x1 <<  0) // (MC) Undefined Addess Abort Status

+#define AT91C_MC_MISADD       ((unsigned int) 0x1 <<  1) // (MC) Misaligned Addess Abort Status

+#define AT91C_MC_ABTSZ        ((unsigned int) 0x3 <<  8) // (MC) Abort Size Status

+#define 	AT91C_MC_ABTSZ_BYTE                 ((unsigned int) 0x0 <<  8) // (MC) Byte

+#define 	AT91C_MC_ABTSZ_HWORD                ((unsigned int) 0x1 <<  8) // (MC) Half-word

+#define 	AT91C_MC_ABTSZ_WORD                 ((unsigned int) 0x2 <<  8) // (MC) Word

+#define AT91C_MC_ABTTYP       ((unsigned int) 0x3 << 10) // (MC) Abort Type Status

+#define 	AT91C_MC_ABTTYP_DATAR                ((unsigned int) 0x0 << 10) // (MC) Data Read

+#define 	AT91C_MC_ABTTYP_DATAW                ((unsigned int) 0x1 << 10) // (MC) Data Write

+#define 	AT91C_MC_ABTTYP_FETCH                ((unsigned int) 0x2 << 10) // (MC) Code Fetch

+#define AT91C_MC_MST0         ((unsigned int) 0x1 << 16) // (MC) Master 0 Abort Source

+#define AT91C_MC_MST1         ((unsigned int) 0x1 << 17) // (MC) Master 1 Abort Source

+#define AT91C_MC_SVMST0       ((unsigned int) 0x1 << 24) // (MC) Saved Master 0 Abort Source

+#define AT91C_MC_SVMST1       ((unsigned int) 0x1 << 25) // (MC) Saved Master 1 Abort Source

+// -------- MC_FMR : (MC Offset: 0x60) MC Flash Mode Register -------- 

+#define AT91C_MC_FRDY         ((unsigned int) 0x1 <<  0) // (MC) Flash Ready

+#define AT91C_MC_LOCKE        ((unsigned int) 0x1 <<  2) // (MC) Lock Error

+#define AT91C_MC_PROGE        ((unsigned int) 0x1 <<  3) // (MC) Programming Error

+#define AT91C_MC_NEBP         ((unsigned int) 0x1 <<  7) // (MC) No Erase Before Programming

+#define AT91C_MC_FWS          ((unsigned int) 0x3 <<  8) // (MC) Flash Wait State

+#define 	AT91C_MC_FWS_0FWS                 ((unsigned int) 0x0 <<  8) // (MC) 1 cycle for Read, 2 for Write operations

+#define 	AT91C_MC_FWS_1FWS                 ((unsigned int) 0x1 <<  8) // (MC) 2 cycles for Read, 3 for Write operations

+#define 	AT91C_MC_FWS_2FWS                 ((unsigned int) 0x2 <<  8) // (MC) 3 cycles for Read, 4 for Write operations

+#define 	AT91C_MC_FWS_3FWS                 ((unsigned int) 0x3 <<  8) // (MC) 4 cycles for Read, 4 for Write operations

+#define AT91C_MC_FMCN         ((unsigned int) 0xFF << 16) // (MC) Flash Microsecond Cycle Number

+// -------- MC_FCR : (MC Offset: 0x64) MC Flash Command Register -------- 

+#define AT91C_MC_FCMD         ((unsigned int) 0xF <<  0) // (MC) Flash Command

+#define 	AT91C_MC_FCMD_START_PROG           ((unsigned int) 0x1) // (MC) Starts the programming of th epage specified by PAGEN.

+#define 	AT91C_MC_FCMD_LOCK                 ((unsigned int) 0x2) // (MC) Starts a lock sequence of the sector defined by the bits 4 to 7 of the field PAGEN.

+#define 	AT91C_MC_FCMD_PROG_AND_LOCK        ((unsigned int) 0x3) // (MC) The lock sequence automatically happens after the programming sequence is completed.

+#define 	AT91C_MC_FCMD_UNLOCK               ((unsigned int) 0x4) // (MC) Starts an unlock sequence of the sector defined by the bits 4 to 7 of the field PAGEN.

+#define 	AT91C_MC_FCMD_ERASE_ALL            ((unsigned int) 0x8) // (MC) Starts the erase of the entire flash.If at least a page is locked, the command is cancelled.

+#define 	AT91C_MC_FCMD_SET_GP_NVM           ((unsigned int) 0xB) // (MC) Set General Purpose NVM bits.

+#define 	AT91C_MC_FCMD_CLR_GP_NVM           ((unsigned int) 0xD) // (MC) Clear General Purpose NVM bits.

+#define 	AT91C_MC_FCMD_SET_SECURITY         ((unsigned int) 0xF) // (MC) Set Security Bit.

+#define AT91C_MC_PAGEN        ((unsigned int) 0x3FF <<  8) // (MC) Page Number

+#define AT91C_MC_KEY          ((unsigned int) 0xFF << 24) // (MC) Writing Protect Key

+// -------- MC_FSR : (MC Offset: 0x68) MC Flash Command Register -------- 

+#define AT91C_MC_SECURITY     ((unsigned int) 0x1 <<  4) // (MC) Security Bit Status

+#define AT91C_MC_GPNVM0       ((unsigned int) 0x1 <<  8) // (MC) Sector 0 Lock Status

+#define AT91C_MC_GPNVM1       ((unsigned int) 0x1 <<  9) // (MC) Sector 1 Lock Status

+#define AT91C_MC_GPNVM2       ((unsigned int) 0x1 << 10) // (MC) Sector 2 Lock Status

+#define AT91C_MC_GPNVM3       ((unsigned int) 0x1 << 11) // (MC) Sector 3 Lock Status

+#define AT91C_MC_GPNVM4       ((unsigned int) 0x1 << 12) // (MC) Sector 4 Lock Status

+#define AT91C_MC_GPNVM5       ((unsigned int) 0x1 << 13) // (MC) Sector 5 Lock Status

+#define AT91C_MC_GPNVM6       ((unsigned int) 0x1 << 14) // (MC) Sector 6 Lock Status

+#define AT91C_MC_GPNVM7       ((unsigned int) 0x1 << 15) // (MC) Sector 7 Lock Status

+#define AT91C_MC_LOCKS0       ((unsigned int) 0x1 << 16) // (MC) Sector 0 Lock Status

+#define AT91C_MC_LOCKS1       ((unsigned int) 0x1 << 17) // (MC) Sector 1 Lock Status

+#define AT91C_MC_LOCKS2       ((unsigned int) 0x1 << 18) // (MC) Sector 2 Lock Status

+#define AT91C_MC_LOCKS3       ((unsigned int) 0x1 << 19) // (MC) Sector 3 Lock Status

+#define AT91C_MC_LOCKS4       ((unsigned int) 0x1 << 20) // (MC) Sector 4 Lock Status

+#define AT91C_MC_LOCKS5       ((unsigned int) 0x1 << 21) // (MC) Sector 5 Lock Status

+#define AT91C_MC_LOCKS6       ((unsigned int) 0x1 << 22) // (MC) Sector 6 Lock Status

+#define AT91C_MC_LOCKS7       ((unsigned int) 0x1 << 23) // (MC) Sector 7 Lock Status

+#define AT91C_MC_LOCKS8       ((unsigned int) 0x1 << 24) // (MC) Sector 8 Lock Status

+#define AT91C_MC_LOCKS9       ((unsigned int) 0x1 << 25) // (MC) Sector 9 Lock Status

+#define AT91C_MC_LOCKS10      ((unsigned int) 0x1 << 26) // (MC) Sector 10 Lock Status

+#define AT91C_MC_LOCKS11      ((unsigned int) 0x1 << 27) // (MC) Sector 11 Lock Status

+#define AT91C_MC_LOCKS12      ((unsigned int) 0x1 << 28) // (MC) Sector 12 Lock Status

+#define AT91C_MC_LOCKS13      ((unsigned int) 0x1 << 29) // (MC) Sector 13 Lock Status

+#define AT91C_MC_LOCKS14      ((unsigned int) 0x1 << 30) // (MC) Sector 14 Lock Status

+#define AT91C_MC_LOCKS15      ((unsigned int) 0x1 << 31) // (MC) Sector 15 Lock Status

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR Serial Parallel Interface

+// *****************************************************************************

+typedef struct _AT91S_SPI {

+	AT91_REG	 SPI_CR; 	// Control Register

+	AT91_REG	 SPI_MR; 	// Mode Register

+	AT91_REG	 SPI_RDR; 	// Receive Data Register

+	AT91_REG	 SPI_TDR; 	// Transmit Data Register

+	AT91_REG	 SPI_SR; 	// Status Register

+	AT91_REG	 SPI_IER; 	// Interrupt Enable Register

+	AT91_REG	 SPI_IDR; 	// Interrupt Disable Register

+	AT91_REG	 SPI_IMR; 	// Interrupt Mask Register

+	AT91_REG	 Reserved0[4]; 	// 

+	AT91_REG	 SPI_CSR[4]; 	// Chip Select Register

+	AT91_REG	 Reserved1[48]; 	// 

+	AT91_REG	 SPI_RPR; 	// Receive Pointer Register

+	AT91_REG	 SPI_RCR; 	// Receive Counter Register

+	AT91_REG	 SPI_TPR; 	// Transmit Pointer Register

+	AT91_REG	 SPI_TCR; 	// Transmit Counter Register

+	AT91_REG	 SPI_RNPR; 	// Receive Next Pointer Register

+	AT91_REG	 SPI_RNCR; 	// Receive Next Counter Register

+	AT91_REG	 SPI_TNPR; 	// Transmit Next Pointer Register

+	AT91_REG	 SPI_TNCR; 	// Transmit Next Counter Register

+	AT91_REG	 SPI_PTCR; 	// PDC Transfer Control Register

+	AT91_REG	 SPI_PTSR; 	// PDC Transfer Status Register

+} AT91S_SPI, *AT91PS_SPI;

+

+// -------- SPI_CR : (SPI Offset: 0x0) SPI Control Register -------- 

+#define AT91C_SPI_SPIEN       ((unsigned int) 0x1 <<  0) // (SPI) SPI Enable

+#define AT91C_SPI_SPIDIS      ((unsigned int) 0x1 <<  1) // (SPI) SPI Disable

+#define AT91C_SPI_SWRST       ((unsigned int) 0x1 <<  7) // (SPI) SPI Software reset

+#define AT91C_SPI_LASTXFER    ((unsigned int) 0x1 << 24) // (SPI) SPI Last Transfer

+// -------- SPI_MR : (SPI Offset: 0x4) SPI Mode Register -------- 

+#define AT91C_SPI_MSTR        ((unsigned int) 0x1 <<  0) // (SPI) Master/Slave Mode

+#define AT91C_SPI_PS          ((unsigned int) 0x1 <<  1) // (SPI) Peripheral Select

+#define 	AT91C_SPI_PS_FIXED                ((unsigned int) 0x0 <<  1) // (SPI) Fixed Peripheral Select

+#define 	AT91C_SPI_PS_VARIABLE             ((unsigned int) 0x1 <<  1) // (SPI) Variable Peripheral Select

+#define AT91C_SPI_PCSDEC      ((unsigned int) 0x1 <<  2) // (SPI) Chip Select Decode

+#define AT91C_SPI_FDIV        ((unsigned int) 0x1 <<  3) // (SPI) Clock Selection

+#define AT91C_SPI_MODFDIS     ((unsigned int) 0x1 <<  4) // (SPI) Mode Fault Detection

+#define AT91C_SPI_LLB         ((unsigned int) 0x1 <<  7) // (SPI) Clock Selection

+#define AT91C_SPI_PCS         ((unsigned int) 0xF << 16) // (SPI) Peripheral Chip Select

+#define AT91C_SPI_DLYBCS      ((unsigned int) 0xFF << 24) // (SPI) Delay Between Chip Selects

+// -------- SPI_RDR : (SPI Offset: 0x8) Receive Data Register -------- 

+#define AT91C_SPI_RD          ((unsigned int) 0xFFFF <<  0) // (SPI) Receive Data

+#define AT91C_SPI_RPCS        ((unsigned int) 0xF << 16) // (SPI) Peripheral Chip Select Status

+// -------- SPI_TDR : (SPI Offset: 0xc) Transmit Data Register -------- 

+#define AT91C_SPI_TD          ((unsigned int) 0xFFFF <<  0) // (SPI) Transmit Data

+#define AT91C_SPI_TPCS        ((unsigned int) 0xF << 16) // (SPI) Peripheral Chip Select Status

+// -------- SPI_SR : (SPI Offset: 0x10) Status Register -------- 

+#define AT91C_SPI_RDRF        ((unsigned int) 0x1 <<  0) // (SPI) Receive Data Register Full

+#define AT91C_SPI_TDRE        ((unsigned int) 0x1 <<  1) // (SPI) Transmit Data Register Empty

+#define AT91C_SPI_MODF        ((unsigned int) 0x1 <<  2) // (SPI) Mode Fault Error

+#define AT91C_SPI_OVRES       ((unsigned int) 0x1 <<  3) // (SPI) Overrun Error Status

+#define AT91C_SPI_ENDRX       ((unsigned int) 0x1 <<  4) // (SPI) End of Receiver Transfer

+#define AT91C_SPI_ENDTX       ((unsigned int) 0x1 <<  5) // (SPI) End of Receiver Transfer

+#define AT91C_SPI_RXBUFF      ((unsigned int) 0x1 <<  6) // (SPI) RXBUFF Interrupt

+#define AT91C_SPI_TXBUFE      ((unsigned int) 0x1 <<  7) // (SPI) TXBUFE Interrupt

+#define AT91C_SPI_NSSR        ((unsigned int) 0x1 <<  8) // (SPI) NSSR Interrupt

+#define AT91C_SPI_TXEMPTY     ((unsigned int) 0x1 <<  9) // (SPI) TXEMPTY Interrupt

+#define AT91C_SPI_SPIENS      ((unsigned int) 0x1 << 16) // (SPI) Enable Status

+// -------- SPI_IER : (SPI Offset: 0x14) Interrupt Enable Register -------- 

+// -------- SPI_IDR : (SPI Offset: 0x18) Interrupt Disable Register -------- 

+// -------- SPI_IMR : (SPI Offset: 0x1c) Interrupt Mask Register -------- 

+// -------- SPI_CSR : (SPI Offset: 0x30) Chip Select Register -------- 

+#define AT91C_SPI_CPOL        ((unsigned int) 0x1 <<  0) // (SPI) Clock Polarity

+#define AT91C_SPI_NCPHA       ((unsigned int) 0x1 <<  1) // (SPI) Clock Phase

+#define AT91C_SPI_CSAAT       ((unsigned int) 0x1 <<  3) // (SPI) Chip Select Active After Transfer

+#define AT91C_SPI_BITS        ((unsigned int) 0xF <<  4) // (SPI) Bits Per Transfer

+#define 	AT91C_SPI_BITS_8                    ((unsigned int) 0x0 <<  4) // (SPI) 8 Bits Per transfer

+#define 	AT91C_SPI_BITS_9                    ((unsigned int) 0x1 <<  4) // (SPI) 9 Bits Per transfer

+#define 	AT91C_SPI_BITS_10                   ((unsigned int) 0x2 <<  4) // (SPI) 10 Bits Per transfer

+#define 	AT91C_SPI_BITS_11                   ((unsigned int) 0x3 <<  4) // (SPI) 11 Bits Per transfer

+#define 	AT91C_SPI_BITS_12                   ((unsigned int) 0x4 <<  4) // (SPI) 12 Bits Per transfer

+#define 	AT91C_SPI_BITS_13                   ((unsigned int) 0x5 <<  4) // (SPI) 13 Bits Per transfer

+#define 	AT91C_SPI_BITS_14                   ((unsigned int) 0x6 <<  4) // (SPI) 14 Bits Per transfer

+#define 	AT91C_SPI_BITS_15                   ((unsigned int) 0x7 <<  4) // (SPI) 15 Bits Per transfer

+#define 	AT91C_SPI_BITS_16                   ((unsigned int) 0x8 <<  4) // (SPI) 16 Bits Per transfer

+#define AT91C_SPI_SCBR        ((unsigned int) 0xFF <<  8) // (SPI) Serial Clock Baud Rate

+#define AT91C_SPI_DLYBS       ((unsigned int) 0xFF << 16) // (SPI) Delay Before SPCK

+#define AT91C_SPI_DLYBCT      ((unsigned int) 0xFF << 24) // (SPI) Delay Between Consecutive Transfers

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR Usart

+// *****************************************************************************

+typedef struct _AT91S_USART {

+	AT91_REG	 US_CR; 	// Control Register

+	AT91_REG	 US_MR; 	// Mode Register

+	AT91_REG	 US_IER; 	// Interrupt Enable Register

+	AT91_REG	 US_IDR; 	// Interrupt Disable Register

+	AT91_REG	 US_IMR; 	// Interrupt Mask Register

+	AT91_REG	 US_CSR; 	// Channel Status Register

+	AT91_REG	 US_RHR; 	// Receiver Holding Register

+	AT91_REG	 US_THR; 	// Transmitter Holding Register

+	AT91_REG	 US_BRGR; 	// Baud Rate Generator Register

+	AT91_REG	 US_RTOR; 	// Receiver Time-out Register

+	AT91_REG	 US_TTGR; 	// Transmitter Time-guard Register

+	AT91_REG	 Reserved0[5]; 	// 

+	AT91_REG	 US_FIDI; 	// FI_DI_Ratio Register

+	AT91_REG	 US_NER; 	// Nb Errors Register

+	AT91_REG	 Reserved1[1]; 	// 

+	AT91_REG	 US_IF; 	// IRDA_FILTER Register

+	AT91_REG	 Reserved2[44]; 	// 

+	AT91_REG	 US_RPR; 	// Receive Pointer Register

+	AT91_REG	 US_RCR; 	// Receive Counter Register

+	AT91_REG	 US_TPR; 	// Transmit Pointer Register

+	AT91_REG	 US_TCR; 	// Transmit Counter Register

+	AT91_REG	 US_RNPR; 	// Receive Next Pointer Register

+	AT91_REG	 US_RNCR; 	// Receive Next Counter Register

+	AT91_REG	 US_TNPR; 	// Transmit Next Pointer Register

+	AT91_REG	 US_TNCR; 	// Transmit Next Counter Register

+	AT91_REG	 US_PTCR; 	// PDC Transfer Control Register

+	AT91_REG	 US_PTSR; 	// PDC Transfer Status Register

+} AT91S_USART, *AT91PS_USART;

+

+// -------- US_CR : (USART Offset: 0x0) Debug Unit Control Register -------- 

+#define AT91C_US_STTBRK       ((unsigned int) 0x1 <<  9) // (USART) Start Break

+#define AT91C_US_STPBRK       ((unsigned int) 0x1 << 10) // (USART) Stop Break

+#define AT91C_US_STTTO        ((unsigned int) 0x1 << 11) // (USART) Start Time-out

+#define AT91C_US_SENDA        ((unsigned int) 0x1 << 12) // (USART) Send Address

+#define AT91C_US_RSTIT        ((unsigned int) 0x1 << 13) // (USART) Reset Iterations

+#define AT91C_US_RSTNACK      ((unsigned int) 0x1 << 14) // (USART) Reset Non Acknowledge

+#define AT91C_US_RETTO        ((unsigned int) 0x1 << 15) // (USART) Rearm Time-out

+#define AT91C_US_DTREN        ((unsigned int) 0x1 << 16) // (USART) Data Terminal ready Enable

+#define AT91C_US_DTRDIS       ((unsigned int) 0x1 << 17) // (USART) Data Terminal ready Disable

+#define AT91C_US_RTSEN        ((unsigned int) 0x1 << 18) // (USART) Request to Send enable

+#define AT91C_US_RTSDIS       ((unsigned int) 0x1 << 19) // (USART) Request to Send Disable

+// -------- US_MR : (USART Offset: 0x4) Debug Unit Mode Register -------- 

+#define AT91C_US_USMODE       ((unsigned int) 0xF <<  0) // (USART) Usart mode

+#define 	AT91C_US_USMODE_NORMAL               ((unsigned int) 0x0) // (USART) Normal

+#define 	AT91C_US_USMODE_RS485                ((unsigned int) 0x1) // (USART) RS485

+#define 	AT91C_US_USMODE_HWHSH                ((unsigned int) 0x2) // (USART) Hardware Handshaking

+#define 	AT91C_US_USMODE_MODEM                ((unsigned int) 0x3) // (USART) Modem

+#define 	AT91C_US_USMODE_ISO7816_0            ((unsigned int) 0x4) // (USART) ISO7816 protocol: T = 0

+#define 	AT91C_US_USMODE_ISO7816_1            ((unsigned int) 0x6) // (USART) ISO7816 protocol: T = 1

+#define 	AT91C_US_USMODE_IRDA                 ((unsigned int) 0x8) // (USART) IrDA

+#define 	AT91C_US_USMODE_SWHSH                ((unsigned int) 0xC) // (USART) Software Handshaking

+#define AT91C_US_CLKS         ((unsigned int) 0x3 <<  4) // (USART) Clock Selection (Baud Rate generator Input Clock

+#define 	AT91C_US_CLKS_CLOCK                ((unsigned int) 0x0 <<  4) // (USART) Clock

+#define 	AT91C_US_CLKS_FDIV1                ((unsigned int) 0x1 <<  4) // (USART) fdiv1

+#define 	AT91C_US_CLKS_SLOW                 ((unsigned int) 0x2 <<  4) // (USART) slow_clock (ARM)

+#define 	AT91C_US_CLKS_EXT                  ((unsigned int) 0x3 <<  4) // (USART) External (SCK)

+#define AT91C_US_CHRL         ((unsigned int) 0x3 <<  6) // (USART) Clock Selection (Baud Rate generator Input Clock

+#define 	AT91C_US_CHRL_5_BITS               ((unsigned int) 0x0 <<  6) // (USART) Character Length: 5 bits

+#define 	AT91C_US_CHRL_6_BITS               ((unsigned int) 0x1 <<  6) // (USART) Character Length: 6 bits

+#define 	AT91C_US_CHRL_7_BITS               ((unsigned int) 0x2 <<  6) // (USART) Character Length: 7 bits

+#define 	AT91C_US_CHRL_8_BITS               ((unsigned int) 0x3 <<  6) // (USART) Character Length: 8 bits

+#define AT91C_US_SYNC         ((unsigned int) 0x1 <<  8) // (USART) Synchronous Mode Select

+#define AT91C_US_NBSTOP       ((unsigned int) 0x3 << 12) // (USART) Number of Stop bits

+#define 	AT91C_US_NBSTOP_1_BIT                ((unsigned int) 0x0 << 12) // (USART) 1 stop bit

+#define 	AT91C_US_NBSTOP_15_BIT               ((unsigned int) 0x1 << 12) // (USART) Asynchronous (SYNC=0) 2 stop bits Synchronous (SYNC=1) 2 stop bits

+#define 	AT91C_US_NBSTOP_2_BIT                ((unsigned int) 0x2 << 12) // (USART) 2 stop bits

+#define AT91C_US_MSBF         ((unsigned int) 0x1 << 16) // (USART) Bit Order

+#define AT91C_US_MODE9        ((unsigned int) 0x1 << 17) // (USART) 9-bit Character length

+#define AT91C_US_CKLO         ((unsigned int) 0x1 << 18) // (USART) Clock Output Select

+#define AT91C_US_OVER         ((unsigned int) 0x1 << 19) // (USART) Over Sampling Mode

+#define AT91C_US_INACK        ((unsigned int) 0x1 << 20) // (USART) Inhibit Non Acknowledge

+#define AT91C_US_DSNACK       ((unsigned int) 0x1 << 21) // (USART) Disable Successive NACK

+#define AT91C_US_MAX_ITER     ((unsigned int) 0x1 << 24) // (USART) Number of Repetitions

+#define AT91C_US_FILTER       ((unsigned int) 0x1 << 28) // (USART) Receive Line Filter

+// -------- US_IER : (USART Offset: 0x8) Debug Unit Interrupt Enable Register -------- 

+#define AT91C_US_RXBRK        ((unsigned int) 0x1 <<  2) // (USART) Break Received/End of Break

+#define AT91C_US_TIMEOUT      ((unsigned int) 0x1 <<  8) // (USART) Receiver Time-out

+#define AT91C_US_ITERATION    ((unsigned int) 0x1 << 10) // (USART) Max number of Repetitions Reached

+#define AT91C_US_NACK         ((unsigned int) 0x1 << 13) // (USART) Non Acknowledge

+#define AT91C_US_RIIC         ((unsigned int) 0x1 << 16) // (USART) Ring INdicator Input Change Flag

+#define AT91C_US_DSRIC        ((unsigned int) 0x1 << 17) // (USART) Data Set Ready Input Change Flag

+#define AT91C_US_DCDIC        ((unsigned int) 0x1 << 18) // (USART) Data Carrier Flag

+#define AT91C_US_CTSIC        ((unsigned int) 0x1 << 19) // (USART) Clear To Send Input Change Flag

+// -------- US_IDR : (USART Offset: 0xc) Debug Unit Interrupt Disable Register -------- 

+// -------- US_IMR : (USART Offset: 0x10) Debug Unit Interrupt Mask Register -------- 

+// -------- US_CSR : (USART Offset: 0x14) Debug Unit Channel Status Register -------- 

+#define AT91C_US_RI           ((unsigned int) 0x1 << 20) // (USART) Image of RI Input

+#define AT91C_US_DSR          ((unsigned int) 0x1 << 21) // (USART) Image of DSR Input

+#define AT91C_US_DCD          ((unsigned int) 0x1 << 22) // (USART) Image of DCD Input

+#define AT91C_US_CTS          ((unsigned int) 0x1 << 23) // (USART) Image of CTS Input

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR Synchronous Serial Controller Interface

+// *****************************************************************************

+typedef struct _AT91S_SSC {

+	AT91_REG	 SSC_CR; 	// Control Register

+	AT91_REG	 SSC_CMR; 	// Clock Mode Register

+	AT91_REG	 Reserved0[2]; 	// 

+	AT91_REG	 SSC_RCMR; 	// Receive Clock ModeRegister

+	AT91_REG	 SSC_RFMR; 	// Receive Frame Mode Register

+	AT91_REG	 SSC_TCMR; 	// Transmit Clock Mode Register

+	AT91_REG	 SSC_TFMR; 	// Transmit Frame Mode Register

+	AT91_REG	 SSC_RHR; 	// Receive Holding Register

+	AT91_REG	 SSC_THR; 	// Transmit Holding Register

+	AT91_REG	 Reserved1[2]; 	// 

+	AT91_REG	 SSC_RSHR; 	// Receive Sync Holding Register

+	AT91_REG	 SSC_TSHR; 	// Transmit Sync Holding Register

+	AT91_REG	 Reserved2[2]; 	// 

+	AT91_REG	 SSC_SR; 	// Status Register

+	AT91_REG	 SSC_IER; 	// Interrupt Enable Register

+	AT91_REG	 SSC_IDR; 	// Interrupt Disable Register

+	AT91_REG	 SSC_IMR; 	// Interrupt Mask Register

+	AT91_REG	 Reserved3[44]; 	// 

+	AT91_REG	 SSC_RPR; 	// Receive Pointer Register

+	AT91_REG	 SSC_RCR; 	// Receive Counter Register

+	AT91_REG	 SSC_TPR; 	// Transmit Pointer Register

+	AT91_REG	 SSC_TCR; 	// Transmit Counter Register

+	AT91_REG	 SSC_RNPR; 	// Receive Next Pointer Register

+	AT91_REG	 SSC_RNCR; 	// Receive Next Counter Register

+	AT91_REG	 SSC_TNPR; 	// Transmit Next Pointer Register

+	AT91_REG	 SSC_TNCR; 	// Transmit Next Counter Register

+	AT91_REG	 SSC_PTCR; 	// PDC Transfer Control Register

+	AT91_REG	 SSC_PTSR; 	// PDC Transfer Status Register

+} AT91S_SSC, *AT91PS_SSC;

+

+// -------- SSC_CR : (SSC Offset: 0x0) SSC Control Register -------- 

+#define AT91C_SSC_RXEN        ((unsigned int) 0x1 <<  0) // (SSC) Receive Enable

+#define AT91C_SSC_RXDIS       ((unsigned int) 0x1 <<  1) // (SSC) Receive Disable

+#define AT91C_SSC_TXEN        ((unsigned int) 0x1 <<  8) // (SSC) Transmit Enable

+#define AT91C_SSC_TXDIS       ((unsigned int) 0x1 <<  9) // (SSC) Transmit Disable

+#define AT91C_SSC_SWRST       ((unsigned int) 0x1 << 15) // (SSC) Software Reset

+// -------- SSC_RCMR : (SSC Offset: 0x10) SSC Receive Clock Mode Register -------- 

+#define AT91C_SSC_CKS         ((unsigned int) 0x3 <<  0) // (SSC) Receive/Transmit Clock Selection

+#define 	AT91C_SSC_CKS_DIV                  ((unsigned int) 0x0) // (SSC) Divided Clock

+#define 	AT91C_SSC_CKS_TK                   ((unsigned int) 0x1) // (SSC) TK Clock signal

+#define 	AT91C_SSC_CKS_RK                   ((unsigned int) 0x2) // (SSC) RK pin

+#define AT91C_SSC_CKO         ((unsigned int) 0x7 <<  2) // (SSC) Receive/Transmit Clock Output Mode Selection

+#define 	AT91C_SSC_CKO_NONE                 ((unsigned int) 0x0 <<  2) // (SSC) Receive/Transmit Clock Output Mode: None RK pin: Input-only

+#define 	AT91C_SSC_CKO_CONTINOUS            ((unsigned int) 0x1 <<  2) // (SSC) Continuous Receive/Transmit Clock RK pin: Output

+#define 	AT91C_SSC_CKO_DATA_TX              ((unsigned int) 0x2 <<  2) // (SSC) Receive/Transmit Clock only during data transfers RK pin: Output

+#define AT91C_SSC_CKI         ((unsigned int) 0x1 <<  5) // (SSC) Receive/Transmit Clock Inversion

+#define AT91C_SSC_START       ((unsigned int) 0xF <<  8) // (SSC) Receive/Transmit Start Selection

+#define 	AT91C_SSC_START_CONTINOUS            ((unsigned int) 0x0 <<  8) // (SSC) Continuous, as soon as the receiver is enabled, and immediately after the end of transfer of the previous data.

+#define 	AT91C_SSC_START_TX                   ((unsigned int) 0x1 <<  8) // (SSC) Transmit/Receive start

+#define 	AT91C_SSC_START_LOW_RF               ((unsigned int) 0x2 <<  8) // (SSC) Detection of a low level on RF input

+#define 	AT91C_SSC_START_HIGH_RF              ((unsigned int) 0x3 <<  8) // (SSC) Detection of a high level on RF input

+#define 	AT91C_SSC_START_FALL_RF              ((unsigned int) 0x4 <<  8) // (SSC) Detection of a falling edge on RF input

+#define 	AT91C_SSC_START_RISE_RF              ((unsigned int) 0x5 <<  8) // (SSC) Detection of a rising edge on RF input

+#define 	AT91C_SSC_START_LEVEL_RF             ((unsigned int) 0x6 <<  8) // (SSC) Detection of any level change on RF input

+#define 	AT91C_SSC_START_EDGE_RF              ((unsigned int) 0x7 <<  8) // (SSC) Detection of any edge on RF input

+#define 	AT91C_SSC_START_0                    ((unsigned int) 0x8 <<  8) // (SSC) Compare 0

+#define AT91C_SSC_STTDLY      ((unsigned int) 0xFF << 16) // (SSC) Receive/Transmit Start Delay

+#define AT91C_SSC_PERIOD      ((unsigned int) 0xFF << 24) // (SSC) Receive/Transmit Period Divider Selection

+// -------- SSC_RFMR : (SSC Offset: 0x14) SSC Receive Frame Mode Register -------- 

+#define AT91C_SSC_DATLEN      ((unsigned int) 0x1F <<  0) // (SSC) Data Length

+#define AT91C_SSC_LOOP        ((unsigned int) 0x1 <<  5) // (SSC) Loop Mode

+#define AT91C_SSC_MSBF        ((unsigned int) 0x1 <<  7) // (SSC) Most Significant Bit First

+#define AT91C_SSC_DATNB       ((unsigned int) 0xF <<  8) // (SSC) Data Number per Frame

+#define AT91C_SSC_FSLEN       ((unsigned int) 0xF << 16) // (SSC) Receive/Transmit Frame Sync length

+#define AT91C_SSC_FSOS        ((unsigned int) 0x7 << 20) // (SSC) Receive/Transmit Frame Sync Output Selection

+#define 	AT91C_SSC_FSOS_NONE                 ((unsigned int) 0x0 << 20) // (SSC) Selected Receive/Transmit Frame Sync Signal: None RK pin Input-only

+#define 	AT91C_SSC_FSOS_NEGATIVE             ((unsigned int) 0x1 << 20) // (SSC) Selected Receive/Transmit Frame Sync Signal: Negative Pulse

+#define 	AT91C_SSC_FSOS_POSITIVE             ((unsigned int) 0x2 << 20) // (SSC) Selected Receive/Transmit Frame Sync Signal: Positive Pulse

+#define 	AT91C_SSC_FSOS_LOW                  ((unsigned int) 0x3 << 20) // (SSC) Selected Receive/Transmit Frame Sync Signal: Driver Low during data transfer

+#define 	AT91C_SSC_FSOS_HIGH                 ((unsigned int) 0x4 << 20) // (SSC) Selected Receive/Transmit Frame Sync Signal: Driver High during data transfer

+#define 	AT91C_SSC_FSOS_TOGGLE               ((unsigned int) 0x5 << 20) // (SSC) Selected Receive/Transmit Frame Sync Signal: Toggling at each start of data transfer

+#define AT91C_SSC_FSEDGE      ((unsigned int) 0x1 << 24) // (SSC) Frame Sync Edge Detection

+// -------- SSC_TCMR : (SSC Offset: 0x18) SSC Transmit Clock Mode Register -------- 

+// -------- SSC_TFMR : (SSC Offset: 0x1c) SSC Transmit Frame Mode Register -------- 

+#define AT91C_SSC_DATDEF      ((unsigned int) 0x1 <<  5) // (SSC) Data Default Value

+#define AT91C_SSC_FSDEN       ((unsigned int) 0x1 << 23) // (SSC) Frame Sync Data Enable

+// -------- SSC_SR : (SSC Offset: 0x40) SSC Status Register -------- 

+#define AT91C_SSC_TXRDY       ((unsigned int) 0x1 <<  0) // (SSC) Transmit Ready

+#define AT91C_SSC_TXEMPTY     ((unsigned int) 0x1 <<  1) // (SSC) Transmit Empty

+#define AT91C_SSC_ENDTX       ((unsigned int) 0x1 <<  2) // (SSC) End Of Transmission

+#define AT91C_SSC_TXBUFE      ((unsigned int) 0x1 <<  3) // (SSC) Transmit Buffer Empty

+#define AT91C_SSC_RXRDY       ((unsigned int) 0x1 <<  4) // (SSC) Receive Ready

+#define AT91C_SSC_OVRUN       ((unsigned int) 0x1 <<  5) // (SSC) Receive Overrun

+#define AT91C_SSC_ENDRX       ((unsigned int) 0x1 <<  6) // (SSC) End of Reception

+#define AT91C_SSC_RXBUFF      ((unsigned int) 0x1 <<  7) // (SSC) Receive Buffer Full

+#define AT91C_SSC_TXSYN       ((unsigned int) 0x1 << 10) // (SSC) Transmit Sync

+#define AT91C_SSC_RXSYN       ((unsigned int) 0x1 << 11) // (SSC) Receive Sync

+#define AT91C_SSC_TXENA       ((unsigned int) 0x1 << 16) // (SSC) Transmit Enable

+#define AT91C_SSC_RXENA       ((unsigned int) 0x1 << 17) // (SSC) Receive Enable

+// -------- SSC_IER : (SSC Offset: 0x44) SSC Interrupt Enable Register -------- 

+// -------- SSC_IDR : (SSC Offset: 0x48) SSC Interrupt Disable Register -------- 

+// -------- SSC_IMR : (SSC Offset: 0x4c) SSC Interrupt Mask Register -------- 

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR Two-wire Interface

+// *****************************************************************************

+typedef struct _AT91S_TWI {

+	AT91_REG	 TWI_CR; 	// Control Register

+	AT91_REG	 TWI_MMR; 	// Master Mode Register

+	AT91_REG	 Reserved0[1]; 	// 

+	AT91_REG	 TWI_IADR; 	// Internal Address Register

+	AT91_REG	 TWI_CWGR; 	// Clock Waveform Generator Register

+	AT91_REG	 Reserved1[3]; 	// 

+	AT91_REG	 TWI_SR; 	// Status Register

+	AT91_REG	 TWI_IER; 	// Interrupt Enable Register

+	AT91_REG	 TWI_IDR; 	// Interrupt Disable Register

+	AT91_REG	 TWI_IMR; 	// Interrupt Mask Register

+	AT91_REG	 TWI_RHR; 	// Receive Holding Register

+	AT91_REG	 TWI_THR; 	// Transmit Holding Register

+} AT91S_TWI, *AT91PS_TWI;

+

+// -------- TWI_CR : (TWI Offset: 0x0) TWI Control Register -------- 

+#define AT91C_TWI_START       ((unsigned int) 0x1 <<  0) // (TWI) Send a START Condition

+#define AT91C_TWI_STOP        ((unsigned int) 0x1 <<  1) // (TWI) Send a STOP Condition

+#define AT91C_TWI_MSEN        ((unsigned int) 0x1 <<  2) // (TWI) TWI Master Transfer Enabled

+#define AT91C_TWI_MSDIS       ((unsigned int) 0x1 <<  3) // (TWI) TWI Master Transfer Disabled

+#define AT91C_TWI_SWRST       ((unsigned int) 0x1 <<  7) // (TWI) Software Reset

+// -------- TWI_MMR : (TWI Offset: 0x4) TWI Master Mode Register -------- 

+#define AT91C_TWI_IADRSZ      ((unsigned int) 0x3 <<  8) // (TWI) Internal Device Address Size

+#define 	AT91C_TWI_IADRSZ_NO                   ((unsigned int) 0x0 <<  8) // (TWI) No internal device address

+#define 	AT91C_TWI_IADRSZ_1_BYTE               ((unsigned int) 0x1 <<  8) // (TWI) One-byte internal device address

+#define 	AT91C_TWI_IADRSZ_2_BYTE               ((unsigned int) 0x2 <<  8) // (TWI) Two-byte internal device address

+#define 	AT91C_TWI_IADRSZ_3_BYTE               ((unsigned int) 0x3 <<  8) // (TWI) Three-byte internal device address

+#define AT91C_TWI_MREAD       ((unsigned int) 0x1 << 12) // (TWI) Master Read Direction

+#define AT91C_TWI_DADR        ((unsigned int) 0x7F << 16) // (TWI) Device Address

+// -------- TWI_CWGR : (TWI Offset: 0x10) TWI Clock Waveform Generator Register -------- 

+#define AT91C_TWI_CLDIV       ((unsigned int) 0xFF <<  0) // (TWI) Clock Low Divider

+#define AT91C_TWI_CHDIV       ((unsigned int) 0xFF <<  8) // (TWI) Clock High Divider

+#define AT91C_TWI_CKDIV       ((unsigned int) 0x7 << 16) // (TWI) Clock Divider

+// -------- TWI_SR : (TWI Offset: 0x20) TWI Status Register -------- 

+#define AT91C_TWI_TXCOMP      ((unsigned int) 0x1 <<  0) // (TWI) Transmission Completed

+#define AT91C_TWI_RXRDY       ((unsigned int) 0x1 <<  1) // (TWI) Receive holding register ReaDY

+#define AT91C_TWI_TXRDY       ((unsigned int) 0x1 <<  2) // (TWI) Transmit holding register ReaDY

+#define AT91C_TWI_OVRE        ((unsigned int) 0x1 <<  6) // (TWI) Overrun Error

+#define AT91C_TWI_UNRE        ((unsigned int) 0x1 <<  7) // (TWI) Underrun Error

+#define AT91C_TWI_NACK        ((unsigned int) 0x1 <<  8) // (TWI) Not Acknowledged

+// -------- TWI_IER : (TWI Offset: 0x24) TWI Interrupt Enable Register -------- 

+// -------- TWI_IDR : (TWI Offset: 0x28) TWI Interrupt Disable Register -------- 

+// -------- TWI_IMR : (TWI Offset: 0x2c) TWI Interrupt Mask Register -------- 

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR PWMC Channel Interface

+// *****************************************************************************

+typedef struct _AT91S_PWMC_CH {

+	AT91_REG	 PWMC_CMR; 	// Channel Mode Register

+	AT91_REG	 PWMC_CDTYR; 	// Channel Duty Cycle Register

+	AT91_REG	 PWMC_CPRDR; 	// Channel Period Register

+	AT91_REG	 PWMC_CCNTR; 	// Channel Counter Register

+	AT91_REG	 PWMC_CUPDR; 	// Channel Update Register

+	AT91_REG	 PWMC_Reserved[3]; 	// Reserved

+} AT91S_PWMC_CH, *AT91PS_PWMC_CH;

+

+// -------- PWMC_CMR : (PWMC_CH Offset: 0x0) PWMC Channel Mode Register -------- 

+#define AT91C_PWMC_CPRE       ((unsigned int) 0xF <<  0) // (PWMC_CH) Channel Pre-scaler : PWMC_CLKx

+#define 	AT91C_PWMC_CPRE_MCK                  ((unsigned int) 0x0) // (PWMC_CH) 

+#define 	AT91C_PWMC_CPRE_MCKA                 ((unsigned int) 0xB) // (PWMC_CH) 

+#define 	AT91C_PWMC_CPRE_MCKB                 ((unsigned int) 0xC) // (PWMC_CH) 

+#define AT91C_PWMC_CALG       ((unsigned int) 0x1 <<  8) // (PWMC_CH) Channel Alignment

+#define AT91C_PWMC_CPOL       ((unsigned int) 0x1 <<  9) // (PWMC_CH) Channel Polarity

+#define AT91C_PWMC_CPD        ((unsigned int) 0x1 << 10) // (PWMC_CH) Channel Update Period

+// -------- PWMC_CDTYR : (PWMC_CH Offset: 0x4) PWMC Channel Duty Cycle Register -------- 

+#define AT91C_PWMC_CDTY       ((unsigned int) 0x0 <<  0) // (PWMC_CH) Channel Duty Cycle

+// -------- PWMC_CPRDR : (PWMC_CH Offset: 0x8) PWMC Channel Period Register -------- 

+#define AT91C_PWMC_CPRD       ((unsigned int) 0x0 <<  0) // (PWMC_CH) Channel Period

+// -------- PWMC_CCNTR : (PWMC_CH Offset: 0xc) PWMC Channel Counter Register -------- 

+#define AT91C_PWMC_CCNT       ((unsigned int) 0x0 <<  0) // (PWMC_CH) Channel Counter

+// -------- PWMC_CUPDR : (PWMC_CH Offset: 0x10) PWMC Channel Update Register -------- 

+#define AT91C_PWMC_CUPD       ((unsigned int) 0x0 <<  0) // (PWMC_CH) Channel Update

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR Pulse Width Modulation Controller Interface

+// *****************************************************************************

+typedef struct _AT91S_PWMC {

+	AT91_REG	 PWMC_MR; 	// PWMC Mode Register

+	AT91_REG	 PWMC_ENA; 	// PWMC Enable Register

+	AT91_REG	 PWMC_DIS; 	// PWMC Disable Register

+	AT91_REG	 PWMC_SR; 	// PWMC Status Register

+	AT91_REG	 PWMC_IER; 	// PWMC Interrupt Enable Register

+	AT91_REG	 PWMC_IDR; 	// PWMC Interrupt Disable Register

+	AT91_REG	 PWMC_IMR; 	// PWMC Interrupt Mask Register

+	AT91_REG	 PWMC_ISR; 	// PWMC Interrupt Status Register

+	AT91_REG	 Reserved0[55]; 	// 

+	AT91_REG	 PWMC_VR; 	// PWMC Version Register

+	AT91_REG	 Reserved1[64]; 	// 

+	AT91S_PWMC_CH	 PWMC_CH[4]; 	// PWMC Channel

+} AT91S_PWMC, *AT91PS_PWMC;

+

+// -------- PWMC_MR : (PWMC Offset: 0x0) PWMC Mode Register -------- 

+#define AT91C_PWMC_DIVA       ((unsigned int) 0xFF <<  0) // (PWMC) CLKA divide factor.

+#define AT91C_PWMC_PREA       ((unsigned int) 0xF <<  8) // (PWMC) Divider Input Clock Prescaler A

+#define 	AT91C_PWMC_PREA_MCK                  ((unsigned int) 0x0 <<  8) // (PWMC) 

+#define AT91C_PWMC_DIVB       ((unsigned int) 0xFF << 16) // (PWMC) CLKB divide factor.

+#define AT91C_PWMC_PREB       ((unsigned int) 0xF << 24) // (PWMC) Divider Input Clock Prescaler B

+#define 	AT91C_PWMC_PREB_MCK                  ((unsigned int) 0x0 << 24) // (PWMC) 

+// -------- PWMC_ENA : (PWMC Offset: 0x4) PWMC Enable Register -------- 

+#define AT91C_PWMC_CHID0      ((unsigned int) 0x1 <<  0) // (PWMC) Channel ID 0

+#define AT91C_PWMC_CHID1      ((unsigned int) 0x1 <<  1) // (PWMC) Channel ID 1

+#define AT91C_PWMC_CHID2      ((unsigned int) 0x1 <<  2) // (PWMC) Channel ID 2

+#define AT91C_PWMC_CHID3      ((unsigned int) 0x1 <<  3) // (PWMC) Channel ID 3

+// -------- PWMC_DIS : (PWMC Offset: 0x8) PWMC Disable Register -------- 

+// -------- PWMC_SR : (PWMC Offset: 0xc) PWMC Status Register -------- 

+// -------- PWMC_IER : (PWMC Offset: 0x10) PWMC Interrupt Enable Register -------- 

+// -------- PWMC_IDR : (PWMC Offset: 0x14) PWMC Interrupt Disable Register -------- 

+// -------- PWMC_IMR : (PWMC Offset: 0x18) PWMC Interrupt Mask Register -------- 

+// -------- PWMC_ISR : (PWMC Offset: 0x1c) PWMC Interrupt Status Register -------- 

+

+// *****************************************************************************

+//              SOFTWARE API DEFINITION  FOR USB Device Interface

+// *****************************************************************************

+typedef struct _AT91S_UDP {

+	AT91_REG	 UDP_NUM; 	// Frame Number Register

+	AT91_REG	 UDP_GLBSTATE; 	// Global State Register

+	AT91_REG	 UDP_FADDR; 	// Function Address Register

+	AT91_REG	 Reserved0[1]; 	// 

+	AT91_REG	 UDP_IER; 	// Interrupt Enable Register

+	AT91_REG	 UDP_IDR; 	// Interrupt Disable Register

+	AT91_REG	 UDP_IMR; 	// Interrupt Mask Register

+	AT91_REG	 UDP_ISR; 	// Interrupt Status Register

+	AT91_REG	 UDP_ICR; 	// Interrupt Clear Register

+	AT91_REG	 Reserved1[1]; 	// 

+	AT91_REG	 UDP_RSTEP; 	// Reset Endpoint Register

+	AT91_REG	 Reserved2[1]; 	// 

+	AT91_REG	 UDP_CSR[6]; 	// Endpoint Control and Status Register

+	AT91_REG	 Reserved3[2]; 	// 

+	AT91_REG	 UDP_FDR[6]; 	// Endpoint FIFO Data Register

+	AT91_REG	 Reserved4[3]; 	// 

+	AT91_REG	 UDP_TXVC; 	// Transceiver Control Register

+} AT91S_UDP, *AT91PS_UDP;

+

+// -------- UDP_FRM_NUM : (UDP Offset: 0x0) USB Frame Number Register -------- 

+#define AT91C_UDP_FRM_NUM     ((unsigned int) 0x7FF <<  0) // (UDP) Frame Number as Defined in the Packet Field Formats

+#define AT91C_UDP_FRM_ERR     ((unsigned int) 0x1 << 16) // (UDP) Frame Error

+#define AT91C_UDP_FRM_OK      ((unsigned int) 0x1 << 17) // (UDP) Frame OK

+// -------- UDP_GLB_STATE : (UDP Offset: 0x4) USB Global State Register -------- 

+#define AT91C_UDP_FADDEN      ((unsigned int) 0x1 <<  0) // (UDP) Function Address Enable

+#define AT91C_UDP_CONFG       ((unsigned int) 0x1 <<  1) // (UDP) Configured

+#define AT91C_UDP_ESR         ((unsigned int) 0x1 <<  2) // (UDP) Enable Send Resume

+#define AT91C_UDP_RSMINPR     ((unsigned int) 0x1 <<  3) // (UDP) A Resume Has Been Sent to the Host

+#define AT91C_UDP_RMWUPE      ((unsigned int) 0x1 <<  4) // (UDP) Remote Wake Up Enable

+// -------- UDP_FADDR : (UDP Offset: 0x8) USB Function Address Register -------- 

+#define AT91C_UDP_FADD        ((unsigned int) 0xFF <<  0) // (UDP) Function Address Value

+#define AT91C_UDP_FEN         ((unsigned int) 0x1 <<  8) // (UDP) Function Enable

+// -------- UDP_IER : (UDP Offset: 0x10) USB Interrupt Enable Register -------- 

+#define AT91C_UDP_EPINT0      ((unsigned int) 0x1 <<  0) // (UDP) Endpoint 0 Interrupt

+#define AT91C_UDP_EPINT1      ((unsigned int) 0x1 <<  1) // (UDP) Endpoint 0 Interrupt

+#define AT91C_UDP_EPINT2      ((unsigned int) 0x1 <<  2) // (UDP) Endpoint 2 Interrupt

+#define AT91C_UDP_EPINT3      ((unsigned int) 0x1 <<  3) // (UDP) Endpoint 3 Interrupt

+#define AT91C_UDP_EPINT4      ((unsigned int) 0x1 <<  4) // (UDP) Endpoint 4 Interrupt

+#define AT91C_UDP_EPINT5      ((unsigned int) 0x1 <<  5) // (UDP) Endpoint 5 Interrupt

+#define AT91C_UDP_RXSUSP      ((unsigned int) 0x1 <<  8) // (UDP) USB Suspend Interrupt

+#define AT91C_UDP_RXRSM       ((unsigned int) 0x1 <<  9) // (UDP) USB Resume Interrupt

+#define AT91C_UDP_EXTRSM      ((unsigned int) 0x1 << 10) // (UDP) USB External Resume Interrupt

+#define AT91C_UDP_SOFINT      ((unsigned int) 0x1 << 11) // (UDP) USB