Upgrade FreeRTOS to 10.2.0

32 files changed, 9547 insertions, 4599 deletions

diff --git a/src/FreeRTOS/License/license.txt b/src/FreeRTOS/License/license.txt
index f96767f..9c59050 100644
--- a/src/FreeRTOS/License/license.txt
+++ b/src/FreeRTOS/License/license.txt
@@ -1,383 +1,37 @@
-----------------------------------------------------------------------------

-

-NOTE: The modification to the GPL documented below is included to allow you to

-distribute a combined work that includes FreeRTOS without being obliged to

-provide the source code for proprietary components.

-

-----------------------------------------------------------------------------

-

-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 version 2 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 with other modules is making a combined work based on FreeRTOS.

-Thus, the terms and conditions of the GNU General Public License V2 cover the

-whole combination.

-

-As a special exception, the copyright holders of FreeRTOS give you permission to

-link FreeRTOS with independent modules to produce a statically linked

-executable, regardless of the license terms of these independent modules, and to

-copy and distribute the resulting executable under terms of your choice,

-provided that you also meet, for each linked independent module, the terms and

-conditions of the license of that module.  An independent module is a module

-which is not derived from or based on 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).

-

-

---------------------------------------------------------------------

-

-The standard GPL v2 text follows:

-

-

-		    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 kernel is released under the MIT open source license, the text of

+which is provided below.

+

+This license covers the FreeRTOS kernel source files, which are located in the

+/FreeRTOS/Source directory of the official FreeRTOS kernel download.  It also

+covers most of the source files in the demo application projects, which are

+located in the /FreeRTOS/Demo directory of the official FreeRTOS download.  The

+demo projects may also include third party software that is not part of FreeRTOS

+and is licensed separately to FreeRTOS.  Examples of third party software

+includes header files provided by chip or tools vendors, linker scripts,

+peripheral drivers, etc.  All the software in subdirectories of the /FreeRTOS

+directory is either open source or distributed with permission, and is free for

+use.  For the avoidance of doubt, refer to the comments at the top of each

+source file.

+

+

+License text:

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

+

+Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+Permission is hereby granted, free of charge, to any person obtaining a copy of

+this software and associated documentation files (the "Software"), to deal in

+the Software without restriction, including without limitation the rights to

+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+the Software, and to permit persons to whom the Software is furnished to do so,

+subject to the following conditions:

+

+The above copyright notice and this permission notice shall be included in all

+copies or substantial portions of the Software.

+

+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

 

diff --git a/src/FreeRTOS/Source/croutine.c b/src/FreeRTOS/Source/croutine.c
index 4d6d4d7..9606f61 100644
--- a/src/FreeRTOS/Source/croutine.c
+++ b/src/FreeRTOS/Source/croutine.c
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 #include "FreeRTOS.h"

 #include "task.h"

@@ -302,7 +260,7 @@ CRCB_t *pxCRCB;
 				( void ) uxListRemove( &( pxCRCB->xGenericListItem ) );

 

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

-				if( pxCRCB->xEventListItem.pvContainer )

+				if( pxCRCB->xEventListItem.pxContainer )

 				{

 					( void ) uxListRemove( &( pxCRCB->xEventListItem ) );

 				}

diff --git a/src/FreeRTOS/Source/event_groups.c b/src/FreeRTOS/Source/event_groups.c
index 625548c..fb2e7fc 100644
--- a/src/FreeRTOS/Source/event_groups.c
+++ b/src/FreeRTOS/Source/event_groups.c
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 /* Standard includes. */

 #include <stdlib.h>

@@ -81,19 +39,11 @@ task.h is included from an application file. */
 #include "timers.h"

 #include "event_groups.h"

 

-/* Lint e961 and e750 are suppressed as a MISRA exception justified because the

-MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined for the

-header files above, but not in this file, in order to generate the correct

-privileged Vs unprivileged linkage and placement. */

-#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750. */

-

-#if ( INCLUDE_xEventGroupSetBitFromISR == 1 ) && ( configUSE_TIMERS == 0 )

-	#error configUSE_TIMERS must be set to 1 to make the xEventGroupSetBitFromISR() function available.

-#endif

-

-#if ( INCLUDE_xEventGroupSetBitFromISR == 1 ) && ( INCLUDE_xTimerPendFunctionCall == 0 )

-	#error INCLUDE_xTimerPendFunctionCall must also be set to one to make the xEventGroupSetBitFromISR() function available.

-#endif

+/* Lint e961, e750 and e9021 are suppressed as a MISRA exception justified

+because the MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined

+for the header files above, but not in this file, in order to generate the

+correct privileged Vs unprivileged linkage and placement. */

+#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750 !e9021 See comment above. */

 

 /* The following bit fields convey control information in a task's event list

 item value.  It is important they don't clash with the

@@ -110,7 +60,7 @@ taskEVENT_LIST_ITEM_VALUE_IN_USE definition. */
 	#define eventEVENT_BITS_CONTROL_BYTES	0xff000000UL

 #endif

 

-typedef struct xEventGroupDefinition

+typedef struct EventGroupDef_t

 {

 	EventBits_t uxEventBits;

 	List_t xTasksWaitingForBits;		/*< List of tasks waiting for a bit to be set. */

@@ -119,6 +69,9 @@ typedef struct xEventGroupDefinition
 		UBaseType_t uxEventGroupNumber;

 	#endif

 

+	#if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )

+		uint8_t ucStaticallyAllocated; /*< Set to pdTRUE if the event group is statically allocated to ensure no attempt is made to free the memory. */

+	#endif

 } EventGroup_t;

 

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

@@ -131,34 +84,114 @@ typedef struct xEventGroupDefinition
  * wait condition is met if any of the bits set in uxBitsToWait for are also set

  * in uxCurrentEventBits.

  */

-static BaseType_t prvTestWaitCondition( const EventBits_t uxCurrentEventBits, const EventBits_t uxBitsToWaitFor, const BaseType_t xWaitForAllBits );

+static BaseType_t prvTestWaitCondition( const EventBits_t uxCurrentEventBits, const EventBits_t uxBitsToWaitFor, const BaseType_t xWaitForAllBits ) PRIVILEGED_FUNCTION;

 

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

 

-EventGroupHandle_t xEventGroupCreate( void )

-{

-EventGroup_t *pxEventBits;

+#if( configSUPPORT_STATIC_ALLOCATION == 1 )

 

-	pxEventBits = ( EventGroup_t * ) pvPortMalloc( sizeof( EventGroup_t ) );

-	if( pxEventBits != NULL )

+	EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t *pxEventGroupBuffer )

 	{

-		pxEventBits->uxEventBits = 0;

-		vListInitialise( &( pxEventBits->xTasksWaitingForBits ) );

-		traceEVENT_GROUP_CREATE( pxEventBits );

+	EventGroup_t *pxEventBits;

+

+		/* A StaticEventGroup_t object must be provided. */

+		configASSERT( pxEventGroupBuffer );

+

+		#if( configASSERT_DEFINED == 1 )

+		{

+			/* Sanity check that the size of the structure used to declare a

+			variable of type StaticEventGroup_t equals the size of the real

+			event group structure. */

+			volatile size_t xSize = sizeof( StaticEventGroup_t );

+			configASSERT( xSize == sizeof( EventGroup_t ) );

+		} /*lint !e529 xSize is referenced if configASSERT() is defined. */

+		#endif /* configASSERT_DEFINED */

+

+		/* The user has provided a statically allocated event group - use it. */

+		pxEventBits = ( EventGroup_t * ) pxEventGroupBuffer; /*lint !e740 !e9087 EventGroup_t and StaticEventGroup_t are deliberately aliased for data hiding purposes and guaranteed to have the same size and alignment requirement - checked by configASSERT(). */

+

+		if( pxEventBits != NULL )

+		{

+			pxEventBits->uxEventBits = 0;

+			vListInitialise( &( pxEventBits->xTasksWaitingForBits ) );

+

+			#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

+			{

+				/* Both static and dynamic allocation can be used, so note that

+				this event group was created statically in case the event group

+				is later deleted. */

+				pxEventBits->ucStaticallyAllocated = pdTRUE;

+			}

+			#endif /* configSUPPORT_DYNAMIC_ALLOCATION */

+

+			traceEVENT_GROUP_CREATE( pxEventBits );

+		}

+		else

+		{

+			/* xEventGroupCreateStatic should only ever be called with

+			pxEventGroupBuffer pointing to a pre-allocated (compile time

+			allocated) StaticEventGroup_t variable. */

+			traceEVENT_GROUP_CREATE_FAILED();

+		}

+

+		return pxEventBits;

 	}

-	else

+

+#endif /* configSUPPORT_STATIC_ALLOCATION */

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

+

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

+

+	EventGroupHandle_t xEventGroupCreate( void )

 	{

-		traceEVENT_GROUP_CREATE_FAILED();

+	EventGroup_t *pxEventBits;

+

+		/* Allocate the event group.  Justification for MISRA deviation as

+		follows:  pvPortMalloc() always ensures returned memory blocks are

+		aligned per the requirements of the MCU stack.  In this case

+		pvPortMalloc() must return a pointer that is guaranteed to meet the

+		alignment requirements of the EventGroup_t structure - which (if you

+		follow it through) is the alignment requirements of the TickType_t type

+		(EventBits_t being of TickType_t itself).  Therefore, whenever the

+		stack alignment requirements are greater than or equal to the

+		TickType_t alignment requirements the cast is safe.  In other cases,

+		where the natural word size of the architecture is less than

+		sizeof( TickType_t ), the TickType_t variables will be accessed in two

+		or more reads operations, and the alignment requirements is only that

+		of each individual read. */

+		pxEventBits = ( EventGroup_t * ) pvPortMalloc( sizeof( EventGroup_t ) ); /*lint !e9087 !e9079 see comment above. */

+

+		if( pxEventBits != NULL )

+		{

+			pxEventBits->uxEventBits = 0;

+			vListInitialise( &( pxEventBits->xTasksWaitingForBits ) );

+

+			#if( configSUPPORT_STATIC_ALLOCATION == 1 )

+			{

+				/* Both static and dynamic allocation can be used, so note this

+				event group was allocated statically in case the event group is

+				later deleted. */

+				pxEventBits->ucStaticallyAllocated = pdFALSE;

+			}

+			#endif /* configSUPPORT_STATIC_ALLOCATION */

+

+			traceEVENT_GROUP_CREATE( pxEventBits );

+		}

+		else

+		{

+			traceEVENT_GROUP_CREATE_FAILED(); /*lint !e9063 Else branch only exists to allow tracing and does not generate code if trace macros are not defined. */

+		}

+

+		return pxEventBits;

 	}

 

-	return ( EventGroupHandle_t ) pxEventBits;

-}

+#endif /* configSUPPORT_DYNAMIC_ALLOCATION */

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

 

 EventBits_t xEventGroupSync( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait )

 {

 EventBits_t uxOriginalBitValue, uxReturn;

-EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;

+EventGroup_t *pxEventBits = xEventGroup;

 BaseType_t xAlreadyYielded;

 BaseType_t xTimeoutOccurred = pdFALSE;

 

@@ -209,6 +242,7 @@ BaseType_t xTimeoutOccurred = pdFALSE;
 				/* The rendezvous bits were not set, but no block time was

 				specified - just return the current event bit value. */

 				uxReturn = pxEventBits->uxEventBits;

+				xTimeoutOccurred = pdTRUE;

 			}

 		}

 	}

@@ -267,13 +301,16 @@ BaseType_t xTimeoutOccurred = pdFALSE;
 

 	traceEVENT_GROUP_SYNC_END( xEventGroup, uxBitsToSet, uxBitsToWaitFor, xTimeoutOccurred );

 

+	/* Prevent compiler warnings when trace macros are not used. */

+	( void ) xTimeoutOccurred;

+

 	return uxReturn;

 }

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

 

 EventBits_t xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait )

 {

-EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;

+EventGroup_t *pxEventBits = xEventGroup;

 EventBits_t uxReturn, uxControlBits = 0;

 BaseType_t xWaitConditionMet, xAlreadyYielded;

 BaseType_t xTimeoutOccurred = pdFALSE;

@@ -318,6 +355,7 @@ BaseType_t xTimeoutOccurred = pdFALSE;
 			/* The wait condition has not been met, but no block time was

 			specified, so just return the current value. */

 			uxReturn = uxCurrentEventBits;

+			xTimeoutOccurred = pdTRUE;

 		}

 		else

 		{

@@ -399,11 +437,9 @@ BaseType_t xTimeoutOccurred = pdFALSE;
 				{

 					mtCOVERAGE_TEST_MARKER();

 				}

+				xTimeoutOccurred = pdTRUE;

 			}

 			taskEXIT_CRITICAL();

-

-			/* Prevent compiler warnings when trace macros are not used. */

-			xTimeoutOccurred = pdFALSE;

 		}

 		else

 		{

@@ -415,13 +451,16 @@ BaseType_t xTimeoutOccurred = pdFALSE;
 	}

 	traceEVENT_GROUP_WAIT_BITS_END( xEventGroup, uxBitsToWaitFor, xTimeoutOccurred );

 

+	/* Prevent compiler warnings when trace macros are not used. */

+	( void ) xTimeoutOccurred;

+

 	return uxReturn;

 }

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

 

 EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear )

 {

-EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;

+EventGroup_t *pxEventBits = xEventGroup;

 EventBits_t uxReturn;

 

 	/* Check the user is not attempting to clear the bits used by the kernel

@@ -453,7 +492,7 @@ EventBits_t uxReturn;
 		BaseType_t xReturn;

 

 		traceEVENT_GROUP_CLEAR_BITS_FROM_ISR( xEventGroup, uxBitsToClear );

-		xReturn = xTimerPendFunctionCallFromISR( vEventGroupClearBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToClear, NULL );

+		xReturn = xTimerPendFunctionCallFromISR( vEventGroupClearBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToClear, NULL ); /*lint !e9087 Can't avoid cast to void* as a generic callback function not specific to this use case. Callback casts back to original type so safe. */

 

 		return xReturn;

 	}

@@ -464,7 +503,7 @@ EventBits_t uxReturn;
 EventBits_t xEventGroupGetBitsFromISR( EventGroupHandle_t xEventGroup )

 {

 UBaseType_t uxSavedInterruptStatus;

-EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;

+EventGroup_t const * const pxEventBits = xEventGroup;

 EventBits_t uxReturn;

 

 	uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();

@@ -474,16 +513,16 @@ EventBits_t uxReturn;
 	portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );

 

 	return uxReturn;

-}

+} /*lint !e818 EventGroupHandle_t is a typedef used in other functions to so can't be pointer to const. */

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

 

 EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet )

 {

 ListItem_t *pxListItem, *pxNext;

 ListItem_t const *pxListEnd;

-List_t *pxList;

+List_t const * pxList;

 EventBits_t uxBitsToClear = 0, uxBitsWaitedFor, uxControlBits;

-EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;

+EventGroup_t *pxEventBits = xEventGroup;

 BaseType_t xMatchFound = pdFALSE;

 

 	/* Check the user is not attempting to set the bits used by the kernel

@@ -492,7 +531,7 @@ BaseType_t xMatchFound = pdFALSE;
 	configASSERT( ( uxBitsToSet & eventEVENT_BITS_CONTROL_BYTES ) == 0 );

 

 	pxList = &( pxEventBits->xTasksWaitingForBits );

-	pxListEnd = listGET_END_MARKER( pxList ); /*lint !e826 !e740 The mini list structure is used as the list end to save RAM.  This is checked and valid. */

+	pxListEnd = listGET_END_MARKER( pxList ); /*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM.  This is checked and valid. */

 	vTaskSuspendAll();

 	{

 		traceEVENT_GROUP_SET_BITS( xEventGroup, uxBitsToSet );

@@ -552,7 +591,7 @@ BaseType_t xMatchFound = pdFALSE;
 				eventUNBLOCKED_DUE_TO_BIT_SET bit is set so the task knows

 				that is was unblocked due to its required bits matching, rather

 				than because it timed out. */

-				( void ) xTaskRemoveFromUnorderedEventList( pxListItem, pxEventBits->uxEventBits | eventUNBLOCKED_DUE_TO_BIT_SET );

+				vTaskRemoveFromUnorderedEventList( pxListItem, pxEventBits->uxEventBits | eventUNBLOCKED_DUE_TO_BIT_SET );

 			}

 

 			/* Move onto the next list item.  Note pxListItem->pxNext is not

@@ -573,7 +612,7 @@ BaseType_t xMatchFound = pdFALSE;
 

 void vEventGroupDelete( EventGroupHandle_t xEventGroup )

 {

-EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;

+EventGroup_t *pxEventBits = xEventGroup;

 const List_t *pxTasksWaitingForBits = &( pxEventBits->xTasksWaitingForBits );

 

 	vTaskSuspendAll();

@@ -583,12 +622,31 @@ const List_t *pxTasksWaitingForBits = &( pxEventBits->xTasksWaitingForBits );
 		while( listCURRENT_LIST_LENGTH( pxTasksWaitingForBits ) > ( UBaseType_t ) 0 )

 		{

 			/* Unblock the task, returning 0 as the event list is being deleted

-			and	cannot therefore have any bits set. */

-			configASSERT( pxTasksWaitingForBits->xListEnd.pxNext != ( ListItem_t * ) &( pxTasksWaitingForBits->xListEnd ) );

-			( void ) xTaskRemoveFromUnorderedEventList( pxTasksWaitingForBits->xListEnd.pxNext, eventUNBLOCKED_DUE_TO_BIT_SET );

+			and cannot therefore have any bits set. */

+			configASSERT( pxTasksWaitingForBits->xListEnd.pxNext != ( const ListItem_t * ) &( pxTasksWaitingForBits->xListEnd ) );

+			vTaskRemoveFromUnorderedEventList( pxTasksWaitingForBits->xListEnd.pxNext, eventUNBLOCKED_DUE_TO_BIT_SET );

 		}

 

-		vPortFree( pxEventBits );

+		#if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 0 ) )

+		{

+			/* The event group can only have been allocated dynamically - free

+			it again. */

+			vPortFree( pxEventBits );

+		}

+		#elif( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )

+		{

+			/* The event group could have been allocated statically or

+			dynamically, so check before attempting to free the memory. */

+			if( pxEventBits->ucStaticallyAllocated == ( uint8_t ) pdFALSE )

+			{

+				vPortFree( pxEventBits );

+			}

+			else

+			{

+				mtCOVERAGE_TEST_MARKER();

+			}

+		}

+		#endif /* configSUPPORT_DYNAMIC_ALLOCATION */

 	}

 	( void ) xTaskResumeAll();

 }

@@ -598,7 +656,7 @@ const List_t *pxTasksWaitingForBits = &( pxEventBits->xTasksWaitingForBits );
 an interrupt. */

 void vEventGroupSetBitsCallback( void *pvEventGroup, const uint32_t ulBitsToSet )

 {

-	( void ) xEventGroupSetBits( pvEventGroup, ( EventBits_t ) ulBitsToSet );

+	( void ) xEventGroupSetBits( pvEventGroup, ( EventBits_t ) ulBitsToSet ); /*lint !e9079 Can't avoid cast to void* as a generic timer callback prototype. Callback casts back to original type so safe. */

 }

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

 

@@ -606,7 +664,7 @@ void vEventGroupSetBitsCallback( void *pvEventGroup, const uint32_t ulBitsToSet
 an interrupt. */

 void vEventGroupClearBitsCallback( void *pvEventGroup, const uint32_t ulBitsToClear )

 {

-	( void ) xEventGroupClearBits( pvEventGroup, ( EventBits_t ) ulBitsToClear );

+	( void ) xEventGroupClearBits( pvEventGroup, ( EventBits_t ) ulBitsToClear ); /*lint !e9079 Can't avoid cast to void* as a generic timer callback prototype. Callback casts back to original type so safe. */

 }

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

 

@@ -652,7 +710,7 @@ BaseType_t xWaitConditionMet = pdFALSE;
 	BaseType_t xReturn;

 

 		traceEVENT_GROUP_SET_BITS_FROM_ISR( xEventGroup, uxBitsToSet );

-		xReturn = xTimerPendFunctionCallFromISR( vEventGroupSetBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToSet, pxHigherPriorityTaskWoken );

+		xReturn = xTimerPendFunctionCallFromISR( vEventGroupSetBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToSet, pxHigherPriorityTaskWoken ); /*lint !e9087 Can't avoid cast to void* as a generic callback function not specific to this use case. Callback casts back to original type so safe. */

 

 		return xReturn;

 	}

@@ -665,7 +723,7 @@ BaseType_t xWaitConditionMet = pdFALSE;
 	UBaseType_t uxEventGroupGetNumber( void* xEventGroup )

 	{

 	UBaseType_t xReturn;

-	EventGroup_t *pxEventBits = ( EventGroup_t * ) xEventGroup;

+	EventGroup_t const *pxEventBits = ( EventGroup_t * ) xEventGroup; /*lint !e9087 !e9079 EventGroupHandle_t is a pointer to an EventGroup_t, but EventGroupHandle_t is kept opaque outside of this file for data hiding purposes. */

 

 		if( xEventGroup == NULL )

 		{

@@ -679,5 +737,17 @@ BaseType_t xWaitConditionMet = pdFALSE;
 		return xReturn;

 	}

 

-#endif

+#endif /* configUSE_TRACE_FACILITY */

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

+

+#if ( configUSE_TRACE_FACILITY == 1 )

+

+	void vEventGroupSetNumber( void * xEventGroup, UBaseType_t uxEventGroupNumber )

+	{

+		( ( EventGroup_t * ) xEventGroup )->uxEventGroupNumber = uxEventGroupNumber; /*lint !e9087 !e9079 EventGroupHandle_t is a pointer to an EventGroup_t, but EventGroupHandle_t is kept opaque outside of this file for data hiding purposes. */

+	}

+

+#endif /* configUSE_TRACE_FACILITY */

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

+

 

diff --git a/src/FreeRTOS/Source/include/FreeRTOS.h b/src/FreeRTOS/Source/include/FreeRTOS.h
index 7d34ec6..3afd3bb 100644
--- a/src/FreeRTOS/Source/include/FreeRTOS.h
+++ b/src/FreeRTOS/Source/include/FreeRTOS.h
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 #ifndef INC_FREERTOS_H

 #define INC_FREERTOS_H

@@ -103,6 +61,15 @@ extern "C" {
 /* Definitions specific to the port being used. */

 #include "portable.h"

 

+/* Must be defaulted before configUSE_NEWLIB_REENTRANT is used below. */

+#ifndef configUSE_NEWLIB_REENTRANT

+	#define configUSE_NEWLIB_REENTRANT 0

+#endif

+

+/* Required if struct _reent is used. */

+#if ( configUSE_NEWLIB_REENTRANT == 1 )

+	#include <reent.h>

+#endif

 /*

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

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

@@ -117,6 +84,10 @@ extern "C" {
 	#error Missing definition:  configMAX_PRIORITIES must be defined in FreeRTOSConfig.h.  See the Configuration section of the FreeRTOS API documentation for details.

 #endif

 

+#if configMAX_PRIORITIES < 1

+	#error configMAX_PRIORITIES must be defined to be greater than or equal to 1.

+#endif

+

 #ifndef configUSE_PREEMPTION

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

 #endif

@@ -129,82 +100,102 @@ extern "C" {
 	#error Missing definition:  configUSE_TICK_HOOK must 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 must 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

+	#define configUSE_CO_ROUTINES 0

+#endif

+

 #ifndef INCLUDE_vTaskPrioritySet

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

+	#define INCLUDE_vTaskPrioritySet 0

 #endif

 

 #ifndef INCLUDE_uxTaskPriorityGet

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

+	#define INCLUDE_uxTaskPriorityGet 0

 #endif

 

 #ifndef INCLUDE_vTaskDelete

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

+	#define INCLUDE_vTaskDelete 0

 #endif

 

 #ifndef INCLUDE_vTaskSuspend

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

+	#define INCLUDE_vTaskSuspend 0

 #endif

 

 #ifndef INCLUDE_vTaskDelayUntil

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

+	#define INCLUDE_vTaskDelayUntil 0

 #endif

 

 #ifndef INCLUDE_vTaskDelay

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

+	#define INCLUDE_vTaskDelay 0

 #endif

 

-#ifndef configUSE_16_BIT_TICKS

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

+#ifndef INCLUDE_xTaskGetIdleTaskHandle

+	#define INCLUDE_xTaskGetIdleTaskHandle 0

 #endif

 

-#ifndef configMAX_PRIORITIES

-	#error configMAX_PRIORITIES must be defined to be greater than or equal to 1.

+#ifndef INCLUDE_xTaskAbortDelay

+	#define INCLUDE_xTaskAbortDelay 0

 #endif

 

-#ifndef configUSE_CO_ROUTINES

-	#define configUSE_CO_ROUTINES 0

+#ifndef INCLUDE_xQueueGetMutexHolder

+	#define INCLUDE_xQueueGetMutexHolder 0

 #endif

 

-#if configUSE_CO_ROUTINES != 0

-	#ifndef configMAX_CO_ROUTINE_PRIORITIES

-		#error configMAX_CO_ROUTINE_PRIORITIES must be greater than or equal to 1.

-	#endif

+#ifndef INCLUDE_xSemaphoreGetMutexHolder

+	#define INCLUDE_xSemaphoreGetMutexHolder INCLUDE_xQueueGetMutexHolder

 #endif

 

-#ifndef INCLUDE_xTaskGetIdleTaskHandle

-	#define INCLUDE_xTaskGetIdleTaskHandle 0

+#ifndef INCLUDE_xTaskGetHandle

+	#define INCLUDE_xTaskGetHandle 0

 #endif

 

-#ifndef INCLUDE_xTimerGetTimerDaemonTaskHandle

-	#define INCLUDE_xTimerGetTimerDaemonTaskHandle 0

+#ifndef INCLUDE_uxTaskGetStackHighWaterMark

+	#define INCLUDE_uxTaskGetStackHighWaterMark 0

 #endif

 

-#ifndef INCLUDE_xQueueGetMutexHolder

-	#define INCLUDE_xQueueGetMutexHolder 0

+#ifndef INCLUDE_uxTaskGetStackHighWaterMark2

+	#define INCLUDE_uxTaskGetStackHighWaterMark2 0

 #endif

 

-#ifndef INCLUDE_xSemaphoreGetMutexHolder

-	#define INCLUDE_xSemaphoreGetMutexHolder INCLUDE_xQueueGetMutexHolder

+#ifndef INCLUDE_eTaskGetState

+	#define INCLUDE_eTaskGetState 0

 #endif

 

-#ifndef INCLUDE_pcTaskGetTaskName

-	#define INCLUDE_pcTaskGetTaskName 0

+#ifndef INCLUDE_xTaskResumeFromISR

+	#define INCLUDE_xTaskResumeFromISR 1

 #endif

 

-#ifndef configUSE_APPLICATION_TASK_TAG

-	#define configUSE_APPLICATION_TASK_TAG 0

+#ifndef INCLUDE_xTimerPendFunctionCall

+	#define INCLUDE_xTimerPendFunctionCall 0

 #endif

 

-#ifndef configNUM_THREAD_LOCAL_STORAGE_POINTERS

-	#define configNUM_THREAD_LOCAL_STORAGE_POINTERS 0

+#ifndef INCLUDE_xTaskGetSchedulerState

+	#define INCLUDE_xTaskGetSchedulerState 0

 #endif

 

-#ifndef INCLUDE_uxTaskGetStackHighWaterMark

-	#define INCLUDE_uxTaskGetStackHighWaterMark 0

+#ifndef INCLUDE_xTaskGetCurrentTaskHandle

+	#define INCLUDE_xTaskGetCurrentTaskHandle 0

 #endif

 

-#ifndef INCLUDE_eTaskGetState

-	#define INCLUDE_eTaskGetState 0

+#if configUSE_CO_ROUTINES != 0

+	#ifndef configMAX_CO_ROUTINE_PRIORITIES

+		#error configMAX_CO_ROUTINE_PRIORITIES must be greater than or equal to 1.

+	#endif

+#endif

+

+#ifndef configUSE_DAEMON_TASK_STARTUP_HOOK

+	#define configUSE_DAEMON_TASK_STARTUP_HOOK 0

+#endif

+

+#ifndef configUSE_APPLICATION_TASK_TAG

+	#define configUSE_APPLICATION_TASK_TAG 0

+#endif

+

+#ifndef configNUM_THREAD_LOCAL_STORAGE_POINTERS

+	#define configNUM_THREAD_LOCAL_STORAGE_POINTERS 0

 #endif

 

 #ifndef configUSE_RECURSIVE_MUTEXES

@@ -243,18 +234,6 @@ extern "C" {
 	#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 INCLUDE_xEventGroupSetBitFromISR

-	#define INCLUDE_xEventGroupSetBitFromISR 0

-#endif

-

-#ifndef INCLUDE_xTimerPendFunctionCall

-	#define INCLUDE_xTimerPendFunctionCall 0

-#endif

-

 #ifndef configASSERT

 	#define configASSERT( x )

 	#define configASSERT_DEFINED 0

@@ -279,15 +258,6 @@ extern "C" {
 

 #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

@@ -315,6 +285,7 @@ extern "C" {
 #if ( configQUEUE_REGISTRY_SIZE < 1 )

 	#define vQueueAddToRegistry( xQueue, pcName )

 	#define vQueueUnregisterQueue( xQueue )

+	#define pcQueueGetName( xQueue )

 #endif

 

 #ifndef portPOINTER_SIZE_TYPE

@@ -387,6 +358,14 @@ extern "C" {
 	#define traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue )

 #endif

 

+#ifndef traceBLOCKING_ON_QUEUE_PEEK

+	/* 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_PEEK( 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

@@ -399,12 +378,24 @@ extern "C" {
 	#define configCHECK_FOR_STACK_OVERFLOW 0

 #endif

 

+#ifndef configRECORD_STACK_HIGH_ADDRESS

+	#define configRECORD_STACK_HIGH_ADDRESS 0

+#endif

+

+#ifndef configINCLUDE_FREERTOS_TASK_C_ADDITIONS_H

+	#define configINCLUDE_FREERTOS_TASK_C_ADDITIONS_H 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 tracePOST_MOVED_TASK_TO_READY_STATE

+	#define tracePOST_MOVED_TASK_TO_READY_STATE( pxTCB )

+#endif

+

 #ifndef traceQUEUE_CREATE

 	#define traceQUEUE_CREATE( pxNewQueue )

 #endif

@@ -461,6 +452,10 @@ extern "C" {
 	#define traceQUEUE_PEEK( pxQueue )

 #endif

 

+#ifndef traceQUEUE_PEEK_FAILED

+	#define traceQUEUE_PEEK_FAILED( pxQueue )

+#endif

+

 #ifndef traceQUEUE_PEEK_FROM_ISR

 	#define traceQUEUE_PEEK_FROM_ISR( pxQueue )

 #endif

@@ -506,7 +501,7 @@ extern "C" {
 #endif

 

 #ifndef traceTASK_DELAY_UNTIL

-	#define traceTASK_DELAY_UNTIL()

+	#define traceTASK_DELAY_UNTIL( x )

 #endif

 

 #ifndef traceTASK_DELAY

@@ -645,6 +640,58 @@ extern "C" {
 	#define traceTASK_NOTIFY_GIVE_FROM_ISR()

 #endif

 

+#ifndef traceSTREAM_BUFFER_CREATE_FAILED

+	#define traceSTREAM_BUFFER_CREATE_FAILED( xIsMessageBuffer )

+#endif

+

+#ifndef traceSTREAM_BUFFER_CREATE_STATIC_FAILED

+	#define traceSTREAM_BUFFER_CREATE_STATIC_FAILED( xReturn, xIsMessageBuffer )

+#endif

+

+#ifndef traceSTREAM_BUFFER_CREATE

+	#define traceSTREAM_BUFFER_CREATE( pxStreamBuffer, xIsMessageBuffer )

+#endif

+

+#ifndef traceSTREAM_BUFFER_DELETE

+	#define traceSTREAM_BUFFER_DELETE( xStreamBuffer )

+#endif

+

+#ifndef traceSTREAM_BUFFER_RESET

+	#define traceSTREAM_BUFFER_RESET( xStreamBuffer )

+#endif

+

+#ifndef traceBLOCKING_ON_STREAM_BUFFER_SEND

+	#define traceBLOCKING_ON_STREAM_BUFFER_SEND( xStreamBuffer )

+#endif

+

+#ifndef traceSTREAM_BUFFER_SEND

+	#define traceSTREAM_BUFFER_SEND( xStreamBuffer, xBytesSent )

+#endif

+

+#ifndef traceSTREAM_BUFFER_SEND_FAILED

+	#define traceSTREAM_BUFFER_SEND_FAILED( xStreamBuffer )

+#endif

+

+#ifndef traceSTREAM_BUFFER_SEND_FROM_ISR

+	#define traceSTREAM_BUFFER_SEND_FROM_ISR( xStreamBuffer, xBytesSent )

+#endif

+

+#ifndef traceBLOCKING_ON_STREAM_BUFFER_RECEIVE

+	#define traceBLOCKING_ON_STREAM_BUFFER_RECEIVE( xStreamBuffer )

+#endif

+

+#ifndef traceSTREAM_BUFFER_RECEIVE

+	#define traceSTREAM_BUFFER_RECEIVE( xStreamBuffer, xReceivedLength )

+#endif

+

+#ifndef traceSTREAM_BUFFER_RECEIVE_FAILED

+	#define traceSTREAM_BUFFER_RECEIVE_FAILED( xStreamBuffer )

+#endif

+

+#ifndef traceSTREAM_BUFFER_RECEIVE_FROM_ISR

+	#define traceSTREAM_BUFFER_RECEIVE_FROM_ISR( xStreamBuffer, xReceivedLength )

+#endif

+

 #ifndef configGENERATE_RUN_TIME_STATS

 	#define configGENERATE_RUN_TIME_STATS 0

 #endif

@@ -679,14 +726,6 @@ extern "C" {
 	#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

-

 #ifndef portSUPPRESS_TICKS_AND_SLEEP

 	#define portSUPPRESS_TICKS_AND_SLEEP( xExpectedIdleTime )

 #endif

@@ -703,6 +742,10 @@ extern "C" {
 	#define configUSE_TICKLESS_IDLE 0

 #endif

 

+#ifndef configPRE_SUPPRESS_TICKS_AND_SLEEP_PROCESSING

+	#define configPRE_SUPPRESS_TICKS_AND_SLEEP_PROCESSING( x )

+#endif

+

 #ifndef configPRE_SLEEP_PROCESSING

 	#define configPRE_SLEEP_PROCESSING( x )

 #endif

@@ -719,6 +762,14 @@ extern "C" {
 	#define portTASK_USES_FLOATING_POINT()

 #endif

 

+#ifndef portALLOCATE_SECURE_CONTEXT

+	#define portALLOCATE_SECURE_CONTEXT( ulSecureStackSize )

+#endif

+

+#ifndef portHAS_STACK_OVERFLOW_CHECKING

+	#define portHAS_STACK_OVERFLOW_CHECKING 0

+#endif

+

 #ifndef configUSE_TIME_SLICING

 	#define configUSE_TIME_SLICING 1

 #endif

@@ -727,10 +778,6 @@ extern "C" {
 	#define configINCLUDE_APPLICATION_DEFINED_PRIVILEGED_FUNCTIONS 0

 #endif

 

-#ifndef configUSE_NEWLIB_REENTRANT

-	#define configUSE_NEWLIB_REENTRANT 0

-#endif

-

 #ifndef configUSE_STATS_FORMATTING_FUNCTIONS

 	#define configUSE_STATS_FORMATTING_FUNCTIONS 0

 #endif

@@ -767,10 +814,56 @@ extern "C" {
 	#define configUSE_TASK_NOTIFICATIONS 1

 #endif

 

+#ifndef configUSE_POSIX_ERRNO

+	#define configUSE_POSIX_ERRNO 0

+#endif

+

 #ifndef portTICK_TYPE_IS_ATOMIC

 	#define portTICK_TYPE_IS_ATOMIC 0

 #endif

 

+#ifndef configSUPPORT_STATIC_ALLOCATION

+	/* Defaults to 0 for backward compatibility. */

+	#define configSUPPORT_STATIC_ALLOCATION 0

+#endif

+

+#ifndef configSUPPORT_DYNAMIC_ALLOCATION

+	/* Defaults to 1 for backward compatibility. */

+	#define configSUPPORT_DYNAMIC_ALLOCATION 1

+#endif

+

+#ifndef configSTACK_DEPTH_TYPE

+	/* Defaults to uint16_t for backward compatibility, but can be overridden

+	in FreeRTOSConfig.h if uint16_t is too restrictive. */

+	#define configSTACK_DEPTH_TYPE uint16_t

+#endif

+

+#ifndef configMESSAGE_BUFFER_LENGTH_TYPE

+	/* Defaults to size_t for backward compatibility, but can be overridden

+	in FreeRTOSConfig.h if lengths will always be less than the number of bytes

+	in a size_t. */

+	#define configMESSAGE_BUFFER_LENGTH_TYPE size_t

+#endif

+

+/* Sanity check the configuration. */

+#if( configUSE_TICKLESS_IDLE != 0 )

+	#if( INCLUDE_vTaskSuspend != 1 )

+		#error INCLUDE_vTaskSuspend must be set to 1 if configUSE_TICKLESS_IDLE is not set to 0

+	#endif /* INCLUDE_vTaskSuspend */

+#endif /* configUSE_TICKLESS_IDLE */

+

+#if( ( configSUPPORT_STATIC_ALLOCATION == 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 0 ) )

+	#error configSUPPORT_STATIC_ALLOCATION and configSUPPORT_DYNAMIC_ALLOCATION cannot both be 0, but can both be 1.

+#endif

+

+#if( ( configUSE_RECURSIVE_MUTEXES == 1 ) && ( configUSE_MUTEXES != 1 ) )

+	#error configUSE_MUTEXES must be set to 1 to use recursive mutexes

+#endif

+

+#ifndef configINITIAL_TICK_COUNT

+	#define configINITIAL_TICK_COUNT 0

+#endif

+

 #if( portTICK_TYPE_IS_ATOMIC == 0 )

 	/* Either variables of tick type cannot be read atomically, or

 	portTICK_TYPE_IS_ATOMIC was not set - map the critical sections used when

@@ -794,6 +887,32 @@ V8 if desired. */
 	#define configENABLE_BACKWARD_COMPATIBILITY 1

 #endif

 

+#ifndef configPRINTF

+	/* configPRINTF() was not defined, so define it away to nothing.  To use

+	configPRINTF() then define it as follows (where MyPrintFunction() is

+	provided by the application writer):

+

+	void MyPrintFunction(const char *pcFormat, ... );

+	#define configPRINTF( X )   MyPrintFunction X

+

+	Then call like a standard printf() function, but placing brackets around

+	all parameters so they are passed as a single parameter.  For example:

+	configPRINTF( ("Value = %d", MyVariable) ); */

+	#define configPRINTF( X )

+#endif

+

+#ifndef configMAX

+	/* The application writer has not provided their own MAX macro, so define

+	the following generic implementation. */

+	#define configMAX( a, b ) ( ( ( a ) > ( b ) ) ? ( a ) : ( b ) )

+#endif

+

+#ifndef configMIN

+	/* The application writer has not provided their own MAX macro, so define

+	the following generic implementation. */

+	#define configMIN( a, b ) ( ( ( a ) < ( b ) ) ? ( a ) : ( b ) )

+#endif

+

 #if configENABLE_BACKWARD_COMPATIBILITY == 1

 	#define eTaskStateGet eTaskGetState

 	#define portTickType TickType_t

@@ -810,6 +929,10 @@ V8 if desired. */
 	#define xCoRoutineHandle CoRoutineHandle_t

 	#define pdTASK_HOOK_CODE TaskHookFunction_t

 	#define portTICK_RATE_MS portTICK_PERIOD_MS

+	#define pcTaskGetTaskName pcTaskGetName

+	#define pcTimerGetTimerName pcTimerGetName

+	#define pcQueueGetQueueName pcQueueGetName

+	#define vTaskGetTaskInfo vTaskGetInfo

 

 	/* Backward compatibility within the scheduler code only - these definitions

 	are not really required but are included for completeness. */

@@ -817,16 +940,332 @@ V8 if desired. */
 	#define pdTASK_CODE TaskFunction_t

 	#define xListItem ListItem_t

 	#define xList List_t

+

+	/* For libraries that break the list data hiding, and access list structure

+	members directly (which is not supposed to be done). */

+	#define pxContainer pvContainer

 #endif /* configENABLE_BACKWARD_COMPATIBILITY */

 

+#if( configUSE_ALTERNATIVE_API != 0 )

+	#error The alternative API was deprecated some time ago, and was removed in FreeRTOS V9.0 0

+#endif

+

 /* Set configUSE_TASK_FPU_SUPPORT to 0 to omit floating point support even

 if floating point hardware is otherwise supported by the FreeRTOS port in use.

-This constant is not supported by all FreeRTOS ports that include floating 

+This constant is not supported by all FreeRTOS ports that include floating

 point support. */

 #ifndef configUSE_TASK_FPU_SUPPORT

 	#define configUSE_TASK_FPU_SUPPORT 1

 #endif

 

+/* Set configENABLE_MPU to 1 to enable MPU support and 0 to disable it. This is

+currently used in ARMv8M ports. */

+#ifndef configENABLE_MPU

+	#define configENABLE_MPU 0

+#endif

+

+/* Set configENABLE_FPU to 1 to enable FPU support and 0 to disable it. This is

+currently used in ARMv8M ports. */

+#ifndef configENABLE_FPU

+	#define configENABLE_FPU 1

+#endif

+

+/* Set configENABLE_TRUSTZONE to 1 enable TrustZone support and 0 to disable it.

+This is currently used in ARMv8M ports. */

+#ifndef configENABLE_TRUSTZONE

+	#define configENABLE_TRUSTZONE 1

+#endif

+

+/* Set configRUN_FREERTOS_SECURE_ONLY to 1 to run the FreeRTOS ARMv8M port on

+the Secure Side only. */

+#ifndef configRUN_FREERTOS_SECURE_ONLY

+	#define configRUN_FREERTOS_SECURE_ONLY 0

+#endif

+

+/* Sometimes the FreeRTOSConfig.h settings only allow a task to be created using

+ * dynamically allocated RAM, in which case when any task is deleted it is known

+ * that both the task's stack and TCB need to be freed.  Sometimes the

+ * FreeRTOSConfig.h settings only allow a task to be created using statically

+ * allocated RAM, in which case when any task is deleted it is known that neither

+ * the task's stack or TCB should be freed.  Sometimes the FreeRTOSConfig.h

+ * settings allow a task to be created using either statically or dynamically

+ * allocated RAM, in which case a member of the TCB is used to record whether the

+ * stack and/or TCB were allocated statically or dynamically, so when a task is

+ * deleted the RAM that was allocated dynamically is freed again and no attempt is

+ * made to free the RAM that was allocated statically.

+ * tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE is only true if it is possible for a

+ * task to be created using either statically or dynamically allocated RAM.  Note

+ * that if portUSING_MPU_WRAPPERS is 1 then a protected task can be created with

+ * a statically allocated stack and a dynamically allocated TCB.

+ *

+ * The following table lists various combinations of portUSING_MPU_WRAPPERS,

+ * configSUPPORT_DYNAMIC_ALLOCATION and configSUPPORT_STATIC_ALLOCATION and

+ * when it is possible to have both static and dynamic allocation:

+ *  +-----+---------+--------+-----------------------------+-----------------------------------+------------------+-----------+

+ * | MPU | Dynamic | Static |     Available Functions     |       Possible Allocations        | Both Dynamic and | Need Free |

+ * |     |         |        |                             |                                   | Static Possible  |           |

+ * +-----+---------+--------+-----------------------------+-----------------------------------+------------------+-----------+

+ * | 0   | 0       | 1      | xTaskCreateStatic           | TCB - Static, Stack - Static      | No               | No        |

+ * +-----|---------|--------|-----------------------------|-----------------------------------|------------------|-----------|

+ * | 0   | 1       | 0      | xTaskCreate                 | TCB - Dynamic, Stack - Dynamic    | No               | Yes       |

+ * +-----|---------|--------|-----------------------------|-----------------------------------|------------------|-----------|

+ * | 0   | 1       | 1      | xTaskCreate,                | 1. TCB - Dynamic, Stack - Dynamic | Yes              | Yes       |

+ * |     |         |        | xTaskCreateStatic           | 2. TCB - Static, Stack - Static   |                  |           |

+ * +-----|---------|--------|-----------------------------|-----------------------------------|------------------|-----------|

+ * | 1   | 0       | 1      | xTaskCreateStatic,          | TCB - Static, Stack - Static      | No               | No        |

+ * |     |         |        | xTaskCreateRestrictedStatic |                                   |                  |           |

+ * +-----|---------|--------|-----------------------------|-----------------------------------|------------------|-----------|

+ * | 1   | 1       | 0      | xTaskCreate,                | 1. TCB - Dynamic, Stack - Dynamic | Yes              | Yes       |

+ * |     |         |        | xTaskCreateRestricted       | 2. TCB - Dynamic, Stack - Static  |                  |           |

+ * +-----|---------|--------|-----------------------------|-----------------------------------|------------------|-----------|

+ * | 1   | 1       | 1      | xTaskCreate,                | 1. TCB - Dynamic, Stack - Dynamic | Yes              | Yes       |

+ * |     |         |        | xTaskCreateStatic,          | 2. TCB - Dynamic, Stack - Static  |                  |           |

+ * |     |         |        | xTaskCreateRestricted,      | 3. TCB - Static, Stack - Static   |                  |           |

+ * |     |         |        | xTaskCreateRestrictedStatic |                                   |                  |           |

+ * +-----+---------+--------+-----------------------------+-----------------------------------+------------------+-----------+

+ */

+#define tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE	( ( ( portUSING_MPU_WRAPPERS == 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) || \

+													  ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) )

+

+/*

+ * In line with software engineering best practice, FreeRTOS implements a strict

+ * data hiding policy, so the real structures used by FreeRTOS to maintain the

+ * state of tasks, queues, semaphores, etc. are not accessible to the application

+ * code.  However, if the application writer wants to statically allocate such

+ * an object then the size of the object needs to be know.  Dummy structures

+ * that are guaranteed to have the same size and alignment requirements of the

+ * real objects are used for this purpose.  The dummy list and list item

+ * structures below are used for inclusion in such a dummy structure.

+ */

+struct xSTATIC_LIST_ITEM

+{

+	#if( configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 1 )

+		TickType_t xDummy1;

+	#endif

+	TickType_t xDummy2;

+	void *pvDummy3[ 4 ];

+	#if( configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 1 )

+		TickType_t xDummy4;

+	#endif

+};

+typedef struct xSTATIC_LIST_ITEM StaticListItem_t;

+

+/* See the comments above the struct xSTATIC_LIST_ITEM definition. */

+struct xSTATIC_MINI_LIST_ITEM

+{

+	#if( configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 1 )

+		TickType_t xDummy1;

+	#endif

+	TickType_t xDummy2;

+	void *pvDummy3[ 2 ];

+};

+typedef struct xSTATIC_MINI_LIST_ITEM StaticMiniListItem_t;

+

+/* See the comments above the struct xSTATIC_LIST_ITEM definition. */

+typedef struct xSTATIC_LIST

+{

+	#if( configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 1 )

+		TickType_t xDummy1;

+	#endif

+	UBaseType_t uxDummy2;

+	void *pvDummy3;

+	StaticMiniListItem_t xDummy4;

+	#if( configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES == 1 )

+		TickType_t xDummy5;

+	#endif

+} StaticList_t;

+

+/*

+ * In line with software engineering best practice, especially when supplying a

+ * library that is likely to change in future versions, FreeRTOS implements a

+ * strict data hiding policy.  This means the Task structure used internally by

+ * FreeRTOS is not accessible to application code.  However, if the application

+ * writer wants to statically allocate the memory required to create a task then

+ * the size of the task object needs to be know.  The StaticTask_t structure

+ * below is provided for this purpose.  Its sizes and alignment requirements are

+ * guaranteed to match those of the genuine structure, no matter which

+ * architecture is being used, and no matter how the values in FreeRTOSConfig.h

+ * are set.  Its contents are somewhat obfuscated in the hope users will

+ * recognise that it would be unwise to make direct use of the structure members.

+ */

+typedef struct xSTATIC_TCB

+{

+	void				*pxDummy1;

+	#if ( portUSING_MPU_WRAPPERS == 1 )

+		xMPU_SETTINGS	xDummy2;

+	#endif

+	StaticListItem_t	xDummy3[ 2 ];

+	UBaseType_t			uxDummy5;

+	void				*pxDummy6;

+	uint8_t				ucDummy7[ configMAX_TASK_NAME_LEN ];

+	#if ( ( portSTACK_GROWTH > 0 ) || ( configRECORD_STACK_HIGH_ADDRESS == 1 ) )

+		void			*pxDummy8;

+	#endif

+	#if ( portCRITICAL_NESTING_IN_TCB == 1 )

+		UBaseType_t		uxDummy9;

+	#endif

+	#if ( configUSE_TRACE_FACILITY == 1 )

+		UBaseType_t		uxDummy10[ 2 ];

+	#endif

+	#if ( configUSE_MUTEXES == 1 )

+		UBaseType_t		uxDummy12[ 2 ];

+	#endif

+	#if ( configUSE_APPLICATION_TASK_TAG == 1 )

+		void			*pxDummy14;

+	#endif

+	#if( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )

+		void			*pvDummy15[ configNUM_THREAD_LOCAL_STORAGE_POINTERS ];

+	#endif

+	#if ( configGENERATE_RUN_TIME_STATS == 1 )

+		uint32_t		ulDummy16;

+	#endif

+	#if ( configUSE_NEWLIB_REENTRANT == 1 )

+		struct	_reent	xDummy17;

+	#endif

+	#if ( configUSE_TASK_NOTIFICATIONS == 1 )

+		uint32_t 		ulDummy18;

+		uint8_t 		ucDummy19;

+	#endif

+	#if ( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 )

+		uint8_t			uxDummy20;

+	#endif

+

+	#if( INCLUDE_xTaskAbortDelay == 1 )

+		uint8_t ucDummy21;

+	#endif

+	#if ( configUSE_POSIX_ERRNO == 1 )

+		int				iDummy22;

+	#endif

+} StaticTask_t;

+

+/*

+ * In line with software engineering best practice, especially when supplying a

+ * library that is likely to change in future versions, FreeRTOS implements a

+ * strict data hiding policy.  This means the Queue structure used internally by

+ * FreeRTOS is not accessible to application code.  However, if the application

+ * writer wants to statically allocate the memory required to create a queue

+ * then the size of the queue object needs to be know.  The StaticQueue_t

+ * structure below is provided for this purpose.  Its sizes and alignment

+ * requirements are guaranteed to match those of the genuine structure, no

+ * matter which architecture is being used, and no matter how the values in

+ * FreeRTOSConfig.h are set.  Its contents are somewhat obfuscated in the hope

+ * users will recognise that it would be unwise to make direct use of the

+ * structure members.

+ */

+typedef struct xSTATIC_QUEUE

+{

+	void *pvDummy1[ 3 ];

+

+	union

+	{

+		void *pvDummy2;

+		UBaseType_t uxDummy2;

+	} u;

+

+	StaticList_t xDummy3[ 2 ];

+	UBaseType_t uxDummy4[ 3 ];

+	uint8_t ucDummy5[ 2 ];

+

+	#if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )

+		uint8_t ucDummy6;

+	#endif

+

+	#if ( configUSE_QUEUE_SETS == 1 )

+		void *pvDummy7;

+	#endif

+

+	#if ( configUSE_TRACE_FACILITY == 1 )

+		UBaseType_t uxDummy8;

+		uint8_t ucDummy9;

+	#endif

+

+} StaticQueue_t;

+typedef StaticQueue_t StaticSemaphore_t;

+

+/*

+ * In line with software engineering best practice, especially when supplying a

+ * library that is likely to change in future versions, FreeRTOS implements a

+ * strict data hiding policy.  This means the event group structure used

+ * internally by FreeRTOS is not accessible to application code.  However, if

+ * the application writer wants to statically allocate the memory required to

+ * create an event group then the size of the event group object needs to be

+ * know.  The StaticEventGroup_t structure below is provided for this purpose.

+ * Its sizes and alignment requirements are guaranteed to match those of the

+ * genuine structure, no matter which architecture is being used, and no matter

+ * how the values in FreeRTOSConfig.h are set.  Its contents are somewhat

+ * obfuscated in the hope users will recognise that it would be unwise to make

+ * direct use of the structure members.

+ */

+typedef struct xSTATIC_EVENT_GROUP

+{

+	TickType_t xDummy1;

+	StaticList_t xDummy2;

+

+	#if( configUSE_TRACE_FACILITY == 1 )

+		UBaseType_t uxDummy3;

+	#endif

+

+	#if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )

+			uint8_t ucDummy4;

+	#endif

+

+} StaticEventGroup_t;

+

+/*

+ * In line with software engineering best practice, especially when supplying a

+ * library that is likely to change in future versions, FreeRTOS implements a

+ * strict data hiding policy.  This means the software timer structure used

+ * internally by FreeRTOS is not accessible to application code.  However, if

+ * the application writer wants to statically allocate the memory required to

+ * create a software timer then the size of the queue object needs to be know.

+ * The StaticTimer_t structure below is provided for this purpose.  Its sizes

+ * and alignment requirements are guaranteed to match those of the genuine

+ * structure, no matter which architecture is being used, and no matter how the

+ * values in FreeRTOSConfig.h are set.  Its contents are somewhat obfuscated in

+ * the hope users will recognise that it would be unwise to make direct use of

+ * the structure members.

+ */

+typedef struct xSTATIC_TIMER

+{

+	void				*pvDummy1;

+	StaticListItem_t	xDummy2;

+	TickType_t			xDummy3;

+	void 				*pvDummy5;

+	TaskFunction_t		pvDummy6;

+	#if( configUSE_TRACE_FACILITY == 1 )

+		UBaseType_t		uxDummy7;

+	#endif

+	uint8_t 			ucDummy8;

+

+} StaticTimer_t;

+

+/*

+* In line with software engineering best practice, especially when supplying a

+* library that is likely to change in future versions, FreeRTOS implements a

+* strict data hiding policy.  This means the stream buffer structure used

+* internally by FreeRTOS is not accessible to application code.  However, if

+* the application writer wants to statically allocate the memory required to

+* create a stream buffer then the size of the stream buffer object needs to be

+* know.  The StaticStreamBuffer_t structure below is provided for this purpose.

+* Its size and alignment requirements are guaranteed to match those of the

+* genuine structure, no matter which architecture is being used, and no matter

+* how the values in FreeRTOSConfig.h are set.  Its contents are somewhat

+* obfuscated in the hope users will recognise that it would be unwise to make

+* direct use of the structure members.

+*/

+typedef struct xSTATIC_STREAM_BUFFER

+{

+	size_t uxDummy1[ 4 ];

+	void * pvDummy2[ 3 ];

+	uint8_t ucDummy3;

+	#if ( configUSE_TRACE_FACILITY == 1 )

+		UBaseType_t uxDummy4;

+	#endif

+} StaticStreamBuffer_t;

+

+/* Message buffers are built on stream buffers. */

+typedef StaticStreamBuffer_t StaticMessageBuffer_t;

+

 #ifdef __cplusplus

 }

 #endif

diff --git a/src/FreeRTOS/Source/include/StackMacros.h b/src/FreeRTOS/Source/include/StackMacros.h
index 1359090..a13143d 100644
--- a/src/FreeRTOS/Source/include/StackMacros.h
+++ b/src/FreeRTOS/Source/include/StackMacros.h
@@ -1,75 +1,37 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 #ifndef STACK_MACROS_H

 #define STACK_MACROS_H

 

+#ifndef _MSC_VER /* Visual Studio doesn't support #warning. */

+	#warning The name of this file has changed to stack_macros.h.  Please update your code accordingly.  This source file (which has the original name) will be removed in future released.

+#endif

+

 /*

  * 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

diff --git a/src/FreeRTOS/Source/include/croutine.h b/src/FreeRTOS/Source/include/croutine.h
index dc655ae..6ec8423 100644
--- a/src/FreeRTOS/Source/include/croutine.h
+++ b/src/FreeRTOS/Source/include/croutine.h
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 #ifndef CO_ROUTINE_H

 #define CO_ROUTINE_H

diff --git a/src/FreeRTOS/Source/include/deprecated_definitions.h b/src/FreeRTOS/Source/include/deprecated_definitions.h
index 0fad862..98a593b 100644
--- a/src/FreeRTOS/Source/include/deprecated_definitions.h
+++ b/src/FreeRTOS/Source/include/deprecated_definitions.h
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 #ifndef DEPRECATED_DEFINITIONS_H

 #define DEPRECATED_DEFINITIONS_H

diff --git a/src/FreeRTOS/Source/include/event_groups.h b/src/FreeRTOS/Source/include/event_groups.h
index a381ed0..cfb4288 100644
--- a/src/FreeRTOS/Source/include/event_groups.h
+++ b/src/FreeRTOS/Source/include/event_groups.h
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 #ifndef EVENT_GROUPS_H

 #define EVENT_GROUPS_H

@@ -74,6 +32,7 @@
 	#error "include FreeRTOS.h" must appear in source files before "include event_groups.h"

 #endif

 

+/* FreeRTOS includes. */

 #include "timers.h"

 

 #ifdef __cplusplus

@@ -119,12 +78,13 @@ extern "C" {
  * \defgroup EventGroupHandle_t EventGroupHandle_t

  * \ingroup EventGroup

  */

-typedef void * EventGroupHandle_t;

+struct EventGroupDef_t;

+typedef struct EventGroupDef_t * EventGroupHandle_t;

 

-/* 

+/*

  * The type that holds event bits always matches TickType_t - therefore the

  * number of bits it holds is set by configUSE_16_BIT_TICKS (16 bits if set to 1,

- * 32 bits if set to 0. 

+ * 32 bits if set to 0.

  *

  * \defgroup EventBits_t EventBits_t

  * \ingroup EventGroup

@@ -137,7 +97,17 @@ typedef TickType_t EventBits_t;
  EventGroupHandle_t xEventGroupCreate( void );

  </pre>

  *

- * Create a new event group.  This function cannot be called from an interrupt.

+ * Create a new event group.

+ *

+ * Internally, within the FreeRTOS implementation, event groups use a [small]

+ * block of memory, in which the event group's structure is stored.  If an event

+ * groups is created using xEventGropuCreate() then the required memory is

+ * automatically dynamically allocated inside the xEventGroupCreate() function.

+ * (see http://www.freertos.org/a00111.html).  If an event group is created

+ * using xEventGropuCreateStatic() then the application writer must instead

+ * provide the memory that will get used by the event group.

+ * xEventGroupCreateStatic() therefore allows an event group to be created

+ * without using any dynamic memory allocation.

  *

  * Although event groups are not related to ticks, for internal implementation

  * reasons the number of bits available for use in an event group is dependent

@@ -173,7 +143,62 @@ typedef TickType_t EventBits_t;
  * \defgroup xEventGroupCreate xEventGroupCreate

  * \ingroup EventGroup

  */

-EventGroupHandle_t xEventGroupCreate( void ) PRIVILEGED_FUNCTION;

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

+	EventGroupHandle_t xEventGroupCreate( void ) PRIVILEGED_FUNCTION;

+#endif

+

+/**

+ * event_groups.h

+ *<pre>

+ EventGroupHandle_t xEventGroupCreateStatic( EventGroupHandle_t * pxEventGroupBuffer );

+ </pre>

+ *

+ * Create a new event group.

+ *

+ * Internally, within the FreeRTOS implementation, event groups use a [small]

+ * block of memory, in which the event group's structure is stored.  If an event

+ * groups is created using xEventGropuCreate() then the required memory is

+ * automatically dynamically allocated inside the xEventGroupCreate() function.

+ * (see http://www.freertos.org/a00111.html).  If an event group is created

+ * using xEventGropuCreateStatic() then the application writer must instead

+ * provide the memory that will get used by the event group.

+ * xEventGroupCreateStatic() therefore allows an event group to be created

+ * without using any dynamic memory allocation.

+ *

+ * Although event groups are not related to ticks, for internal implementation

+ * reasons the number of bits available for use in an event group is dependent

+ * on the configUSE_16_BIT_TICKS setting in FreeRTOSConfig.h.  If

+ * configUSE_16_BIT_TICKS is 1 then each event group contains 8 usable bits (bit

+ * 0 to bit 7).  If configUSE_16_BIT_TICKS is set to 0 then each event group has

+ * 24 usable bits (bit 0 to bit 23).  The EventBits_t type is used to store

+ * event bits within an event group.

+ *

+ * @param pxEventGroupBuffer pxEventGroupBuffer must point to a variable of type

+ * StaticEventGroup_t, which will be then be used to hold the event group's data

+ * structures, removing the need for the memory to be allocated dynamically.

+ *

+ * @return If the event group was created then a handle to the event group is

+ * returned.  If pxEventGroupBuffer was NULL then NULL is returned.

+ *

+ * Example usage:

+   <pre>

+	// StaticEventGroup_t is a publicly accessible structure that has the same

+	// size and alignment requirements as the real event group structure.  It is

+	// provided as a mechanism for applications to know the size of the event

+	// group (which is dependent on the architecture and configuration file

+	// settings) without breaking the strict data hiding policy by exposing the

+	// real event group internals.  This StaticEventGroup_t variable is passed

+	// into the xSemaphoreCreateEventGroupStatic() function and is used to store

+	// the event group's data structures

+	StaticEventGroup_t xEventGroupBuffer;

+

+	// Create the event group without dynamically allocating any memory.

+	xEventGroup = xEventGroupCreateStatic( &xEventGroupBuffer );

+   </pre>

+ */

+#if( configSUPPORT_STATIC_ALLOCATION == 1 )

+	EventGroupHandle_t xEventGroupCreateStatic( StaticEventGroup_t *pxEventGroupBuffer ) PRIVILEGED_FUNCTION;

+#endif

 

 /**

  * event_groups.h

@@ -340,8 +365,8 @@ EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBit
  * while interrupts are disabled, so protects event groups that are accessed

  * from tasks by suspending the scheduler rather than disabling interrupts.  As

  * a result event groups cannot be accessed directly from an interrupt service

- * routine.  Therefore xEventGroupClearBitsFromISR() sends a message to the 

- * timer task to have the clear operation performed in the context of the timer 

+ * routine.  Therefore xEventGroupClearBitsFromISR() sends a message to the

+ * timer task to have the clear operation performed in the context of the timer

  * task.

  *

  * @param xEventGroup The event group in which the bits are to be cleared.

@@ -350,8 +375,8 @@ EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBit
  * For example, to clear bit 3 only, set uxBitsToClear to 0x08.  To clear bit 3

  * and bit 0 set uxBitsToClear to 0x09.

  *

- * @return If the request to execute the function was posted successfully then 

- * pdPASS is returned, otherwise pdFALSE is returned.  pdFALSE will be returned 

+ * @return If the request to execute the function was posted successfully then

+ * pdPASS is returned, otherwise pdFALSE is returned.  pdFALSE will be returned

  * if the timer service queue was full.

  *

  * Example usage:

@@ -376,11 +401,11 @@ EventBits_t xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBit
 		}

   }

    </pre>

- * \defgroup xEventGroupSetBitsFromISR xEventGroupSetBitsFromISR

+ * \defgroup xEventGroupClearBitsFromISR xEventGroupClearBitsFromISR

  * \ingroup EventGroup

  */

 #if( configUSE_TRACE_FACILITY == 1 )

-	BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet ) PRIVILEGED_FUNCTION;

+	BaseType_t xEventGroupClearBitsFromISR( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear ) PRIVILEGED_FUNCTION;

 #else

 	#define xEventGroupClearBitsFromISR( xEventGroup, uxBitsToClear ) xTimerPendFunctionCallFromISR( vEventGroupClearBitsCallback, ( void * ) xEventGroup, ( uint32_t ) uxBitsToClear, NULL )

 #endif

@@ -470,7 +495,7 @@ EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_
  * Setting bits in an event group is not a deterministic operation because there

  * are an unknown number of tasks that may be waiting for the bit or bits being

  * set.  FreeRTOS does not allow nondeterministic operations to be performed in

- * interrupts or from critical sections.  Therefore xEventGroupSetBitFromISR()

+ * interrupts or from critical sections.  Therefore xEventGroupSetBitsFromISR()

  * sends a message to the timer task to have the set operation performed in the

  * context of the timer task - where a scheduler lock is used in place of a

  * critical section.

@@ -491,8 +516,8 @@ EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_
  * *pxHigherPriorityTaskWoken must be initialised to pdFALSE.  See the

  * example code below.

  *

- * @return If the request to execute the function was posted successfully then 

- * pdPASS is returned, otherwise pdFALSE is returned.  pdFALSE will be returned 

+ * @return If the request to execute the function was posted successfully then

+ * pdPASS is returned, otherwise pdFALSE is returned.  pdFALSE will be returned

  * if the timer service queue was full.

  *

  * Example usage:

@@ -521,8 +546,8 @@ EventBits_t xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_
 		if( xResult == pdPASS )

 		{

 			// If xHigherPriorityTaskWoken is now set to pdTRUE then a context

-			// switch should be requested.  The macro used is port specific and 

-			// will be either portYIELD_FROM_ISR() or portEND_SWITCHING_ISR() - 

+			// switch should be requested.  The macro used is port specific and

+			// will be either portYIELD_FROM_ISR() or portEND_SWITCHING_ISR() -

 			// refer to the documentation page for the port being used.

 			portYIELD_FROM_ISR( xHigherPriorityTaskWoken );

 		}

@@ -717,8 +742,10 @@ void vEventGroupDelete( EventGroupHandle_t xEventGroup ) PRIVILEGED_FUNCTION;
 void vEventGroupSetBitsCallback( void *pvEventGroup, const uint32_t ulBitsToSet ) PRIVILEGED_FUNCTION;

 void vEventGroupClearBitsCallback( void *pvEventGroup, const uint32_t ulBitsToClear ) PRIVILEGED_FUNCTION;

 

+

 #if (configUSE_TRACE_FACILITY == 1)

 	UBaseType_t uxEventGroupGetNumber( void* xEventGroup ) PRIVILEGED_FUNCTION;

+	void vEventGroupSetNumber( void* xEventGroup, UBaseType_t uxEventGroupNumber ) PRIVILEGED_FUNCTION;

 #endif

 

 #ifdef __cplusplus

diff --git a/src/FreeRTOS/Source/include/list.h b/src/FreeRTOS/Source/include/list.h
index 75d391d..ad7d844 100644
--- a/src/FreeRTOS/Source/include/list.h
+++ b/src/FreeRTOS/Source/include/list.h
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 /*

  * This is the list implementation used by the scheduler.  While it is tailored

@@ -178,6 +136,7 @@ use of FreeRTOS.*/
 /*

  * Definition of the only type of object that a list can contain.

  */

+struct xLIST;

 struct xLIST_ITEM

 {

 	listFIRST_LIST_ITEM_INTEGRITY_CHECK_VALUE			/*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */

@@ -185,7 +144,7 @@ struct xLIST_ITEM
 	struct xLIST_ITEM * configLIST_VOLATILE pxNext;		/*< Pointer to the next ListItem_t in the list. */

 	struct xLIST_ITEM * configLIST_VOLATILE pxPrevious;	/*< Pointer to the previous ListItem_t 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 * configLIST_VOLATILE pvContainer;				/*< Pointer to the list in which this list item is placed (if any). */

+	struct xLIST * configLIST_VOLATILE pxContainer;		/*< Pointer to the list in which this list item is placed (if any). */

 	listSECOND_LIST_ITEM_INTEGRITY_CHECK_VALUE			/*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */

 };

 typedef struct xLIST_ITEM ListItem_t;					/* For some reason lint wants this as two separate definitions. */

@@ -205,7 +164,7 @@ typedef struct xMINI_LIST_ITEM MiniListItem_t;
 typedef struct xLIST

 {

 	listFIRST_LIST_INTEGRITY_CHECK_VALUE				/*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */

-	configLIST_VOLATILE UBaseType_t uxNumberOfItems;

+	volatile UBaseType_t uxNumberOfItems;

 	ListItem_t * configLIST_VOLATILE pxIndex;			/*< Used to walk through the list.  Points to the last item returned by a call to listGET_OWNER_OF_NEXT_ENTRY (). */

 	MiniListItem_t 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. */

 	listSECOND_LIST_INTEGRITY_CHECK_VALUE				/*< Set to a known value if configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */

@@ -288,7 +247,7 @@ typedef struct xLIST
  * \page listLIST_IS_EMPTY listLIST_IS_EMPTY

  * \ingroup LinkedList

  */

-#define listLIST_IS_EMPTY( pxList )	( ( BaseType_t ) ( ( pxList )->uxNumberOfItems == ( UBaseType_t ) 0 ) )

+#define listLIST_IS_EMPTY( pxList )	( ( ( pxList )->uxNumberOfItems == ( UBaseType_t ) 0 ) ? pdTRUE : pdFALSE )

 

 /*

  * Access macro to return the number of items in the list.

@@ -356,7 +315,7 @@ List_t * const pxConstList = ( pxList );													\
  * @param pxListItem The list item we want to know if is in the list.

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

  */

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

+#define listIS_CONTAINED_WITHIN( pxList, pxListItem ) ( ( ( pxListItem )->pxContainer == ( pxList ) ) ? ( pdTRUE ) : ( pdFALSE ) )

 

 /*

  * Return the list a list item is contained within (referenced from).

@@ -364,7 +323,7 @@ List_t * const pxConstList = ( pxList );													\
  * @param pxListItem The list item being queried.

  * @return A pointer to the List_t object that references the pxListItem

  */

-#define listLIST_ITEM_CONTAINER( pxListItem ) ( ( pxListItem )->pvContainer )

+#define listLIST_ITEM_CONTAINER( pxListItem ) ( ( pxListItem )->pxContainer )

 

 /*

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

@@ -414,12 +373,12 @@ void vListInsert( List_t * const pxList, ListItem_t * const pxNewListItem ) PRIV
  * 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.

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

  * 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

+ * in the list position pointed to by pxIndex.  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.

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

  *

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

  *

diff --git a/src/FreeRTOS/Source/include/message_buffer.h b/src/FreeRTOS/Source/include/message_buffer.h
new file mode 100644
index 0000000..64810c2
--- /dev/null
+++ b/src/FreeRTOS/Source/include/message_buffer.h
@@ -0,0 +1,798 @@
+/*

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

+

+

+/*

+ * Message buffers build functionality on top of FreeRTOS stream buffers.

+ * Whereas stream buffers are used to send a continuous stream of data from one

+ * task or interrupt to another, message buffers are used to send variable

+ * length discrete messages from one task or interrupt to another.  Their

+ * implementation is light weight, making them particularly suited for interrupt

+ * to task and core to core communication scenarios.

+ *

+ * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer

+ * implementation (so also the message buffer implementation, as message buffers

+ * are built on top of stream buffers) assumes there is only one task or

+ * interrupt that will write to the buffer (the writer), and only one task or

+ * interrupt that will read from the buffer (the reader).  It is safe for the

+ * writer and reader to be different tasks or interrupts, but, unlike other

+ * FreeRTOS objects, it is not safe to have multiple different writers or

+ * multiple different readers.  If there are to be multiple different writers

+ * then the application writer must place each call to a writing API function

+ * (such as xMessageBufferSend()) inside a critical section and set the send

+ * block time to 0.  Likewise, if there are to be multiple different readers

+ * then the application writer must place each call to a reading API function

+ * (such as xMessageBufferRead()) inside a critical section and set the receive

+ * timeout to 0.

+ *

+ * Message buffers hold variable length messages.  To enable that, when a

+ * message is written to the message buffer an additional sizeof( size_t ) bytes

+ * are also written to store the message's length (that happens internally, with

+ * the API function).  sizeof( size_t ) is typically 4 bytes on a 32-bit

+ * architecture, so writing a 10 byte message to a message buffer on a 32-bit

+ * architecture will actually reduce the available space in the message buffer

+ * by 14 bytes (10 byte are used by the message, and 4 bytes to hold the length

+ * of the message).

+ */

+

+#ifndef FREERTOS_MESSAGE_BUFFER_H

+#define FREERTOS_MESSAGE_BUFFER_H

+

+/* Message buffers are built onto of stream buffers. */

+#include "stream_buffer.h"

+

+#if defined( __cplusplus )

+extern "C" {

+#endif

+

+/**

+ * Type by which message buffers are referenced.  For example, a call to

+ * xMessageBufferCreate() returns an MessageBufferHandle_t variable that can

+ * then be used as a parameter to xMessageBufferSend(), xMessageBufferReceive(),

+ * etc.

+ */

+typedef void * MessageBufferHandle_t;

+

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

+

+/**

+ * message_buffer.h

+ *

+<pre>

+MessageBufferHandle_t xMessageBufferCreate( size_t xBufferSizeBytes );

+</pre>

+ *

+ * Creates a new message buffer using dynamically allocated memory.  See

+ * xMessageBufferCreateStatic() for a version that uses statically allocated

+ * memory (memory that is allocated at compile time).

+ *

+ * configSUPPORT_DYNAMIC_ALLOCATION must be set to 1 or left undefined in

+ * FreeRTOSConfig.h for xMessageBufferCreate() to be available.

+ *

+ * @param xBufferSizeBytes The total number of bytes (not messages) the message

+ * buffer will be able to hold at any one time.  When a message is written to

+ * the message buffer an additional sizeof( size_t ) bytes are also written to

+ * store the message's length.  sizeof( size_t ) is typically 4 bytes on a

+ * 32-bit architecture, so on most 32-bit architectures a 10 byte message will

+ * take up 14 bytes of message buffer space.

+ *

+ * @return If NULL is returned, then the message buffer cannot be created

+ * because there is insufficient heap memory available for FreeRTOS to allocate

+ * the message buffer data structures and storage area.  A non-NULL value being

+ * returned indicates that the message buffer has been created successfully -

+ * the returned value should be stored as the handle to the created message

+ * buffer.

+ *

+ * Example use:

+<pre>

+

+void vAFunction( void )

+{

+MessageBufferHandle_t xMessageBuffer;

+const size_t xMessageBufferSizeBytes = 100;

+

+    // Create a message buffer that can hold 100 bytes.  The memory used to hold

+    // both the message buffer structure and the messages themselves is allocated

+    // dynamically.  Each message added to the buffer consumes an additional 4

+    // bytes which are used to hold the lengh of the message.

+    xMessageBuffer = xMessageBufferCreate( xMessageBufferSizeBytes );

+

+    if( xMessageBuffer == NULL )

+    {

+        // There was not enough heap memory space available to create the

+        // message buffer.

+    }

+    else

+    {

+        // The message buffer was created successfully and can now be used.

+    }

+

+</pre>

+ * \defgroup xMessageBufferCreate xMessageBufferCreate

+ * \ingroup MessageBufferManagement

+ */

+#define xMessageBufferCreate( xBufferSizeBytes ) ( MessageBufferHandle_t ) xStreamBufferGenericCreate( xBufferSizeBytes, ( size_t ) 0, pdTRUE )

+

+/**

+ * message_buffer.h

+ *

+<pre>

+MessageBufferHandle_t xMessageBufferCreateStatic( size_t xBufferSizeBytes,

+                                                  uint8_t *pucMessageBufferStorageArea,

+                                                  StaticMessageBuffer_t *pxStaticMessageBuffer );

+</pre>

+ * Creates a new message buffer using statically allocated memory.  See

+ * xMessageBufferCreate() for a version that uses dynamically allocated memory.

+ *

+ * @param xBufferSizeBytes The size, in bytes, of the buffer pointed to by the

+ * pucMessageBufferStorageArea parameter.  When a message is written to the

+ * message buffer an additional sizeof( size_t ) bytes are also written to store

+ * the message's length.  sizeof( size_t ) is typically 4 bytes on a 32-bit

+ * architecture, so on most 32-bit architecture a 10 byte message will take up

+ * 14 bytes of message buffer space.  The maximum number of bytes that can be

+ * stored in the message buffer is actually (xBufferSizeBytes - 1).

+ *

+ * @param pucMessageBufferStorageArea Must point to a uint8_t array that is at

+ * least xBufferSizeBytes + 1 big.  This is the array to which messages are

+ * copied when they are written to the message buffer.

+ *

+ * @param pxStaticMessageBuffer Must point to a variable of type

+ * StaticMessageBuffer_t, which will be used to hold the message buffer's data

+ * structure.

+ *

+ * @return If the message buffer is created successfully then a handle to the

+ * created message buffer is returned. If either pucMessageBufferStorageArea or

+ * pxStaticmessageBuffer are NULL then NULL is returned.

+ *

+ * Example use:

+<pre>

+

+// Used to dimension the array used to hold the messages.  The available space

+// will actually be one less than this, so 999.

+#define STORAGE_SIZE_BYTES 1000

+

+// Defines the memory that will actually hold the messages within the message

+// buffer.

+static uint8_t ucStorageBuffer[ STORAGE_SIZE_BYTES ];

+

+// The variable used to hold the message buffer structure.

+StaticMessageBuffer_t xMessageBufferStruct;

+

+void MyFunction( void )

+{

+MessageBufferHandle_t xMessageBuffer;

+

+    xMessageBuffer = xMessageBufferCreateStatic( sizeof( ucBufferStorage ),

+                                                 ucBufferStorage,

+                                                 &xMessageBufferStruct );

+

+    // As neither the pucMessageBufferStorageArea or pxStaticMessageBuffer

+    // parameters were NULL, xMessageBuffer will not be NULL, and can be used to

+    // reference the created message buffer in other message buffer API calls.

+

+    // Other code that uses the message buffer can go here.

+}

+

+</pre>

+ * \defgroup xMessageBufferCreateStatic xMessageBufferCreateStatic

+ * \ingroup MessageBufferManagement

+ */

+#define xMessageBufferCreateStatic( xBufferSizeBytes, pucMessageBufferStorageArea, pxStaticMessageBuffer ) ( MessageBufferHandle_t ) xStreamBufferGenericCreateStatic( xBufferSizeBytes, 0, pdTRUE, pucMessageBufferStorageArea, pxStaticMessageBuffer )

+

+/**

+ * message_buffer.h

+ *

+<pre>

+size_t xMessageBufferSend( MessageBufferHandle_t xMessageBuffer,

+                           const void *pvTxData,

+                           size_t xDataLengthBytes,

+                           TickType_t xTicksToWait );

+<pre>

+ *

+ * Sends a discrete message to the message buffer.  The message can be any

+ * length that fits within the buffer's free space, and is copied into the

+ * buffer.

+ *

+ * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer

+ * implementation (so also the message buffer implementation, as message buffers

+ * are built on top of stream buffers) assumes there is only one task or

+ * interrupt that will write to the buffer (the writer), and only one task or

+ * interrupt that will read from the buffer (the reader).  It is safe for the

+ * writer and reader to be different tasks or interrupts, but, unlike other

+ * FreeRTOS objects, it is not safe to have multiple different writers or

+ * multiple different readers.  If there are to be multiple different writers

+ * then the application writer must place each call to a writing API function

+ * (such as xMessageBufferSend()) inside a critical section and set the send

+ * block time to 0.  Likewise, if there are to be multiple different readers

+ * then the application writer must place each call to a reading API function

+ * (such as xMessageBufferRead()) inside a critical section and set the receive

+ * block time to 0.

+ *

+ * Use xMessageBufferSend() to write to a message buffer from a task.  Use

+ * xMessageBufferSendFromISR() to write to a message buffer from an interrupt

+ * service routine (ISR).

+ *

+ * @param xMessageBuffer The handle of the message buffer to which a message is

+ * being sent.

+ *

+ * @param pvTxData A pointer to the message that is to be copied into the

+ * message buffer.

+ *

+ * @param xDataLengthBytes The length of the message.  That is, the number of

+ * bytes to copy from pvTxData into the message buffer.  When a message is

+ * written to the message buffer an additional sizeof( size_t ) bytes are also

+ * written to store the message's length.  sizeof( size_t ) is typically 4 bytes

+ * on a 32-bit architecture, so on most 32-bit architecture setting

+ * xDataLengthBytes to 20 will reduce the free space in the message buffer by 24

+ * bytes (20 bytes of message data and 4 bytes to hold the message length).

+ *

+ * @param xTicksToWait The maximum amount of time the calling task should remain

+ * in the Blocked state to wait for enough space to become available in the

+ * message buffer, should the message buffer have insufficient space when

+ * xMessageBufferSend() is called.  The calling task will never block if

+ * xTicksToWait is zero.  The block time is specified in tick periods, so the

+ * absolute time it represents is dependent on the tick frequency.  The macro

+ * pdMS_TO_TICKS() can be used to convert a time specified in milliseconds into

+ * a time specified in ticks.  Setting xTicksToWait to portMAX_DELAY will cause

+ * the task to wait indefinitely (without timing out), provided

+ * INCLUDE_vTaskSuspend is set to 1 in FreeRTOSConfig.h.  Tasks do not use any

+ * CPU time when they are in the Blocked state.

+ *

+ * @return The number of bytes written to the message buffer.  If the call to

+ * xMessageBufferSend() times out before there was enough space to write the

+ * message into the message buffer then zero is returned.  If the call did not

+ * time out then xDataLengthBytes is returned.

+ *

+ * Example use:

+<pre>

+void vAFunction( MessageBufferHandle_t xMessageBuffer )

+{

+size_t xBytesSent;

+uint8_t ucArrayToSend[] = { 0, 1, 2, 3 };

+char *pcStringToSend = "String to send";

+const TickType_t x100ms = pdMS_TO_TICKS( 100 );

+

+    // Send an array to the message buffer, blocking for a maximum of 100ms to

+    // wait for enough space to be available in the message buffer.

+    xBytesSent = xMessageBufferSend( xMessageBuffer, ( void * ) ucArrayToSend, sizeof( ucArrayToSend ), x100ms );

+

+    if( xBytesSent != sizeof( ucArrayToSend ) )

+    {

+        // The call to xMessageBufferSend() times out before there was enough

+        // space in the buffer for the data to be written.

+    }

+

+    // Send the string to the message buffer.  Return immediately if there is

+    // not enough space in the buffer.

+    xBytesSent = xMessageBufferSend( xMessageBuffer, ( void * ) pcStringToSend, strlen( pcStringToSend ), 0 );

+

+    if( xBytesSent != strlen( pcStringToSend ) )

+    {

+        // The string could not be added to the message buffer because there was

+        // not enough free space in the buffer.

+    }

+}

+</pre>

+ * \defgroup xMessageBufferSend xMessageBufferSend

+ * \ingroup MessageBufferManagement

+ */

+#define xMessageBufferSend( xMessageBuffer, pvTxData, xDataLengthBytes, xTicksToWait ) xStreamBufferSend( ( StreamBufferHandle_t ) xMessageBuffer, pvTxData, xDataLengthBytes, xTicksToWait )

+

+/**

+ * message_buffer.h

+ *

+<pre>

+size_t xMessageBufferSendFromISR( MessageBufferHandle_t xMessageBuffer,

+                                  const void *pvTxData,

+                                  size_t xDataLengthBytes,

+                                  BaseType_t *pxHigherPriorityTaskWoken );

+<pre>

+ *

+ * Interrupt safe version of the API function that sends a discrete message to

+ * the message buffer.  The message can be any length that fits within the

+ * buffer's free space, and is copied into the buffer.

+ *

+ * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer

+ * implementation (so also the message buffer implementation, as message buffers

+ * are built on top of stream buffers) assumes there is only one task or

+ * interrupt that will write to the buffer (the writer), and only one task or

+ * interrupt that will read from the buffer (the reader).  It is safe for the

+ * writer and reader to be different tasks or interrupts, but, unlike other

+ * FreeRTOS objects, it is not safe to have multiple different writers or

+ * multiple different readers.  If there are to be multiple different writers

+ * then the application writer must place each call to a writing API function

+ * (such as xMessageBufferSend()) inside a critical section and set the send

+ * block time to 0.  Likewise, if there are to be multiple different readers

+ * then the application writer must place each call to a reading API function

+ * (such as xMessageBufferRead()) inside a critical section and set the receive

+ * block time to 0.

+ *

+ * Use xMessageBufferSend() to write to a message buffer from a task.  Use

+ * xMessageBufferSendFromISR() to write to a message buffer from an interrupt

+ * service routine (ISR).

+ *

+ * @param xMessageBuffer The handle of the message buffer to which a message is

+ * being sent.

+ *

+ * @param pvTxData A pointer to the message that is to be copied into the

+ * message buffer.

+ *

+ * @param xDataLengthBytes The length of the message.  That is, the number of

+ * bytes to copy from pvTxData into the message buffer.  When a message is

+ * written to the message buffer an additional sizeof( size_t ) bytes are also

+ * written to store the message's length.  sizeof( size_t ) is typically 4 bytes

+ * on a 32-bit architecture, so on most 32-bit architecture setting

+ * xDataLengthBytes to 20 will reduce the free space in the message buffer by 24

+ * bytes (20 bytes of message data and 4 bytes to hold the message length).

+ *

+ * @param pxHigherPriorityTaskWoken  It is possible that a message buffer will

+ * have a task blocked on it waiting for data.  Calling

+ * xMessageBufferSendFromISR() can make data available, and so cause a task that

+ * was waiting for data to leave the Blocked state.  If calling

+ * xMessageBufferSendFromISR() causes a task to leave the Blocked state, and the

+ * unblocked task has a priority higher than the currently executing task (the

+ * task that was interrupted), then, internally, xMessageBufferSendFromISR()

+ * will set *pxHigherPriorityTaskWoken to pdTRUE.  If

+ * xMessageBufferSendFromISR() sets this value to pdTRUE, then normally a

+ * context switch should be performed before the interrupt is exited.  This will

+ * ensure that the interrupt returns directly to the highest priority Ready

+ * state task.  *pxHigherPriorityTaskWoken should be set to pdFALSE before it

+ * is passed into the function.  See the code example below for an example.

+ *

+ * @return The number of bytes actually written to the message buffer.  If the

+ * message buffer didn't have enough free space for the message to be stored

+ * then 0 is returned, otherwise xDataLengthBytes is returned.

+ *

+ * Example use:

+<pre>

+// A message buffer that has already been created.

+MessageBufferHandle_t xMessageBuffer;

+

+void vAnInterruptServiceRoutine( void )

+{

+size_t xBytesSent;

+char *pcStringToSend = "String to send";

+BaseType_t xHigherPriorityTaskWoken = pdFALSE; // Initialised to pdFALSE.

+

+    // Attempt to send the string to the message buffer.

+    xBytesSent = xMessageBufferSendFromISR( xMessageBuffer,

+                                            ( void * ) pcStringToSend,

+                                            strlen( pcStringToSend ),

+                                            &xHigherPriorityTaskWoken );

+

+    if( xBytesSent != strlen( pcStringToSend ) )

+    {

+        // The string could not be added to the message buffer because there was

+        // not enough free space in the buffer.

+    }

+

+    // If xHigherPriorityTaskWoken was set to pdTRUE inside

+    // xMessageBufferSendFromISR() then a task that has a priority above the

+    // priority of the currently executing task was unblocked and a context

+    // switch should be performed to ensure the ISR returns to the unblocked

+    // task.  In most FreeRTOS ports this is done by simply passing

+    // xHigherPriorityTaskWoken into taskYIELD_FROM_ISR(), which will test the

+    // variables value, and perform the context switch if necessary.  Check the

+    // documentation for the port in use for port specific instructions.

+    taskYIELD_FROM_ISR( xHigherPriorityTaskWoken );

+}

+</pre>

+ * \defgroup xMessageBufferSendFromISR xMessageBufferSendFromISR

+ * \ingroup MessageBufferManagement

+ */

+#define xMessageBufferSendFromISR( xMessageBuffer, pvTxData, xDataLengthBytes, pxHigherPriorityTaskWoken ) xStreamBufferSendFromISR( ( StreamBufferHandle_t ) xMessageBuffer, pvTxData, xDataLengthBytes, pxHigherPriorityTaskWoken )

+

+/**

+ * message_buffer.h

+ *

+<pre>

+size_t xMessageBufferReceive( MessageBufferHandle_t xMessageBuffer,

+                              void *pvRxData,

+                              size_t xBufferLengthBytes,

+                              TickType_t xTicksToWait );

+</pre>

+ *

+ * Receives a discrete message from a message buffer.  Messages can be of

+ * variable length and are copied out of the buffer.

+ *

+ * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer

+ * implementation (so also the message buffer implementation, as message buffers

+ * are built on top of stream buffers) assumes there is only one task or

+ * interrupt that will write to the buffer (the writer), and only one task or

+ * interrupt that will read from the buffer (the reader).  It is safe for the

+ * writer and reader to be different tasks or interrupts, but, unlike other

+ * FreeRTOS objects, it is not safe to have multiple different writers or

+ * multiple different readers.  If there are to be multiple different writers

+ * then the application writer must place each call to a writing API function

+ * (such as xMessageBufferSend()) inside a critical section and set the send

+ * block time to 0.  Likewise, if there are to be multiple different readers

+ * then the application writer must place each call to a reading API function

+ * (such as xMessageBufferRead()) inside a critical section and set the receive

+ * block time to 0.

+ *

+ * Use xMessageBufferReceive() to read from a message buffer from a task.  Use

+ * xMessageBufferReceiveFromISR() to read from a message buffer from an

+ * interrupt service routine (ISR).

+ *

+ * @param xMessageBuffer The handle of the message buffer from which a message

+ * is being received.

+ *

+ * @param pvRxData A pointer to the buffer into which the received message is

+ * to be copied.

+ *

+ * @param xBufferLengthBytes The length of the buffer pointed to by the pvRxData

+ * parameter.  This sets the maximum length of the message that can be received.

+ * If xBufferLengthBytes is too small to hold the next message then the message

+ * will be left in the message buffer and 0 will be returned.

+ *

+ * @param xTicksToWait The maximum amount of time the task should remain in the

+ * Blocked state to wait for a message, should the message buffer be empty.

+ * xMessageBufferReceive() will return immediately if xTicksToWait is zero and

+ * the message buffer is empty.  The block time is specified in tick periods, so

+ * the absolute time it represents is dependent on the tick frequency.  The

+ * macro pdMS_TO_TICKS() can be used to convert a time specified in milliseconds

+ * into a time specified in ticks.  Setting xTicksToWait to portMAX_DELAY will

+ * cause the task to wait indefinitely (without timing out), provided

+ * INCLUDE_vTaskSuspend is set to 1 in FreeRTOSConfig.h.  Tasks do not use any

+ * CPU time when they are in the Blocked state.

+ *

+ * @return The length, in bytes, of the message read from the message buffer, if

+ * any.  If xMessageBufferReceive() times out before a message became available

+ * then zero is returned.  If the length of the message is greater than

+ * xBufferLengthBytes then the message will be left in the message buffer and

+ * zero is returned.

+ *

+ * Example use:

+<pre>

+void vAFunction( MessageBuffer_t xMessageBuffer )

+{

+uint8_t ucRxData[ 20 ];

+size_t xReceivedBytes;

+const TickType_t xBlockTime = pdMS_TO_TICKS( 20 );

+

+    // Receive the next message from the message buffer.  Wait in the Blocked

+    // state (so not using any CPU processing time) for a maximum of 100ms for

+    // a message to become available.

+    xReceivedBytes = xMessageBufferReceive( xMessageBuffer,

+                                            ( void * ) ucRxData,

+                                            sizeof( ucRxData ),

+                                            xBlockTime );

+

+    if( xReceivedBytes > 0 )

+    {

+        // A ucRxData contains a message that is xReceivedBytes long.  Process

+        // the message here....

+    }

+}

+</pre>

+ * \defgroup xMessageBufferReceive xMessageBufferReceive

+ * \ingroup MessageBufferManagement

+ */

+#define xMessageBufferReceive( xMessageBuffer, pvRxData, xBufferLengthBytes, xTicksToWait ) xStreamBufferReceive( ( StreamBufferHandle_t ) xMessageBuffer, pvRxData, xBufferLengthBytes, xTicksToWait )

+

+

+/**

+ * message_buffer.h

+ *

+<pre>

+size_t xMessageBufferReceiveFromISR( MessageBufferHandle_t xMessageBuffer,

+                                     void *pvRxData,

+                                     size_t xBufferLengthBytes,

+                                     BaseType_t *pxHigherPriorityTaskWoken );

+</pre>

+ *

+ * An interrupt safe version of the API function that receives a discrete

+ * message from a message buffer.  Messages can be of variable length and are

+ * copied out of the buffer.

+ *

+ * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer

+ * implementation (so also the message buffer implementation, as message buffers

+ * are built on top of stream buffers) assumes there is only one task or

+ * interrupt that will write to the buffer (the writer), and only one task or

+ * interrupt that will read from the buffer (the reader).  It is safe for the

+ * writer and reader to be different tasks or interrupts, but, unlike other

+ * FreeRTOS objects, it is not safe to have multiple different writers or

+ * multiple different readers.  If there are to be multiple different writers

+ * then the application writer must place each call to a writing API function

+ * (such as xMessageBufferSend()) inside a critical section and set the send

+ * block time to 0.  Likewise, if there are to be multiple different readers

+ * then the application writer must place each call to a reading API function

+ * (such as xMessageBufferRead()) inside a critical section and set the receive

+ * block time to 0.

+ *

+ * Use xMessageBufferReceive() to read from a message buffer from a task.  Use

+ * xMessageBufferReceiveFromISR() to read from a message buffer from an

+ * interrupt service routine (ISR).

+ *

+ * @param xMessageBuffer The handle of the message buffer from which a message

+ * is being received.

+ *

+ * @param pvRxData A pointer to the buffer into which the received message is

+ * to be copied.

+ *

+ * @param xBufferLengthBytes The length of the buffer pointed to by the pvRxData

+ * parameter.  This sets the maximum length of the message that can be received.

+ * If xBufferLengthBytes is too small to hold the next message then the message

+ * will be left in the message buffer and 0 will be returned.

+ *

+ * @param pxHigherPriorityTaskWoken  It is possible that a message buffer will

+ * have a task blocked on it waiting for space to become available.  Calling

+ * xMessageBufferReceiveFromISR() can make space available, and so cause a task

+ * that is waiting for space to leave the Blocked state.  If calling

+ * xMessageBufferReceiveFromISR() causes a task to leave the Blocked state, and

+ * the unblocked task has a priority higher than the currently executing task

+ * (the task that was interrupted), then, internally,

+ * xMessageBufferReceiveFromISR() will set *pxHigherPriorityTaskWoken to pdTRUE.

+ * If xMessageBufferReceiveFromISR() sets this value to pdTRUE, then normally a

+ * context switch should be performed before the interrupt is exited.  That will

+ * ensure the interrupt returns directly to the highest priority Ready state

+ * task.  *pxHigherPriorityTaskWoken should be set to pdFALSE before it is

+ * passed into the function.  See the code example below for an example.

+ *

+ * @return The length, in bytes, of the message read from the message buffer, if

+ * any.

+ *

+ * Example use:

+<pre>

+// A message buffer that has already been created.

+MessageBuffer_t xMessageBuffer;

+

+void vAnInterruptServiceRoutine( void )

+{

+uint8_t ucRxData[ 20 ];

+size_t xReceivedBytes;

+BaseType_t xHigherPriorityTaskWoken = pdFALSE;  // Initialised to pdFALSE.

+

+    // Receive the next message from the message buffer.

+    xReceivedBytes = xMessageBufferReceiveFromISR( xMessageBuffer,

+                                                  ( void * ) ucRxData,

+                                                  sizeof( ucRxData ),

+                                                  &xHigherPriorityTaskWoken );

+

+    if( xReceivedBytes > 0 )

+    {

+        // A ucRxData contains a message that is xReceivedBytes long.  Process

+        // the message here....

+    }

+

+    // If xHigherPriorityTaskWoken was set to pdTRUE inside

+    // xMessageBufferReceiveFromISR() then a task that has a priority above the

+    // priority of the currently executing task was unblocked and a context

+    // switch should be performed to ensure the ISR returns to the unblocked

+    // task.  In most FreeRTOS ports this is done by simply passing

+    // xHigherPriorityTaskWoken into taskYIELD_FROM_ISR(), which will test the

+    // variables value, and perform the context switch if necessary.  Check the

+    // documentation for the port in use for port specific instructions.

+    taskYIELD_FROM_ISR( xHigherPriorityTaskWoken );

+}

+</pre>

+ * \defgroup xMessageBufferReceiveFromISR xMessageBufferReceiveFromISR

+ * \ingroup MessageBufferManagement

+ */

+#define xMessageBufferReceiveFromISR( xMessageBuffer, pvRxData, xBufferLengthBytes, pxHigherPriorityTaskWoken ) xStreamBufferReceiveFromISR( ( StreamBufferHandle_t ) xMessageBuffer, pvRxData, xBufferLengthBytes, pxHigherPriorityTaskWoken )

+

+/**

+ * message_buffer.h

+ *

+<pre>

+void vMessageBufferDelete( MessageBufferHandle_t xMessageBuffer );

+</pre>

+ *

+ * Deletes a message buffer that was previously created using a call to

+ * xMessageBufferCreate() or xMessageBufferCreateStatic().  If the message

+ * buffer was created using dynamic memory (that is, by xMessageBufferCreate()),

+ * then the allocated memory is freed.

+ *

+ * A message buffer handle must not be used after the message buffer has been

+ * deleted.

+ *

+ * @param xMessageBuffer The handle of the message buffer to be deleted.

+ *

+ */

+#define vMessageBufferDelete( xMessageBuffer ) vStreamBufferDelete( ( StreamBufferHandle_t ) xMessageBuffer )

+

+/**

+ * message_buffer.h

+<pre>

+BaseType_t xMessageBufferIsFull( MessageBufferHandle_t xMessageBuffer ) );

+</pre>

+ *

+ * Tests to see if a message buffer is full.  A message buffer is full if it

+ * cannot accept any more messages, of any size, until space is made available

+ * by a message being removed from the message buffer.

+ *

+ * @param xMessageBuffer The handle of the message buffer being queried.

+ *

+ * @return If the message buffer referenced by xMessageBuffer is full then

+ * pdTRUE is returned.  Otherwise pdFALSE is returned.

+ */

+#define xMessageBufferIsFull( xMessageBuffer ) xStreamBufferIsFull( ( StreamBufferHandle_t ) xMessageBuffer )

+

+/**

+ * message_buffer.h

+<pre>

+BaseType_t xMessageBufferIsEmpty( MessageBufferHandle_t xMessageBuffer ) );

+</pre>

+ *

+ * Tests to see if a message buffer is empty (does not contain any messages).

+ *

+ * @param xMessageBuffer The handle of the message buffer being queried.

+ *

+ * @return If the message buffer referenced by xMessageBuffer is empty then

+ * pdTRUE is returned.  Otherwise pdFALSE is returned.

+ *

+ */

+#define xMessageBufferIsEmpty( xMessageBuffer ) xStreamBufferIsEmpty( ( StreamBufferHandle_t ) xMessageBuffer )

+

+/**

+ * message_buffer.h

+<pre>

+BaseType_t xMessageBufferReset( MessageBufferHandle_t xMessageBuffer );

+</pre>

+ *

+ * Resets a message buffer to its initial empty state, discarding any message it

+ * contained.

+ *

+ * A message buffer can only be reset if there are no tasks blocked on it.

+ *

+ * @param xMessageBuffer The handle of the message buffer being reset.

+ *

+ * @return If the message buffer was reset then pdPASS is returned.  If the

+ * message buffer could not be reset because either there was a task blocked on

+ * the message queue to wait for space to become available, or to wait for a

+ * a message to be available, then pdFAIL is returned.

+ *

+ * \defgroup xMessageBufferReset xMessageBufferReset

+ * \ingroup MessageBufferManagement

+ */

+#define xMessageBufferReset( xMessageBuffer ) xStreamBufferReset( ( StreamBufferHandle_t ) xMessageBuffer )

+

+

+/**

+ * message_buffer.h

+<pre>

+size_t xMessageBufferSpaceAvailable( MessageBufferHandle_t xMessageBuffer ) );

+</pre>

+ * Returns the number of bytes of free space in the message buffer.

+ *

+ * @param xMessageBuffer The handle of the message buffer being queried.

+ *

+ * @return The number of bytes that can be written to the message buffer before

+ * the message buffer would be full.  When a message is written to the message

+ * buffer an additional sizeof( size_t ) bytes are also written to store the

+ * message's length.  sizeof( size_t ) is typically 4 bytes on a 32-bit

+ * architecture, so if xMessageBufferSpacesAvailable() returns 10, then the size

+ * of the largest message that can be written to the message buffer is 6 bytes.

+ *

+ * \defgroup xMessageBufferSpaceAvailable xMessageBufferSpaceAvailable

+ * \ingroup MessageBufferManagement

+ */

+#define xMessageBufferSpaceAvailable( xMessageBuffer ) xStreamBufferSpacesAvailable( ( StreamBufferHandle_t ) xMessageBuffer )

+

+/**

+ * message_buffer.h

+ <pre>

+ size_t xMessageBufferNextLengthBytes( MessageBufferHandle_t xMessageBuffer ) );

+ </pre>

+ * Returns the length (in bytes) of the next message in a message buffer.

+ * Useful if xMessageBufferReceive() returned 0 because the size of the buffer

+ * passed into xMessageBufferReceive() was too small to hold the next message.

+ *

+ * @param xMessageBuffer The handle of the message buffer being queried.

+ *

+ * @return The length (in bytes) of the next message in the message buffer, or 0

+ * if the message buffer is empty.

+ *

+ * \defgroup xMessageBufferNextLengthBytes xMessageBufferNextLengthBytes

+ * \ingroup MessageBufferManagement

+ */

+#define xMessageBufferNextLengthBytes( xMessageBuffer ) xStreamBufferNextMessageLengthBytes( ( StreamBufferHandle_t ) xMessageBuffer ) PRIVILEGED_FUNCTION;

+

+/**

+ * message_buffer.h

+ *

+<pre>

+BaseType_t xMessageBufferSendCompletedFromISR( MessageBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken );

+</pre>

+ *

+ * For advanced users only.

+ *

+ * The sbSEND_COMPLETED() macro is called from within the FreeRTOS APIs when

+ * data is sent to a message buffer or stream buffer.  If there was a task that

+ * was blocked on the message or stream buffer waiting for data to arrive then

+ * the sbSEND_COMPLETED() macro sends a notification to the task to remove it

+ * from the Blocked state.  xMessageBufferSendCompletedFromISR() does the same

+ * thing.  It is provided to enable application writers to implement their own

+ * version of sbSEND_COMPLETED(), and MUST NOT BE USED AT ANY OTHER TIME.

+ *

+ * See the example implemented in FreeRTOS/Demo/Minimal/MessageBufferAMP.c for

+ * additional information.

+ *

+ * @param xStreamBuffer The handle of the stream buffer to which data was

+ * written.

+ *

+ * @param pxHigherPriorityTaskWoken *pxHigherPriorityTaskWoken should be

+ * initialised to pdFALSE before it is passed into

+ * xMessageBufferSendCompletedFromISR().  If calling

+ * xMessageBufferSendCompletedFromISR() removes a task from the Blocked state,

+ * and the task has a priority above the priority of the currently running task,

+ * then *pxHigherPriorityTaskWoken will get set to pdTRUE indicating that a

+ * context switch should be performed before exiting the ISR.

+ *

+ * @return If a task was removed from the Blocked state then pdTRUE is returned.

+ * Otherwise pdFALSE is returned.

+ *

+ * \defgroup xMessageBufferSendCompletedFromISR xMessageBufferSendCompletedFromISR

+ * \ingroup StreamBufferManagement

+ */

+#define xMessageBufferSendCompletedFromISR( xMessageBuffer, pxHigherPriorityTaskWoken ) xStreamBufferSendCompletedFromISR( ( StreamBufferHandle_t ) xMessageBuffer, pxHigherPriorityTaskWoken )

+

+/**

+ * message_buffer.h

+ *

+<pre>

+BaseType_t xMessageBufferReceiveCompletedFromISR( MessageBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken );

+</pre>

+ *

+ * For advanced users only.

+ *

+ * The sbRECEIVE_COMPLETED() macro is called from within the FreeRTOS APIs when

+ * data is read out of a message buffer or stream buffer.  If there was a task

+ * that was blocked on the message or stream buffer waiting for data to arrive

+ * then the sbRECEIVE_COMPLETED() macro sends a notification to the task to

+ * remove it from the Blocked state.  xMessageBufferReceiveCompletedFromISR()

+ * does the same thing.  It is provided to enable application writers to

+ * implement their own version of sbRECEIVE_COMPLETED(), and MUST NOT BE USED AT

+ * ANY OTHER TIME.

+ *

+ * See the example implemented in FreeRTOS/Demo/Minimal/MessageBufferAMP.c for

+ * additional information.

+ *

+ * @param xStreamBuffer The handle of the stream buffer from which data was

+ * read.

+ *

+ * @param pxHigherPriorityTaskWoken *pxHigherPriorityTaskWoken should be

+ * initialised to pdFALSE before it is passed into

+ * xMessageBufferReceiveCompletedFromISR().  If calling

+ * xMessageBufferReceiveCompletedFromISR() removes a task from the Blocked state,

+ * and the task has a priority above the priority of the currently running task,

+ * then *pxHigherPriorityTaskWoken will get set to pdTRUE indicating that a

+ * context switch should be performed before exiting the ISR.

+ *

+ * @return If a task was removed from the Blocked state then pdTRUE is returned.

+ * Otherwise pdFALSE is returned.

+ *

+ * \defgroup xMessageBufferReceiveCompletedFromISR xMessageBufferReceiveCompletedFromISR

+ * \ingroup StreamBufferManagement

+ */

+#define xMessageBufferReceiveCompletedFromISR( xMessageBuffer, pxHigherPriorityTaskWoken ) xStreamBufferReceiveCompletedFromISR( ( StreamBufferHandle_t ) xMessageBuffer, pxHigherPriorityTaskWoken )

+

+#if defined( __cplusplus )

+} /* extern "C" */

+#endif

+

+#endif	/* !defined( FREERTOS_MESSAGE_BUFFER_H ) */

diff --git a/src/FreeRTOS/Source/include/mpu_prototypes.h b/src/FreeRTOS/Source/include/mpu_prototypes.h
new file mode 100644
index 0000000..4e3baf7
--- /dev/null
+++ b/src/FreeRTOS/Source/include/mpu_prototypes.h
@@ -0,0 +1,157 @@
+/*

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

+

+/*

+ * When the MPU is used the standard (non MPU) API functions are mapped to

+ * equivalents that start "MPU_", the prototypes for which are defined in this

+ * header files.  This will cause the application code to call the MPU_ version

+ * which wraps the non-MPU version with privilege promoting then demoting code,

+ * so the kernel code always runs will full privileges.

+ */

+

+

+#ifndef MPU_PROTOTYPES_H

+#define MPU_PROTOTYPES_H

+

+/* MPU versions of tasks.h API functions. */

+BaseType_t MPU_xTaskCreate( TaskFunction_t pxTaskCode, const char * const pcName, const uint16_t usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pxCreatedTask ) FREERTOS_SYSTEM_CALL;

+TaskHandle_t MPU_xTaskCreateStatic( TaskFunction_t pxTaskCode, const char * const pcName, const uint32_t ulStackDepth, void * const pvParameters, UBaseType_t uxPriority, StackType_t * const puxStackBuffer, StaticTask_t * const pxTaskBuffer ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xTaskCreateRestrictedStatic( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask ) FREERTOS_SYSTEM_CALL;

+void MPU_vTaskAllocateMPURegions( TaskHandle_t xTask, const MemoryRegion_t * const pxRegions ) FREERTOS_SYSTEM_CALL;

+void MPU_vTaskDelete( TaskHandle_t xTaskToDelete ) FREERTOS_SYSTEM_CALL;

+void MPU_vTaskDelay( const TickType_t xTicksToDelay ) FREERTOS_SYSTEM_CALL;

+void MPU_vTaskDelayUntil( TickType_t * const pxPreviousWakeTime, const TickType_t xTimeIncrement ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xTaskAbortDelay( TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;

+UBaseType_t MPU_uxTaskPriorityGet( const TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;

+eTaskState MPU_eTaskGetState( TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;

+void MPU_vTaskGetInfo( TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, BaseType_t xGetFreeStackSpace, eTaskState eState ) FREERTOS_SYSTEM_CALL;

+void MPU_vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority ) FREERTOS_SYSTEM_CALL;

+void MPU_vTaskSuspend( TaskHandle_t xTaskToSuspend ) FREERTOS_SYSTEM_CALL;

+void MPU_vTaskResume( TaskHandle_t xTaskToResume ) FREERTOS_SYSTEM_CALL;

+void MPU_vTaskStartScheduler( void ) FREERTOS_SYSTEM_CALL;

+void MPU_vTaskSuspendAll( void ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xTaskResumeAll( void ) FREERTOS_SYSTEM_CALL;

+TickType_t MPU_xTaskGetTickCount( void ) FREERTOS_SYSTEM_CALL;

+UBaseType_t MPU_uxTaskGetNumberOfTasks( void ) FREERTOS_SYSTEM_CALL;

+char * MPU_pcTaskGetName( TaskHandle_t xTaskToQuery ) FREERTOS_SYSTEM_CALL;

+TaskHandle_t MPU_xTaskGetHandle( const char *pcNameToQuery ) FREERTOS_SYSTEM_CALL;

+UBaseType_t MPU_uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;

+configSTACK_DEPTH_TYPE MPU_uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;

+void MPU_vTaskSetApplicationTaskTag( TaskHandle_t xTask, TaskHookFunction_t pxHookFunction ) FREERTOS_SYSTEM_CALL;

+TaskHookFunction_t MPU_xTaskGetApplicationTaskTag( TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;

+void MPU_vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet, BaseType_t xIndex, void *pvValue ) FREERTOS_SYSTEM_CALL;

+void * MPU_pvTaskGetThreadLocalStoragePointer( TaskHandle_t xTaskToQuery, BaseType_t xIndex ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter ) FREERTOS_SYSTEM_CALL;

+TaskHandle_t MPU_xTaskGetIdleTaskHandle( void ) FREERTOS_SYSTEM_CALL;

+UBaseType_t MPU_uxTaskGetSystemState( TaskStatus_t * const pxTaskStatusArray, const UBaseType_t uxArraySize, uint32_t * const pulTotalRunTime ) FREERTOS_SYSTEM_CALL;

+TickType_t MPU_xTaskGetIdleRunTimeCounter( void ) FREERTOS_SYSTEM_CALL;

+void MPU_vTaskList( char * pcWriteBuffer ) FREERTOS_SYSTEM_CALL;

+void MPU_vTaskGetRunTimeStats( char *pcWriteBuffer ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xTaskGenericNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;

+uint32_t MPU_ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xTaskNotifyStateClear( TaskHandle_t xTask ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xTaskIncrementTick( void ) FREERTOS_SYSTEM_CALL;

+TaskHandle_t MPU_xTaskGetCurrentTaskHandle( void ) FREERTOS_SYSTEM_CALL;

+void MPU_vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait ) FREERTOS_SYSTEM_CALL;

+void MPU_vTaskMissedYield( void ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xTaskGetSchedulerState( void ) FREERTOS_SYSTEM_CALL;

+

+/* MPU versions of queue.h API functions. */

+BaseType_t MPU_xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, const BaseType_t xCopyPosition ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xQueueReceive( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xQueuePeek( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xQueueSemaphoreTake( QueueHandle_t xQueue, TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;

+UBaseType_t MPU_uxQueueMessagesWaiting( const QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;

+UBaseType_t MPU_uxQueueSpacesAvailable( const QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;

+void MPU_vQueueDelete( QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;

+QueueHandle_t MPU_xQueueCreateMutex( const uint8_t ucQueueType ) FREERTOS_SYSTEM_CALL;

+QueueHandle_t MPU_xQueueCreateMutexStatic( const uint8_t ucQueueType, StaticQueue_t *pxStaticQueue ) FREERTOS_SYSTEM_CALL;

+QueueHandle_t MPU_xQueueCreateCountingSemaphore( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount ) FREERTOS_SYSTEM_CALL;

+QueueHandle_t MPU_xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount, StaticQueue_t *pxStaticQueue ) FREERTOS_SYSTEM_CALL;

+TaskHandle_t MPU_xQueueGetMutexHolder( QueueHandle_t xSemaphore ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xQueueTakeMutexRecursive( QueueHandle_t xMutex, TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xQueueGiveMutexRecursive( QueueHandle_t pxMutex ) FREERTOS_SYSTEM_CALL;

+void MPU_vQueueAddToRegistry( QueueHandle_t xQueue, const char *pcName ) FREERTOS_SYSTEM_CALL;

+void MPU_vQueueUnregisterQueue( QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;

+const char * MPU_pcQueueGetName( QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;

+QueueHandle_t MPU_xQueueGenericCreate( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, const uint8_t ucQueueType ) FREERTOS_SYSTEM_CALL;

+QueueHandle_t MPU_xQueueGenericCreateStatic( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, StaticQueue_t *pxStaticQueue, const uint8_t ucQueueType ) FREERTOS_SYSTEM_CALL;

+QueueSetHandle_t MPU_xQueueCreateSet( const UBaseType_t uxEventQueueLength ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xQueueAddToSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xQueueRemoveFromSet( QueueSetMemberHandle_t xQueueOrSemaphore, QueueSetHandle_t xQueueSet ) FREERTOS_SYSTEM_CALL;

+QueueSetMemberHandle_t MPU_xQueueSelectFromSet( QueueSetHandle_t xQueueSet, const TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xQueueGenericReset( QueueHandle_t xQueue, BaseType_t xNewQueue ) FREERTOS_SYSTEM_CALL;

+void MPU_vQueueSetQueueNumber( QueueHandle_t xQueue, UBaseType_t uxQueueNumber ) FREERTOS_SYSTEM_CALL;

+UBaseType_t MPU_uxQueueGetQueueNumber( QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;

+uint8_t MPU_ucQueueGetQueueType( QueueHandle_t xQueue ) FREERTOS_SYSTEM_CALL;

+

+/* MPU versions of timers.h API functions. */

+TimerHandle_t MPU_xTimerCreate( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction ) FREERTOS_SYSTEM_CALL;

+TimerHandle_t MPU_xTimerCreateStatic( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction, StaticTimer_t *pxTimerBuffer ) FREERTOS_SYSTEM_CALL;

+void * MPU_pvTimerGetTimerID( const TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;

+void MPU_vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xTimerIsTimerActive( TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;

+TaskHandle_t MPU_xTimerGetTimerDaemonTaskHandle( void ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xTimerPendFunctionCall( PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;

+const char * MPU_pcTimerGetName( TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;

+void MPU_vTimerSetReloadMode( TimerHandle_t xTimer, const UBaseType_t uxAutoReload ) FREERTOS_SYSTEM_CALL;

+TickType_t MPU_xTimerGetPeriod( TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;

+TickType_t MPU_xTimerGetExpiryTime( TimerHandle_t xTimer ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xTimerCreateTimerTask( void ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xTimerGenericCommand( TimerHandle_t xTimer, const BaseType_t xCommandID, const TickType_t xOptionalValue, BaseType_t * const pxHigherPriorityTaskWoken, const TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;

+

+/* MPU versions of event_group.h API functions. */

+EventGroupHandle_t MPU_xEventGroupCreate( void ) FREERTOS_SYSTEM_CALL;

+EventGroupHandle_t MPU_xEventGroupCreateStatic( StaticEventGroup_t *pxEventGroupBuffer ) FREERTOS_SYSTEM_CALL;

+EventBits_t MPU_xEventGroupWaitBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToWaitFor, const BaseType_t xClearOnExit, const BaseType_t xWaitForAllBits, TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;

+EventBits_t MPU_xEventGroupClearBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToClear ) FREERTOS_SYSTEM_CALL;

+EventBits_t MPU_xEventGroupSetBits( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet ) FREERTOS_SYSTEM_CALL;

+EventBits_t MPU_xEventGroupSync( EventGroupHandle_t xEventGroup, const EventBits_t uxBitsToSet, const EventBits_t uxBitsToWaitFor, TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;

+void MPU_vEventGroupDelete( EventGroupHandle_t xEventGroup ) FREERTOS_SYSTEM_CALL;

+UBaseType_t MPU_uxEventGroupGetNumber( void* xEventGroup ) FREERTOS_SYSTEM_CALL;

+

+/* MPU versions of message/stream_buffer.h API functions. */

+size_t MPU_xStreamBufferSend( StreamBufferHandle_t xStreamBuffer, const void *pvTxData, size_t xDataLengthBytes, TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;

+size_t MPU_xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer, void *pvRxData, size_t xBufferLengthBytes, TickType_t xTicksToWait ) FREERTOS_SYSTEM_CALL;

+size_t MPU_xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;

+void MPU_vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;

+size_t MPU_xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;

+size_t MPU_xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) FREERTOS_SYSTEM_CALL;

+BaseType_t MPU_xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer, size_t xTriggerLevel ) FREERTOS_SYSTEM_CALL;

+StreamBufferHandle_t MPU_xStreamBufferGenericCreate( size_t xBufferSizeBytes, size_t xTriggerLevelBytes, BaseType_t xIsMessageBuffer ) FREERTOS_SYSTEM_CALL;

+StreamBufferHandle_t MPU_xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes, size_t xTriggerLevelBytes, BaseType_t xIsMessageBuffer, uint8_t * const pucStreamBufferStorageArea, StaticStreamBuffer_t * const pxStaticStreamBuffer ) FREERTOS_SYSTEM_CALL;

+

+

+

+#endif /* MPU_PROTOTYPES_H */

+

diff --git a/src/FreeRTOS/Source/include/mpu_wrappers.h b/src/FreeRTOS/Source/include/mpu_wrappers.h
index 5b2ad47..879bad4 100644
--- a/src/FreeRTOS/Source/include/mpu_wrappers.h
+++ b/src/FreeRTOS/Source/include/mpu_wrappers.h
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 #ifndef MPU_WRAPPERS_H

 #define MPU_WRAPPERS_H

@@ -79,88 +37,138 @@ only for ports that are using the MPU. */
 	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 eTaskGetState					MPU_eTaskGetState

-		#define vTaskSuspend					MPU_vTaskSuspend

-		#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 xTaskGetIdleTaskHandle			MPU_xTaskGetIdleTaskHandle

-		#define uxTaskGetSystemState			MPU_uxTaskGetSystemState

-		#define xTaskGenericNotify				MPU_xTaskGenericNotify

-		#define xTaskNotifyWait					MPU_xTaskNotifyWait

-		#define ulTaskNotifyTake				MPU_ulTaskNotifyTake

-

-		#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 xQueueGenericReset				MPU_xQueueGenericReset

-		#define xQueueCreateSet					MPU_xQueueCreateSet

-		#define xQueueSelectFromSet				MPU_xQueueSelectFromSet

-		#define xQueueAddToSet					MPU_xQueueAddToSet

-		#define xQueueRemoveFromSet				MPU_xQueueRemoveFromSet

-		#define xQueueGetMutexHolder			MPU_xQueueGetMutexHolder

-		#define xQueueGetMutexHolder			MPU_xQueueGetMutexHolder

-

-		#define pvPortMalloc					MPU_pvPortMalloc

-		#define vPortFree						MPU_vPortFree

-		#define xPortGetFreeHeapSize			MPU_xPortGetFreeHeapSize

-		#define vPortInitialiseBlocks			MPU_vPortInitialiseBlocks

-		#define xPortGetMinimumEverFreeHeapSize	MPU_xPortGetMinimumEverFreeHeapSize

-

-		#if configQUEUE_REGISTRY_SIZE > 0

-			#define vQueueAddToRegistry				MPU_vQueueAddToRegistry

-			#define vQueueUnregisterQueue			MPU_vQueueUnregisterQueue

+		/*

+		 * Map standard (non MPU) API functions to equivalents that start

+		 * "MPU_".  This will cause the application code to call the MPU_

+		 * version, which wraps the non-MPU version with privilege promoting

+		 * then demoting code, so the kernel code always runs will full

+		 * privileges.

+		 */

+

+		/* Map standard tasks.h API functions to the MPU equivalents. */

+		#define xTaskCreate								MPU_xTaskCreate

+		#define xTaskCreateStatic						MPU_xTaskCreateStatic

+		#define xTaskCreateRestricted					MPU_xTaskCreateRestricted

+		#define vTaskAllocateMPURegions					MPU_vTaskAllocateMPURegions

+		#define vTaskDelete								MPU_vTaskDelete

+		#define vTaskDelay								MPU_vTaskDelay

+		#define vTaskDelayUntil							MPU_vTaskDelayUntil

+		#define xTaskAbortDelay							MPU_xTaskAbortDelay

+		#define uxTaskPriorityGet						MPU_uxTaskPriorityGet

+		#define eTaskGetState							MPU_eTaskGetState

+		#define vTaskGetInfo							MPU_vTaskGetInfo

+		#define vTaskPrioritySet						MPU_vTaskPrioritySet

+		#define vTaskSuspend							MPU_vTaskSuspend

+		#define vTaskResume								MPU_vTaskResume

+		#define vTaskSuspendAll							MPU_vTaskSuspendAll

+		#define xTaskResumeAll							MPU_xTaskResumeAll

+		#define xTaskGetTickCount						MPU_xTaskGetTickCount

+		#define uxTaskGetNumberOfTasks					MPU_uxTaskGetNumberOfTasks

+		#define pcTaskGetName							MPU_pcTaskGetName

+		#define xTaskGetHandle							MPU_xTaskGetHandle

+		#define uxTaskGetStackHighWaterMark				MPU_uxTaskGetStackHighWaterMark

+		#define uxTaskGetStackHighWaterMark2			MPU_uxTaskGetStackHighWaterMark2

+		#define vTaskSetApplicationTaskTag				MPU_vTaskSetApplicationTaskTag

+		#define xTaskGetApplicationTaskTag				MPU_xTaskGetApplicationTaskTag

+		#define vTaskSetThreadLocalStoragePointer		MPU_vTaskSetThreadLocalStoragePointer

+		#define pvTaskGetThreadLocalStoragePointer		MPU_pvTaskGetThreadLocalStoragePointer

+		#define xTaskCallApplicationTaskHook			MPU_xTaskCallApplicationTaskHook

+		#define xTaskGetIdleTaskHandle					MPU_xTaskGetIdleTaskHandle

+		#define uxTaskGetSystemState					MPU_uxTaskGetSystemState

+		#define vTaskList								MPU_vTaskList

+		#define vTaskGetRunTimeStats					MPU_vTaskGetRunTimeStats

+		#define xTaskGetIdleRunTimeCounter				MPU_xTaskGetIdleRunTimeCounter

+		#define xTaskGenericNotify						MPU_xTaskGenericNotify

+		#define xTaskNotifyWait							MPU_xTaskNotifyWait

+		#define ulTaskNotifyTake						MPU_ulTaskNotifyTake

+		#define xTaskNotifyStateClear					MPU_xTaskNotifyStateClear

+

+		#define xTaskGetCurrentTaskHandle				MPU_xTaskGetCurrentTaskHandle

+		#define vTaskSetTimeOutState					MPU_vTaskSetTimeOutState

+		#define xTaskCheckForTimeOut					MPU_xTaskCheckForTimeOut

+		#define xTaskGetSchedulerState					MPU_xTaskGetSchedulerState

+

+		/* Map standard queue.h API functions to the MPU equivalents. */

+		#define xQueueGenericSend						MPU_xQueueGenericSend

+		#define xQueueReceive							MPU_xQueueReceive

+		#define xQueuePeek								MPU_xQueuePeek

+		#define xQueueSemaphoreTake						MPU_xQueueSemaphoreTake

+		#define uxQueueMessagesWaiting					MPU_uxQueueMessagesWaiting

+		#define uxQueueSpacesAvailable					MPU_uxQueueSpacesAvailable

+		#define vQueueDelete							MPU_vQueueDelete

+		#define xQueueCreateMutex						MPU_xQueueCreateMutex

+		#define xQueueCreateMutexStatic					MPU_xQueueCreateMutexStatic

+		#define xQueueCreateCountingSemaphore			MPU_xQueueCreateCountingSemaphore

+		#define xQueueCreateCountingSemaphoreStatic		MPU_xQueueCreateCountingSemaphoreStatic

+		#define xQueueGetMutexHolder					MPU_xQueueGetMutexHolder

+		#define xQueueTakeMutexRecursive				MPU_xQueueTakeMutexRecursive

+		#define xQueueGiveMutexRecursive				MPU_xQueueGiveMutexRecursive

+		#define xQueueGenericCreate						MPU_xQueueGenericCreate

+		#define xQueueGenericCreateStatic				MPU_xQueueGenericCreateStatic

+		#define xQueueCreateSet							MPU_xQueueCreateSet

+		#define xQueueAddToSet							MPU_xQueueAddToSet

+		#define xQueueRemoveFromSet						MPU_xQueueRemoveFromSet

+		#define xQueueSelectFromSet						MPU_xQueueSelectFromSet

+		#define xQueueGenericReset						MPU_xQueueGenericReset

+

+		#if( configQUEUE_REGISTRY_SIZE > 0 )

+			#define vQueueAddToRegistry						MPU_vQueueAddToRegistry

+			#define vQueueUnregisterQueue					MPU_vQueueUnregisterQueue

+			#define pcQueueGetName							MPU_pcQueueGetName

 		#endif

 

-		#define xTimerCreate					MPU_xTimerCreate

-		#define pvTimerGetTimerID				MPU_pvTimerGetTimerID

-		#define vTimerSetTimerID				MPU_vTimerSetTimerID

-		#define xTimerIsTimerActive				MPU_xTimerIsTimerActive

-		#define xTimerGetTimerDaemonTaskHandle	MPU_xTimerGetTimerDaemonTaskHandle

-		#define xTimerPendFunctionCall			MPU_xTimerPendFunctionCall

-		#define pcTimerGetTimerName				MPU_pcTimerGetTimerName

-		#define xTimerGenericCommand			MPU_xTimerGenericCommand

-

-		#define xEventGroupCreate				MPU_xEventGroupCreate

-		#define xEventGroupWaitBits				MPU_xEventGroupWaitBits

-		#define xEventGroupClearBits			MPU_xEventGroupClearBits

-		#define xEventGroupSetBits				MPU_xEventGroupSetBits

-		#define xEventGroupSync					MPU_xEventGroupSync

-		#define vEventGroupDelete				MPU_vEventGroupDelete

-

-		/* Remove the privileged function macro. */

+		/* Map standard timer.h API functions to the MPU equivalents. */

+		#define xTimerCreate							MPU_xTimerCreate

+		#define xTimerCreateStatic						MPU_xTimerCreateStatic

+		#define pvTimerGetTimerID						MPU_pvTimerGetTimerID

+		#define vTimerSetTimerID						MPU_vTimerSetTimerID

+		#define xTimerIsTimerActive						MPU_xTimerIsTimerActive

+		#define xTimerGetTimerDaemonTaskHandle			MPU_xTimerGetTimerDaemonTaskHandle

+		#define xTimerPendFunctionCall					MPU_xTimerPendFunctionCall

+		#define pcTimerGetName							MPU_pcTimerGetName

+		#define vTimerSetReloadMode						MPU_vTimerSetReloadMode

+		#define xTimerGetPeriod							MPU_xTimerGetPeriod

+		#define xTimerGetExpiryTime						MPU_xTimerGetExpiryTime

+		#define xTimerGenericCommand					MPU_xTimerGenericCommand

+

+		/* Map standard event_group.h API functions to the MPU equivalents. */

+		#define xEventGroupCreate						MPU_xEventGroupCreate

+		#define xEventGroupCreateStatic					MPU_xEventGroupCreateStatic

+		#define xEventGroupWaitBits						MPU_xEventGroupWaitBits

+		#define xEventGroupClearBits					MPU_xEventGroupClearBits

+		#define xEventGroupSetBits						MPU_xEventGroupSetBits

+		#define xEventGroupSync							MPU_xEventGroupSync

+		#define vEventGroupDelete						MPU_vEventGroupDelete

+

+		/* Map standard message/stream_buffer.h API functions to the MPU

+		equivalents. */

+		#define xStreamBufferSend						MPU_xStreamBufferSend

+		#define xStreamBufferReceive					MPU_xStreamBufferReceive

+		#define xStreamBufferNextMessageLengthBytes		MPU_xStreamBufferNextMessageLengthBytes

+		#define vStreamBufferDelete						MPU_vStreamBufferDelete

+		#define xStreamBufferIsFull						MPU_xStreamBufferIsFull

+		#define xStreamBufferIsEmpty					MPU_xStreamBufferIsEmpty

+		#define xStreamBufferReset						MPU_xStreamBufferReset

+		#define xStreamBufferSpacesAvailable			MPU_xStreamBufferSpacesAvailable

+		#define xStreamBufferBytesAvailable				MPU_xStreamBufferBytesAvailable

+		#define xStreamBufferSetTriggerLevel			MPU_xStreamBufferSetTriggerLevel

+		#define xStreamBufferGenericCreate				MPU_xStreamBufferGenericCreate

+		#define xStreamBufferGenericCreateStatic		MPU_xStreamBufferGenericCreateStatic

+

+

+		/* Remove the privileged function macro, but keep the PRIVILEGED_DATA

+		macro so applications can place data in privileged access sections

+		(useful when using statically allocated objects). */

 		#define PRIVILEGED_FUNCTION

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

+		#define FREERTOS_SYSTEM_CALL

 

 	#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 FREERTOS_SYSTEM_CALL __attribute__((section( "freertos_system_calls")))

 

 	#endif /* MPU_WRAPPERS_INCLUDED_FROM_API_FILE */

 

@@ -168,6 +176,7 @@ only for ports that are using the MPU. */
 

 	#define PRIVILEGED_FUNCTION

 	#define PRIVILEGED_DATA

+	#define FREERTOS_SYSTEM_CALL

 	#define portUSING_MPU_WRAPPERS 0

 

 #endif /* portUSING_MPU_WRAPPERS */

diff --git a/src/FreeRTOS/Source/include/portable.h b/src/FreeRTOS/Source/include/portable.h
index cd6a934..51ef6d6 100644
--- a/src/FreeRTOS/Source/include/portable.h
+++ b/src/FreeRTOS/Source/include/portable.h
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

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

  * Portable layer API.  Each function must be defined for each port.

@@ -139,9 +97,17 @@ extern "C" {
  *

  */

 #if( portUSING_MPU_WRAPPERS == 1 )

-	StackType_t *pxPortInitialiseStack( StackType_t *pxTopOfStack, TaskFunction_t pxCode, void *pvParameters, BaseType_t xRunPrivileged ) PRIVILEGED_FUNCTION;

+	#if( portHAS_STACK_OVERFLOW_CHECKING == 1 )

+		StackType_t *pxPortInitialiseStack( StackType_t *pxTopOfStack, StackType_t *pxEndOfStack, TaskFunction_t pxCode, void *pvParameters, BaseType_t xRunPrivileged ) PRIVILEGED_FUNCTION;

+	#else

+		StackType_t *pxPortInitialiseStack( StackType_t *pxTopOfStack, TaskFunction_t pxCode, void *pvParameters, BaseType_t xRunPrivileged ) PRIVILEGED_FUNCTION;

+	#endif

 #else

-	StackType_t *pxPortInitialiseStack( StackType_t *pxTopOfStack, TaskFunction_t pxCode, void *pvParameters ) PRIVILEGED_FUNCTION;

+	#if( portHAS_STACK_OVERFLOW_CHECKING == 1 )

+		StackType_t *pxPortInitialiseStack( StackType_t *pxTopOfStack, StackType_t *pxEndOfStack, TaskFunction_t pxCode, void *pvParameters ) PRIVILEGED_FUNCTION;

+	#else

+		StackType_t *pxPortInitialiseStack( StackType_t *pxTopOfStack, TaskFunction_t pxCode, void *pvParameters ) PRIVILEGED_FUNCTION;

+	#endif

 #endif

 

 /* Used by heap_5.c. */

@@ -196,7 +162,7 @@ void vPortEndScheduler( void ) PRIVILEGED_FUNCTION;
  */

 #if( portUSING_MPU_WRAPPERS == 1 )

 	struct xMEMORY_REGION;

-	void vPortStoreTaskMPUSettings( xMPU_SETTINGS *xMPUSettings, const struct xMEMORY_REGION * const xRegions, StackType_t *pxBottomOfStack, uint16_t usStackDepth ) PRIVILEGED_FUNCTION;

+	void vPortStoreTaskMPUSettings( xMPU_SETTINGS *xMPUSettings, const struct xMEMORY_REGION * const xRegions, StackType_t *pxBottomOfStack, uint32_t ulStackDepth ) PRIVILEGED_FUNCTION;

 #endif

 

 #ifdef __cplusplus

diff --git a/src/FreeRTOS/Source/include/projdefs.h b/src/FreeRTOS/Source/include/projdefs.h
index 956264b..ce62c44 100644
--- a/src/FreeRTOS/Source/include/projdefs.h
+++ b/src/FreeRTOS/Source/include/projdefs.h
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 #ifndef PROJDEFS_H

 #define PROJDEFS_H

@@ -76,8 +34,12 @@
  */

 typedef void (*TaskFunction_t)( void * );

 

-/* Converts a time in milliseconds to a time in ticks. */

-#define pdMS_TO_TICKS( xTimeInMs ) ( ( TickType_t ) ( ( ( TickType_t ) ( xTimeInMs ) * ( TickType_t ) configTICK_RATE_HZ ) / ( TickType_t ) 1000 ) )

+/* Converts a time in milliseconds to a time in ticks.  This macro can be

+overridden by a macro of the same name defined in FreeRTOSConfig.h in case the

+definition here is not suitable for your application. */

+#ifndef pdMS_TO_TICKS

+	#define pdMS_TO_TICKS( xTimeInMs ) ( ( TickType_t ) ( ( ( TickType_t ) ( xTimeInMs ) * ( TickType_t ) configTICK_RATE_HZ ) / ( TickType_t ) 1000 ) )

+#endif

 

 #define pdFALSE			( ( BaseType_t ) 0 )

 #define pdTRUE			( ( BaseType_t ) 1 )

@@ -107,6 +69,7 @@ typedef void (*TaskFunction_t)( void * );
 itself. */

 #define pdFREERTOS_ERRNO_NONE			0	/* No errors */

 #define	pdFREERTOS_ERRNO_ENOENT			2	/* No such file or directory */

+#define	pdFREERTOS_ERRNO_EINTR			4	/* Interrupted system call */

 #define	pdFREERTOS_ERRNO_EIO			5	/* I/O error */

 #define	pdFREERTOS_ERRNO_ENXIO			6	/* No such device or address */

 #define	pdFREERTOS_ERRNO_EBADF			9	/* Bad file number */

@@ -147,8 +110,13 @@ itself. */
 

 /* The following endian values are used by FreeRTOS+ components, not FreeRTOS

 itself. */

-#define pdFREERTOS_LITTLE_ENDIAN	0

-#define pdFREERTOS_BIG_ENDIAN		1

+#define pdFREERTOS_LITTLE_ENDIAN		0

+#define pdFREERTOS_BIG_ENDIAN			1

+

+/* Re-defining endian values for generic naming. */

+#define pdLITTLE_ENDIAN					pdFREERTOS_LITTLE_ENDIAN

+#define pdBIG_ENDIAN					pdFREERTOS_BIG_ENDIAN

+

 

 #endif /* PROJDEFS_H */

 

diff --git a/src/FreeRTOS/Source/include/queue.h b/src/FreeRTOS/Source/include/queue.h
index 2d7b5e9..5b1e35c 100644
--- a/src/FreeRTOS/Source/include/queue.h
+++ b/src/FreeRTOS/Source/include/queue.h
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 

 #ifndef QUEUE_H

@@ -79,27 +37,29 @@
 extern "C" {

 #endif

 

+#include "task.h"

 

 /**

  * Type by which queues are referenced.  For example, a call to xQueueCreate()

  * returns an QueueHandle_t variable that can then be used as a parameter to

  * xQueueSend(), xQueueReceive(), etc.

  */

-typedef void * QueueHandle_t;

+struct QueueDefinition; /* Using old naming convention so as not to break kernel aware debuggers. */

+typedef struct QueueDefinition * QueueHandle_t;

 

 /**

  * Type by which queue sets are referenced.  For example, a call to

  * xQueueCreateSet() returns an xQueueSet variable that can then be used as a

  * parameter to xQueueSelectFromSet(), xQueueAddToSet(), etc.

  */

-typedef void * QueueSetHandle_t;

+typedef struct QueueDefinition * QueueSetHandle_t;

 

 /**

  * Queue sets can contain both queues and semaphores, so the

  * QueueSetMemberHandle_t is defined as a type to be used where a parameter or

  * return value can be either an QueueHandle_t or an SemaphoreHandle_t.

  */

-typedef void * QueueSetMemberHandle_t;

+typedef struct QueueDefinition * QueueSetMemberHandle_t;

 

 /* For internal use only. */

 #define	queueSEND_TO_BACK		( ( BaseType_t ) 0 )

@@ -123,8 +83,20 @@ typedef void * QueueSetMemberHandle_t;
 						  );

  * </pre>

  *

- * Creates a new queue instance.  This allocates the storage required by the

- * new queue and returns a handle for the queue.

+ * Creates a new queue instance, and returns a handle by which the new queue

+ * can be referenced.

+ *

+ * Internally, within the FreeRTOS implementation, queues use two blocks of

+ * memory.  The first block is used to hold the queue's data structures.  The

+ * second block is used to hold items placed into the queue.  If a queue is

+ * created using xQueueCreate() then both blocks of memory are automatically

+ * dynamically allocated inside the xQueueCreate() function.  (see

+ * http://www.freertos.org/a00111.html).  If a queue is created using

+ * xQueueCreateStatic() then the application writer must provide the memory that

+ * will get used by the queue.  xQueueCreateStatic() therefore allows a queue to

+ * be created without using any dynamic memory allocation.

+ *

+ * http://www.FreeRTOS.org/Embedded-RTOS-Queues.html

  *

  * @param uxQueueLength The maximum number of items that the queue can contain.

  *

@@ -170,7 +142,95 @@ typedef void * QueueSetMemberHandle_t;
  * \defgroup xQueueCreate xQueueCreate

  * \ingroup QueueManagement

  */

-#define xQueueCreate( uxQueueLength, uxItemSize ) xQueueGenericCreate( uxQueueLength, uxItemSize, queueQUEUE_TYPE_BASE )

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

+	#define xQueueCreate( uxQueueLength, uxItemSize ) xQueueGenericCreate( ( uxQueueLength ), ( uxItemSize ), ( queueQUEUE_TYPE_BASE ) )

+#endif

+

+/**

+ * queue. h

+ * <pre>

+ QueueHandle_t xQueueCreateStatic(

+							  UBaseType_t uxQueueLength,

+							  UBaseType_t uxItemSize,

+							  uint8_t *pucQueueStorageBuffer,

+							  StaticQueue_t *pxQueueBuffer

+						  );

+ * </pre>

+ *

+ * Creates a new queue instance, and returns a handle by which the new queue

+ * can be referenced.

+ *

+ * Internally, within the FreeRTOS implementation, queues use two blocks of

+ * memory.  The first block is used to hold the queue's data structures.  The

+ * second block is used to hold items placed into the queue.  If a queue is

+ * created using xQueueCreate() then both blocks of memory are automatically

+ * dynamically allocated inside the xQueueCreate() function.  (see

+ * http://www.freertos.org/a00111.html).  If a queue is created using

+ * xQueueCreateStatic() then the application writer must provide the memory that

+ * will get used by the queue.  xQueueCreateStatic() therefore allows a queue to

+ * be created without using any dynamic memory allocation.

+ *

+ * http://www.FreeRTOS.org/Embedded-RTOS-Queues.html

+ *

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

+ *

+ * @param pucQueueStorageBuffer If uxItemSize is not zero then

+ * pucQueueStorageBuffer must point to a uint8_t array that is at least large

+ * enough to hold the maximum number of items that can be in the queue at any

+ * one time - which is ( uxQueueLength * uxItemsSize ) bytes.  If uxItemSize is

+ * zero then pucQueueStorageBuffer can be NULL.

+ *

+ * @param pxQueueBuffer Must point to a variable of type StaticQueue_t, which

+ * will be used to hold the queue's data structure.

+ *

+ * @return If the queue is created then a handle to the created queue is

+ * returned.  If pxQueueBuffer is NULL then NULL is returned.

+ *

+ * Example usage:

+   <pre>

+ struct AMessage

+ {

+	char ucMessageID;

+	char ucData[ 20 ];

+ };

+

+ #define QUEUE_LENGTH 10

+ #define ITEM_SIZE sizeof( uint32_t )

+

+ // xQueueBuffer will hold the queue structure.

+ StaticQueue_t xQueueBuffer;

+

+ // ucQueueStorage will hold the items posted to the queue.  Must be at least

+ // [(queue length) * ( queue item size)] bytes long.

+ uint8_t ucQueueStorage[ QUEUE_LENGTH * ITEM_SIZE ];

+

+ void vATask( void *pvParameters )

+ {

+ QueueHandle_t xQueue1;

+

+	// Create a queue capable of containing 10 uint32_t values.

+	xQueue1 = xQueueCreate( QUEUE_LENGTH, // The number of items the queue can hold.

+							ITEM_SIZE	  // The size of each item in the queue

+							&( ucQueueStorage[ 0 ] ), // The buffer that will hold the items in the queue.

+							&xQueueBuffer ); // The buffer that will hold the queue structure.

+

+	// The queue is guaranteed to be created successfully as no dynamic memory

+	// allocation is used.  Therefore xQueue1 is now a handle to a valid queue.

+

+	// ... Rest of task code.

+ }

+ </pre>

+ * \defgroup xQueueCreateStatic xQueueCreateStatic

+ * \ingroup QueueManagement

+ */

+#if( configSUPPORT_STATIC_ALLOCATION == 1 )

+	#define xQueueCreateStatic( uxQueueLength, uxItemSize, pucQueueStorage, pxQueueBuffer ) xQueueGenericCreateStatic( ( uxQueueLength ), ( uxItemSize ), ( pucQueueStorage ), ( pxQueueBuffer ), ( queueQUEUE_TYPE_BASE ) )

+#endif /* configSUPPORT_STATIC_ALLOCATION */

 

 /**

  * queue. h

@@ -182,8 +242,6 @@ typedef void * QueueSetMemberHandle_t;
 							   );

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

@@ -596,12 +654,10 @@ BaseType_t xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQ
  * <pre>

  BaseType_t xQueuePeek(

 							 QueueHandle_t xQueue,

-							 void *pvBuffer,

+							 void * const pvBuffer,

 							 TickType_t 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

@@ -682,10 +738,10 @@ BaseType_t xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQ
 	// ... Rest of task code.

  }

  </pre>

- * \defgroup xQueueReceive xQueueReceive

+ * \defgroup xQueuePeek xQueuePeek

  * \ingroup QueueManagement

  */

-#define xQueuePeek( xQueue, pvBuffer, xTicksToWait ) xQueueGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdTRUE )

+BaseType_t xQueuePeek( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;

 

 /**

  * queue. h

@@ -729,8 +785,6 @@ BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue, void * const pvBuffer ) PRIV
 								 TickType_t 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.

@@ -811,106 +865,7 @@ BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue, void * const pvBuffer ) PRIV
  * \defgroup xQueueReceive xQueueReceive

  * \ingroup QueueManagement

  */

-#define xQueueReceive( xQueue, pvBuffer, xTicksToWait ) xQueueGenericReceive( ( xQueue ), ( pvBuffer ), ( xTicksToWait ), pdFALSE )

-

-

-/**

- * queue. h

- * <pre>

- BaseType_t xQueueGenericReceive(

-									   QueueHandle_t	xQueue,

-									   void	*pvBuffer,

-									   TickType_t	xTicksToWait

-									   BaseType_t	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 xQueue 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_PERIOD_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;

-

- QueueHandle_t 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, ( TickType_t ) 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 ), ( TickType_t ) 10 ) )

-		{

-			// pcRxedMessage now points to the struct AMessage variable posted

-			// by vATask.

-		}

-	}

-

-	// ... Rest of task code.

- }

- </pre>

- * \defgroup xQueueReceive xQueueReceive

- * \ingroup QueueManagement

- */

-BaseType_t xQueueGenericReceive( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait, const BaseType_t xJustPeek ) PRIVILEGED_FUNCTION;

+BaseType_t xQueueReceive( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;

 

 /**

  * queue. h

@@ -1437,28 +1392,6 @@ BaseType_t xQueueIsQueueEmptyFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FU
 BaseType_t xQueueIsQueueFullFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;

 UBaseType_t uxQueueMessagesWaitingFromISR( const QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;

 

-

-/*

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

- */

-BaseType_t xQueueAltGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, BaseType_t xCopyPosition ) PRIVILEGED_FUNCTION;

-BaseType_t xQueueAltGenericReceive( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait, BaseType_t xJustPeeking ) PRIVILEGED_FUNCTION;

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

@@ -1479,15 +1412,19 @@ BaseType_t xQueueCRReceive( QueueHandle_t xQueue, void *pvBuffer, TickType_t xTi
  * these functions directly.

  */

 QueueHandle_t xQueueCreateMutex( const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;

+QueueHandle_t xQueueCreateMutexStatic( const uint8_t ucQueueType, StaticQueue_t *pxStaticQueue ) PRIVILEGED_FUNCTION;

 QueueHandle_t xQueueCreateCountingSemaphore( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount ) PRIVILEGED_FUNCTION;

-void* xQueueGetMutexHolder( QueueHandle_t xSemaphore ) PRIVILEGED_FUNCTION;

+QueueHandle_t xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount, StaticQueue_t *pxStaticQueue ) PRIVILEGED_FUNCTION;

+BaseType_t xQueueSemaphoreTake( QueueHandle_t xQueue, TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;

+TaskHandle_t xQueueGetMutexHolder( QueueHandle_t xSemaphore ) PRIVILEGED_FUNCTION;

+TaskHandle_t xQueueGetMutexHolderFromISR( QueueHandle_t xSemaphore ) PRIVILEGED_FUNCTION;

 

 /*

  * For internal use only.  Use xSemaphoreTakeMutexRecursive() or

  * xSemaphoreGiveMutexRecursive() instead of calling these functions directly.

  */

 BaseType_t xQueueTakeMutexRecursive( QueueHandle_t xMutex, TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;

-BaseType_t xQueueGiveMutexRecursive( QueueHandle_t pxMutex ) PRIVILEGED_FUNCTION;

+BaseType_t xQueueGiveMutexRecursive( QueueHandle_t xMutex ) PRIVILEGED_FUNCTION;

 

 /*

  * Reset a queue back to its original empty state.  The return value is now

@@ -1517,8 +1454,8 @@ BaseType_t xQueueGiveMutexRecursive( QueueHandle_t pxMutex ) PRIVILEGED_FUNCTION
  * stores a pointer to the string - so the string must be persistent (global or

  * preferably in ROM/Flash), not on the stack.

  */

-#if configQUEUE_REGISTRY_SIZE > 0

-	void vQueueAddToRegistry( QueueHandle_t xQueue, const char *pcName ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+#if( configQUEUE_REGISTRY_SIZE > 0 )

+	void vQueueAddToRegistry( QueueHandle_t xQueue, const char *pcQueueName ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

 #endif

 

 /*

@@ -1531,15 +1468,42 @@ BaseType_t xQueueGiveMutexRecursive( QueueHandle_t pxMutex ) PRIVILEGED_FUNCTION
  *

  * @param xQueue The handle of the queue being removed from the registry.

  */

-#if configQUEUE_REGISTRY_SIZE > 0

+#if( configQUEUE_REGISTRY_SIZE > 0 )

 	void vQueueUnregisterQueue( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION;

 #endif

 

 /*

- * Generic version of the queue creation function, which is in turn called by

- * any queue, semaphore or mutex creation function or macro.

+ * The queue registry is provided as a means for kernel aware debuggers to

+ * locate queues, semaphores and mutexes.  Call pcQueueGetName() to look

+ * up and return the name of a queue in the queue registry from the queue's

+ * handle.

+ *

+ * @param xQueue The handle of the queue the name of which will be returned.

+ * @return If the queue is in the registry then a pointer to the name of the

+ * queue is returned.  If the queue is not in the registry then NULL is

+ * returned.

+ */

+#if( configQUEUE_REGISTRY_SIZE > 0 )

+	const char *pcQueueGetName( QueueHandle_t xQueue ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+#endif

+

+/*

+ * Generic version of the function used to creaet a queue using dynamic memory

+ * allocation.  This is called by other functions and macros that create other

+ * RTOS objects that use the queue structure as their base.

  */

-QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

+	QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;

+#endif

+

+/*

+ * Generic version of the function used to creaet a queue using dynamic memory

+ * allocation.  This is called by other functions and macros that create other

+ * RTOS objects that use the queue structure as their base.

+ */

+#if( configSUPPORT_STATIC_ALLOCATION == 1 )

+	QueueHandle_t xQueueGenericCreateStatic( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, StaticQueue_t *pxStaticQueue, const uint8_t ucQueueType ) PRIVILEGED_FUNCTION;

+#endif

 

 /*

  * Queue sets provide a mechanism to allow a task to block (pend) on a read

diff --git a/src/FreeRTOS/Source/include/semphr.h b/src/FreeRTOS/Source/include/semphr.h
index ab00d09..827a877 100644
--- a/src/FreeRTOS/Source/include/semphr.h
+++ b/src/FreeRTOS/Source/include/semphr.h
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 #ifndef SEMAPHORE_H

 #define SEMAPHORE_H

@@ -87,6 +45,10 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * semphr. h

  * <pre>vSemaphoreCreateBinary( SemaphoreHandle_t xSemaphore )</pre>

  *

+ * In many usage scenarios it is faster and more memory efficient to use a

+ * direct to task notification in place of a binary semaphore!

+ * http://www.freertos.org/RTOS-task-notifications.html

+ *

  * This old vSemaphoreCreateBinary() macro is now deprecated in favour of the

  * xSemaphoreCreateBinary() function.  Note that binary semaphores created using

  * the vSemaphoreCreateBinary() macro are created in a state such that the

@@ -128,19 +90,37 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * \defgroup vSemaphoreCreateBinary vSemaphoreCreateBinary

  * \ingroup Semaphores

  */

-#define vSemaphoreCreateBinary( xSemaphore )																							\

-	{																																	\

-		( xSemaphore ) = xQueueGenericCreate( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_BINARY_SEMAPHORE );	\

-		if( ( xSemaphore ) != NULL )																									\

-		{																																\

-			( void ) xSemaphoreGive( ( xSemaphore ) );																					\

-		}																																\

-	}

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

+	#define vSemaphoreCreateBinary( xSemaphore )																							\

+		{																																	\

+			( xSemaphore ) = xQueueGenericCreate( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_BINARY_SEMAPHORE );	\

+			if( ( xSemaphore ) != NULL )																									\

+			{																																\

+				( void ) xSemaphoreGive( ( xSemaphore ) );																					\

+			}																																\

+		}

+#endif

 

 /**

  * semphr. h

  * <pre>SemaphoreHandle_t xSemaphoreCreateBinary( void )</pre>

  *

+ * Creates a new binary semaphore instance, and returns a handle by which the

+ * new semaphore can be referenced.

+ *

+ * In many usage scenarios it is faster and more memory efficient to use a

+ * direct to task notification in place of a binary semaphore!

+ * http://www.freertos.org/RTOS-task-notifications.html

+ *

+ * Internally, within the FreeRTOS implementation, binary semaphores use a block

+ * of memory, in which the semaphore structure is stored.  If a binary semaphore

+ * is created using xSemaphoreCreateBinary() then the required memory is

+ * automatically dynamically allocated inside the xSemaphoreCreateBinary()

+ * function.  (see http://www.freertos.org/a00111.html).  If a binary semaphore

+ * is created using xSemaphoreCreateBinaryStatic() then the application writer

+ * must provide the memory.  xSemaphoreCreateBinaryStatic() therefore allows a

+ * binary semaphore to be created without using any dynamic memory allocation.

+ *

  * The old vSemaphoreCreateBinary() macro is now deprecated in favour of this

  * xSemaphoreCreateBinary() function.  Note that binary semaphores created using

  * the vSemaphoreCreateBinary() macro are created in a state such that the

@@ -148,11 +128,6 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * created using xSemaphoreCreateBinary() are created in a state such that the

  * the semaphore must first be 'given' before it can be 'taken'.

  *

- * Function that creates 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 nothing is actually stored - all that is important is whether the queue is

- * empty or full (the binary semaphore is available or not).

- *

  * 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

@@ -160,7 +135,8 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * semaphore does not use a priority inheritance mechanism.  For an alternative

  * that does use priority inheritance see xSemaphoreCreateMutex().

  *

- * @return Handle to the created semaphore.

+ * @return Handle to the created semaphore, or NULL if the memory required to

+ * hold the semaphore's data structures could not be allocated.

  *

  * Example usage:

  <pre>

@@ -168,7 +144,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
 

  void vATask( void * pvParameters )

  {

-    // Semaphore cannot be used before a call to vSemaphoreCreateBinary ().

+    // Semaphore cannot be used before a call to xSemaphoreCreateBinary().

     // This is a macro so pass the variable in directly.

     xSemaphore = xSemaphoreCreateBinary();

 

@@ -179,10 +155,71 @@ typedef QueueHandle_t SemaphoreHandle_t;
     }

  }

  </pre>

- * \defgroup vSemaphoreCreateBinary vSemaphoreCreateBinary

+ * \defgroup xSemaphoreCreateBinary xSemaphoreCreateBinary

+ * \ingroup Semaphores

+ */

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

+	#define xSemaphoreCreateBinary() xQueueGenericCreate( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_BINARY_SEMAPHORE )

+#endif

+

+/**

+ * semphr. h

+ * <pre>SemaphoreHandle_t xSemaphoreCreateBinaryStatic( StaticSemaphore_t *pxSemaphoreBuffer )</pre>

+ *

+ * Creates a new binary semaphore instance, and returns a handle by which the

+ * new semaphore can be referenced.

+ *

+ * NOTE: In many usage scenarios it is faster and more memory efficient to use a

+ * direct to task notification in place of a binary semaphore!

+ * http://www.freertos.org/RTOS-task-notifications.html

+ *

+ * Internally, within the FreeRTOS implementation, binary semaphores use a block

+ * of memory, in which the semaphore structure is stored.  If a binary semaphore

+ * is created using xSemaphoreCreateBinary() then the required memory is

+ * automatically dynamically allocated inside the xSemaphoreCreateBinary()

+ * function.  (see http://www.freertos.org/a00111.html).  If a binary semaphore

+ * is created using xSemaphoreCreateBinaryStatic() then the application writer

+ * must provide the memory.  xSemaphoreCreateBinaryStatic() therefore allows a

+ * binary semaphore to be created without using any dynamic memory allocation.

+ *

+ * 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 pxSemaphoreBuffer Must point to a variable of type StaticSemaphore_t,

+ * which will then be used to hold the semaphore's data structure, removing the

+ * need for the memory to be allocated dynamically.

+ *

+ * @return If the semaphore is created then a handle to the created semaphore is

+ * returned.  If pxSemaphoreBuffer is NULL then NULL is returned.

+ *

+ * Example usage:

+ <pre>

+ SemaphoreHandle_t xSemaphore = NULL;

+ StaticSemaphore_t xSemaphoreBuffer;

+

+ void vATask( void * pvParameters )

+ {

+    // Semaphore cannot be used before a call to xSemaphoreCreateBinary().

+    // The semaphore's data structures will be placed in the xSemaphoreBuffer

+    // variable, the address of which is passed into the function.  The

+    // function's parameter is not NULL, so the function will not attempt any

+    // dynamic memory allocation, and therefore the function will not return

+    // return NULL.

+    xSemaphore = xSemaphoreCreateBinary( &xSemaphoreBuffer );

+

+    // Rest of task code goes here.

+ }

+ </pre>

+ * \defgroup xSemaphoreCreateBinaryStatic xSemaphoreCreateBinaryStatic

  * \ingroup Semaphores

  */

-#define xSemaphoreCreateBinary() xQueueGenericCreate( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, queueQUEUE_TYPE_BINARY_SEMAPHORE )

+#if( configSUPPORT_STATIC_ALLOCATION == 1 )

+	#define xSemaphoreCreateBinaryStatic( pxStaticSemaphore ) xQueueGenericCreateStatic( ( UBaseType_t ) 1, semSEMAPHORE_QUEUE_ITEM_LENGTH, NULL, pxStaticSemaphore, queueQUEUE_TYPE_BINARY_SEMAPHORE )

+#endif /* configSUPPORT_STATIC_ALLOCATION */

 

 /**

  * semphr. h

@@ -192,7 +229,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  *               )</pre>

  *

  * <i>Macro</i> to obtain a semaphore.  The semaphore must have previously been

- * created with a call to vSemaphoreCreateBinary(), xSemaphoreCreateMutex() or

+ * created with a call to xSemaphoreCreateBinary(), xSemaphoreCreateMutex() or

  * xSemaphoreCreateCounting().

  *

  * @param xSemaphore A handle to the semaphore being taken - obtained when

@@ -215,7 +252,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  void vATask( void * pvParameters )

  {

     // Create the semaphore to guard a shared resource.

-    vSemaphoreCreateBinary( xSemaphore );

+    xSemaphore = xSemaphoreCreateBinary();

  }

 

  // A task that uses the semaphore.

@@ -249,7 +286,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * \defgroup xSemaphoreTake xSemaphoreTake

  * \ingroup Semaphores

  */

-#define xSemaphoreTake( xSemaphore, xBlockTime )		xQueueGenericReceive( ( QueueHandle_t ) ( xSemaphore ), NULL, ( xBlockTime ), pdFALSE )

+#define xSemaphoreTake( xSemaphore, xBlockTime )		xQueueSemaphoreTake( ( xSemaphore ), ( xBlockTime ) )

 

 /**

  * semphr. h

@@ -313,23 +350,23 @@ typedef QueueHandle_t SemaphoreHandle_t;
 

             // ...

             // 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() 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, ( TickType_t ) 10 );

             xSemaphoreTakeRecursive( xMutex, ( TickType_t ) 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.

+            // 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 );

-			xSemaphoreGiveRecursive( xMutex );

-			xSemaphoreGiveRecursive( xMutex );

 

-			// Now the mutex can be taken by other tasks.

+            // Now the mutex can be taken by other tasks.

         }

         else

         {

@@ -342,29 +379,16 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * \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( ( QueueHandle_t ) ( xSemaphore ), NULL, ( xBlockTime ), pdFALSE )

+#if( configUSE_RECURSIVE_MUTEXES == 1 )

+	#define xSemaphoreTakeRecursive( xMutex, xBlockTime )	xQueueTakeMutexRecursive( ( xMutex ), ( xBlockTime ) )

+#endif

 

 /**

  * semphr. h

  * <pre>xSemaphoreGive( SemaphoreHandle_t xSemaphore )</pre>

  *

  * <i>Macro</i> to release a semaphore.  The semaphore must have previously been

- * created with a call to vSemaphoreCreateBinary(), xSemaphoreCreateMutex() or

+ * created with a call to xSemaphoreCreateBinary(), xSemaphoreCreateMutex() or

  * xSemaphoreCreateCounting(). and obtained using sSemaphoreTake().

  *

  * This macro must not be used from an ISR.  See xSemaphoreGiveFromISR () for

@@ -388,7 +412,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
  void vATask( void * pvParameters )

  {

     // Create the semaphore to guard a shared resource.

-    vSemaphoreCreateBinary( xSemaphore );

+    xSemaphore = vSemaphoreCreateBinary();

 

     if( xSemaphore != NULL )

     {

@@ -504,21 +528,9 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * \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( ( QueueHandle_t ) ( xSemaphore ), NULL, semGIVE_BLOCK_TIME, queueSEND_TO_BACK )

+#if( configUSE_RECURSIVE_MUTEXES == 1 )

+	#define xSemaphoreGiveRecursive( xMutex )	xQueueGiveMutexRecursive( ( xMutex ) )

+#endif

 

 /**

  * semphr. h

@@ -529,7 +541,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
                       )</pre>

  *

  * <i>Macro</i> to  release a semaphore.  The semaphore must have previously been

- * created with a call to vSemaphoreCreateBinary() or xSemaphoreCreateCounting().

+ * created with a call to xSemaphoreCreateBinary() or xSemaphoreCreateCounting().

  *

  * Mutex type semaphores (those created using a call to xSemaphoreCreateMutex())

  * must not be used with this macro.

@@ -620,7 +632,7 @@ typedef QueueHandle_t SemaphoreHandle_t;
                       )</pre>

  *

  * <i>Macro</i> to  take a semaphore from an ISR.  The semaphore must have

- * previously been created with a call to vSemaphoreCreateBinary() or

+ * previously been created with a call to xSemaphoreCreateBinary() or

  * xSemaphoreCreateCounting().

  *

  * Mutex type semaphores (those created using a call to xSemaphoreCreateMutex())

@@ -649,12 +661,21 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * semphr. h

  * <pre>SemaphoreHandle_t xSemaphoreCreateMutex( void )</pre>

  *

- * <i>Macro</i> that implements a mutex semaphore by using the existing queue

- * mechanism.

+ * Creates a new mutex type semaphore instance, and returns a handle by which

+ * the new mutex can be referenced.

  *

- * Mutexes created using this macro can be accessed using the xSemaphoreTake()

+ * Internally, within the FreeRTOS implementation, mutex semaphores use a block

+ * of memory, in which the mutex structure is stored.  If a mutex is created

+ * using xSemaphoreCreateMutex() then the required memory is automatically

+ * dynamically allocated inside the xSemaphoreCreateMutex() function.  (see

+ * http://www.freertos.org/a00111.html).  If a mutex is created using

+ * xSemaphoreCreateMutexStatic() then the application writer must provided the

+ * memory.  xSemaphoreCreateMutexStatic() therefore allows a mutex to be created

+ * without using any dynamic memory allocation.

+ *

+ * Mutexes created using this function can be accessed using the xSemaphoreTake()

  * and xSemaphoreGive() macros.  The xSemaphoreTakeRecursive() and

- * xSemaphoreGiveRecursive() macros should not be used.

+ * xSemaphoreGiveRecursive() macros must 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

@@ -662,13 +683,14 @@ typedef QueueHandle_t SemaphoreHandle_t;
  *

  * Mutex type semaphores cannot be used from within interrupt service routines.

  *

- * See vSemaphoreCreateBinary() for an alternative implementation that can be

+ * See xSemaphoreCreateBinary() 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

- *		SemaphoreHandle_t.

+ * @return If the mutex was successfully created then a handle to the created

+ * semaphore is returned.  If there was not enough heap to allocate the mutex

+ * data structures then NULL is returned.

  *

  * Example usage:

  <pre>

@@ -687,22 +709,96 @@ typedef QueueHandle_t SemaphoreHandle_t;
     }

  }

  </pre>

- * \defgroup vSemaphoreCreateMutex vSemaphoreCreateMutex

+ * \defgroup xSemaphoreCreateMutex xSemaphoreCreateMutex

+ * \ingroup Semaphores

+ */

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

+	#define xSemaphoreCreateMutex() xQueueCreateMutex( queueQUEUE_TYPE_MUTEX )

+#endif

+

+/**

+ * semphr. h

+ * <pre>SemaphoreHandle_t xSemaphoreCreateMutexStatic( StaticSemaphore_t *pxMutexBuffer )</pre>

+ *

+ * Creates a new mutex type semaphore instance, and returns a handle by which

+ * the new mutex can be referenced.

+ *

+ * Internally, within the FreeRTOS implementation, mutex semaphores use a block

+ * of memory, in which the mutex structure is stored.  If a mutex is created

+ * using xSemaphoreCreateMutex() then the required memory is automatically

+ * dynamically allocated inside the xSemaphoreCreateMutex() function.  (see

+ * http://www.freertos.org/a00111.html).  If a mutex is created using

+ * xSemaphoreCreateMutexStatic() then the application writer must provided the

+ * memory.  xSemaphoreCreateMutexStatic() therefore allows a mutex to be created

+ * without using any dynamic memory allocation.

+ *

+ * Mutexes created using this function can be accessed using the xSemaphoreTake()

+ * and xSemaphoreGive() macros.  The xSemaphoreTakeRecursive() and

+ * xSemaphoreGiveRecursive() macros must 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 xSemaphoreCreateBinary() 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.

+ *

+ * @param pxMutexBuffer Must point to a variable of type StaticSemaphore_t,

+ * which will be used to hold the mutex's data structure, removing the need for

+ * the memory to be allocated dynamically.

+ *

+ * @return If the mutex was successfully created then a handle to the created

+ * mutex is returned.  If pxMutexBuffer was NULL then NULL is returned.

+ *

+ * Example usage:

+ <pre>

+ SemaphoreHandle_t xSemaphore;

+ StaticSemaphore_t xMutexBuffer;

+

+ void vATask( void * pvParameters )

+ {

+    // A mutex cannot be used before it has been created.  xMutexBuffer is

+    // into xSemaphoreCreateMutexStatic() so no dynamic memory allocation is

+    // attempted.

+    xSemaphore = xSemaphoreCreateMutexStatic( &xMutexBuffer );

+

+    // As no dynamic memory allocation was performed, xSemaphore cannot be NULL,

+    // so there is no need to check it.

+ }

+ </pre>

+ * \defgroup xSemaphoreCreateMutexStatic xSemaphoreCreateMutexStatic

  * \ingroup Semaphores

  */

-#define xSemaphoreCreateMutex() xQueueCreateMutex( queueQUEUE_TYPE_MUTEX )

+ #if( configSUPPORT_STATIC_ALLOCATION == 1 )

+	#define xSemaphoreCreateMutexStatic( pxMutexBuffer ) xQueueCreateMutexStatic( queueQUEUE_TYPE_MUTEX, ( pxMutexBuffer ) )

+#endif /* configSUPPORT_STATIC_ALLOCATION */

 

 

 /**

  * semphr. h

  * <pre>SemaphoreHandle_t xSemaphoreCreateRecursiveMutex( void )</pre>

  *

- * <i>Macro</i> that implements a recursive mutex by using the existing queue

- * mechanism.

+ * Creates a new recursive mutex type semaphore instance, and returns a handle

+ * by which the new recursive mutex can be referenced.

+ *

+ * Internally, within the FreeRTOS implementation, recursive mutexs use a block

+ * of memory, in which the mutex structure is stored.  If a recursive mutex is

+ * created using xSemaphoreCreateRecursiveMutex() then the required memory is

+ * automatically dynamically allocated inside the

+ * xSemaphoreCreateRecursiveMutex() function.  (see

+ * http://www.freertos.org/a00111.html).  If a recursive mutex is created using

+ * xSemaphoreCreateRecursiveMutexStatic() then the application writer must

+ * provide the memory that will get used by the mutex.

+ * xSemaphoreCreateRecursiveMutexStatic() therefore allows a recursive mutex to

+ * be created without using any dynamic memory allocation.

  *

  * Mutexes created using this macro can be accessed using the

  * xSemaphoreTakeRecursive() and xSemaphoreGiveRecursive() macros.  The

- * xSemaphoreTake() and xSemaphoreGive() macros should not be used.

+ * xSemaphoreTake() and xSemaphoreGive() macros must 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

@@ -717,13 +813,13 @@ typedef QueueHandle_t SemaphoreHandle_t;
  *

  * Mutex type semaphores cannot be used from within interrupt service routines.

  *

- * See vSemaphoreCreateBinary() for an alternative implementation that can be

+ * See xSemaphoreCreateBinary() 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

- *		SemaphoreHandle_t.

+ * SemaphoreHandle_t.

  *

  * Example usage:

  <pre>

@@ -742,17 +838,107 @@ typedef QueueHandle_t SemaphoreHandle_t;
     }

  }

  </pre>

- * \defgroup vSemaphoreCreateMutex vSemaphoreCreateMutex

+ * \defgroup xSemaphoreCreateRecursiveMutex xSemaphoreCreateRecursiveMutex

+ * \ingroup Semaphores

+ */

+#if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configUSE_RECURSIVE_MUTEXES == 1 ) )

+	#define xSemaphoreCreateRecursiveMutex() xQueueCreateMutex( queueQUEUE_TYPE_RECURSIVE_MUTEX )

+#endif

+

+/**

+ * semphr. h

+ * <pre>SemaphoreHandle_t xSemaphoreCreateRecursiveMutexStatic( StaticSemaphore_t *pxMutexBuffer )</pre>

+ *

+ * Creates a new recursive mutex type semaphore instance, and returns a handle

+ * by which the new recursive mutex can be referenced.

+ *

+ * Internally, within the FreeRTOS implementation, recursive mutexs use a block

+ * of memory, in which the mutex structure is stored.  If a recursive mutex is

+ * created using xSemaphoreCreateRecursiveMutex() then the required memory is

+ * automatically dynamically allocated inside the

+ * xSemaphoreCreateRecursiveMutex() function.  (see

+ * http://www.freertos.org/a00111.html).  If a recursive mutex is created using

+ * xSemaphoreCreateRecursiveMutexStatic() then the application writer must

+ * provide the memory that will get used by the mutex.

+ * xSemaphoreCreateRecursiveMutexStatic() therefore allows a recursive mutex to

+ * be created without using any dynamic memory allocation.

+ *

+ * Mutexes created using this macro can be accessed using the

+ * xSemaphoreTakeRecursive() and xSemaphoreGiveRecursive() macros.  The

+ * xSemaphoreTake() and xSemaphoreGive() macros must 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 xSemaphoreCreateBinary() 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.

+ *

+ * @param pxMutexBuffer Must point to a variable of type StaticSemaphore_t,

+ * which will then be used to hold the recursive mutex's data structure,

+ * removing the need for the memory to be allocated dynamically.

+ *

+ * @return If the recursive mutex was successfully created then a handle to the

+ * created recursive mutex is returned.  If pxMutexBuffer was NULL then NULL is

+ * returned.

+ *

+ * Example usage:

+ <pre>

+ SemaphoreHandle_t xSemaphore;

+ StaticSemaphore_t xMutexBuffer;

+

+ void vATask( void * pvParameters )

+ {

+    // A recursive semaphore cannot be used before it is created.  Here a

+    // recursive mutex is created using xSemaphoreCreateRecursiveMutexStatic().

+    // The address of xMutexBuffer is passed into the function, and will hold

+    // the mutexes data structures - so no dynamic memory allocation will be

+    // attempted.

+    xSemaphore = xSemaphoreCreateRecursiveMutexStatic( &xMutexBuffer );

+

+    // As no dynamic memory allocation was performed, xSemaphore cannot be NULL,

+    // so there is no need to check it.

+ }

+ </pre>

+ * \defgroup xSemaphoreCreateRecursiveMutexStatic xSemaphoreCreateRecursiveMutexStatic

  * \ingroup Semaphores

  */

-#define xSemaphoreCreateRecursiveMutex() xQueueCreateMutex( queueQUEUE_TYPE_RECURSIVE_MUTEX )

+#if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configUSE_RECURSIVE_MUTEXES == 1 ) )

+	#define xSemaphoreCreateRecursiveMutexStatic( pxStaticSemaphore ) xQueueCreateMutexStatic( queueQUEUE_TYPE_RECURSIVE_MUTEX, pxStaticSemaphore )

+#endif /* configSUPPORT_STATIC_ALLOCATION */

 

 /**

  * semphr. h

  * <pre>SemaphoreHandle_t xSemaphoreCreateCounting( UBaseType_t uxMaxCount, UBaseType_t uxInitialCount )</pre>

  *

- * <i>Macro</i> that creates a counting semaphore by using the existing

- * queue mechanism.

+ * Creates a new counting semaphore instance, and returns a handle by which the

+ * new counting semaphore can be referenced.

+ *

+ * In many usage scenarios it is faster and more memory efficient to use a

+ * direct to task notification in place of a counting semaphore!

+ * http://www.freertos.org/RTOS-task-notifications.html

+ *

+ * Internally, within the FreeRTOS implementation, counting semaphores use a

+ * block of memory, in which the counting semaphore structure is stored.  If a

+ * counting semaphore is created using xSemaphoreCreateCounting() then the

+ * required memory is automatically dynamically allocated inside the

+ * xSemaphoreCreateCounting() function.  (see

+ * http://www.freertos.org/a00111.html).  If a counting semaphore is created

+ * using xSemaphoreCreateCountingStatic() then the application writer can

+ * instead optionally provide the memory that will get used by the counting

+ * semaphore.  xSemaphoreCreateCountingStatic() therefore allows a counting

+ * semaphore to be created without using any dynamic memory allocation.

  *

  * Counting semaphores are typically used for two things:

  *

@@ -808,7 +994,94 @@ typedef QueueHandle_t SemaphoreHandle_t;
  * \defgroup xSemaphoreCreateCounting xSemaphoreCreateCounting

  * \ingroup Semaphores

  */

-#define xSemaphoreCreateCounting( uxMaxCount, uxInitialCount ) xQueueCreateCountingSemaphore( ( uxMaxCount ), ( uxInitialCount ) )

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

+	#define xSemaphoreCreateCounting( uxMaxCount, uxInitialCount ) xQueueCreateCountingSemaphore( ( uxMaxCount ), ( uxInitialCount ) )

+#endif

+

+/**

+ * semphr. h

+ * <pre>SemaphoreHandle_t xSemaphoreCreateCountingStatic( UBaseType_t uxMaxCount, UBaseType_t uxInitialCount, StaticSemaphore_t *pxSemaphoreBuffer )</pre>

+ *

+ * Creates a new counting semaphore instance, and returns a handle by which the

+ * new counting semaphore can be referenced.

+ *

+ * In many usage scenarios it is faster and more memory efficient to use a

+ * direct to task notification in place of a counting semaphore!

+ * http://www.freertos.org/RTOS-task-notifications.html

+ *

+ * Internally, within the FreeRTOS implementation, counting semaphores use a

+ * block of memory, in which the counting semaphore structure is stored.  If a

+ * counting semaphore is created using xSemaphoreCreateCounting() then the

+ * required memory is automatically dynamically allocated inside the

+ * xSemaphoreCreateCounting() function.  (see

+ * http://www.freertos.org/a00111.html).  If a counting semaphore is created

+ * using xSemaphoreCreateCountingStatic() then the application writer must

+ * provide the memory.  xSemaphoreCreateCountingStatic() therefore allows a

+ * counting semaphore to be created without using any dynamic memory allocation.

+ *

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

+ *

+ * @param pxSemaphoreBuffer Must point to a variable of type StaticSemaphore_t,

+ * which will then be used to hold the semaphore's data structure, removing the

+ * need for the memory to be allocated dynamically.

+ *

+ * @return If the counting semaphore was successfully created then a handle to

+ * the created counting semaphore is returned.  If pxSemaphoreBuffer was NULL

+ * then NULL is returned.

+ *

+ * Example usage:

+ <pre>

+ SemaphoreHandle_t xSemaphore;

+ StaticSemaphore_t xSemaphoreBuffer;

+

+ void vATask( void * pvParameters )

+ {

+ SemaphoreHandle_t xSemaphore = NULL;

+

+    // Counting semaphore cannot be used before they have been created.  Create

+    // a counting semaphore using xSemaphoreCreateCountingStatic().  The max

+    // value to which the semaphore can count is 10, and the initial value

+    // assigned to the count will be 0.  The address of xSemaphoreBuffer is

+    // passed in and will be used to hold the semaphore structure, so no dynamic

+    // memory allocation will be used.

+    xSemaphore = xSemaphoreCreateCounting( 10, 0, &xSemaphoreBuffer );

+

+    // No memory allocation was attempted so xSemaphore cannot be NULL, so there

+    // is no need to check its value.

+ }

+ </pre>

+ * \defgroup xSemaphoreCreateCountingStatic xSemaphoreCreateCountingStatic

+ * \ingroup Semaphores

+ */

+#if( configSUPPORT_STATIC_ALLOCATION == 1 )

+	#define xSemaphoreCreateCountingStatic( uxMaxCount, uxInitialCount, pxSemaphoreBuffer ) xQueueCreateCountingSemaphoreStatic( ( uxMaxCount ), ( uxInitialCount ), ( pxSemaphoreBuffer ) )

+#endif /* configSUPPORT_STATIC_ALLOCATION */

 

 /**

  * semphr. h

@@ -839,6 +1112,29 @@ typedef QueueHandle_t SemaphoreHandle_t;
  */

 #define xSemaphoreGetMutexHolder( xSemaphore ) xQueueGetMutexHolder( ( xSemaphore ) )

 

+/**

+ * semphr.h

+ * <pre>TaskHandle_t xSemaphoreGetMutexHolderFromISR( SemaphoreHandle_t 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.

+ *

+ */

+#define xSemaphoreGetMutexHolderFromISR( xSemaphore ) xQueueGetMutexHolderFromISR( ( xSemaphore ) )

+

+/**

+ * semphr.h

+ * <pre>UBaseType_t uxSemaphoreGetCount( SemaphoreHandle_t xSemaphore );</pre>

+ *

+ * If the semaphore is a counting semaphore then uxSemaphoreGetCount() returns

+ * its current count value.  If the semaphore is a binary semaphore then

+ * uxSemaphoreGetCount() returns 1 if the semaphore is available, and 0 if the

+ * semaphore is not available.

+ *

+ */

+#define uxSemaphoreGetCount( xSemaphore ) uxQueueMessagesWaiting( ( QueueHandle_t ) ( xSemaphore ) )

+

 #endif /* SEMAPHORE_H */

 

 

diff --git a/src/FreeRTOS/Source/include/stack_macros.h b/src/FreeRTOS/Source/include/stack_macros.h
new file mode 100644
index 0000000..23cf452
--- /dev/null
+++ b/src/FreeRTOS/Source/include/stack_macros.h
@@ -0,0 +1,129 @@
+/*

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

+

+#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 == 1 ) && ( portSTACK_GROWTH < 0 ) )

+

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

+	#define taskCHECK_FOR_STACK_OVERFLOW()																\

+	{																									\

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

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

+		{																								\

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

+		}																								\

+	}

+

+#endif /* configCHECK_FOR_STACK_OVERFLOW == 1 */

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

+

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

+

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

+	#define taskCHECK_FOR_STACK_OVERFLOW()																\

+	{																									\

+																										\

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

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

+		{																								\

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

+		}																								\

+	}

+

+#endif /* configCHECK_FOR_STACK_OVERFLOW == 1 */

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

+

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

+

+	#define taskCHECK_FOR_STACK_OVERFLOW()																\

+	{																									\

+		const uint32_t * const pulStack = ( uint32_t * ) pxCurrentTCB->pxStack;							\

+		const uint32_t ulCheckValue = ( uint32_t ) 0xa5a5a5a5;											\

+																										\

+		if( ( pulStack[ 0 ] != ulCheckValue ) ||														\

+			( pulStack[ 1 ] != ulCheckValue ) ||														\

+			( pulStack[ 2 ] != ulCheckValue ) ||														\

+			( pulStack[ 3 ] != ulCheckValue ) )															\

+		{																								\

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

+		}																								\

+	}

+

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

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

+

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

+

+	#define taskCHECK_FOR_STACK_OVERFLOW()																								\

+	{																																	\

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

+	static const uint8_t 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( ( TaskHandle_t ) pxCurrentTCB, pxCurrentTCB->pcTaskName );									\

+		}																																\

+	}

+

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

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

+

+/* Remove stack overflow macro if not being used. */

+#ifndef taskCHECK_FOR_STACK_OVERFLOW

+	#define taskCHECK_FOR_STACK_OVERFLOW()

+#endif

+

+

+

+#endif /* STACK_MACROS_H */

+

diff --git a/src/FreeRTOS/Source/include/stream_buffer.h b/src/FreeRTOS/Source/include/stream_buffer.h
new file mode 100644
index 0000000..3764a8e
--- /dev/null
+++ b/src/FreeRTOS/Source/include/stream_buffer.h
@@ -0,0 +1,855 @@
+/*

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

+

+/*

+ * Stream buffers are used to send a continuous stream of data from one task or

+ * interrupt to another.  Their implementation is light weight, making them

+ * particularly suited for interrupt to task and core to core communication

+ * scenarios.

+ *

+ * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer

+ * implementation (so also the message buffer implementation, as message buffers

+ * are built on top of stream buffers) assumes there is only one task or

+ * interrupt that will write to the buffer (the writer), and only one task or

+ * interrupt that will read from the buffer (the reader).  It is safe for the

+ * writer and reader to be different tasks or interrupts, but, unlike other

+ * FreeRTOS objects, it is not safe to have multiple different writers or

+ * multiple different readers.  If there are to be multiple different writers

+ * then the application writer must place each call to a writing API function

+ * (such as xStreamBufferSend()) inside a critical section and set the send

+ * block time to 0.  Likewise, if there are to be multiple different readers

+ * then the application writer must place each call to a reading API function

+ * (such as xStreamBufferRead()) inside a critical section section and set the

+ * receive block time to 0.

+ *

+ */

+

+#ifndef STREAM_BUFFER_H

+#define STREAM_BUFFER_H

+

+#if defined( __cplusplus )

+extern "C" {

+#endif

+

+/**

+ * Type by which stream buffers are referenced.  For example, a call to

+ * xStreamBufferCreate() returns an StreamBufferHandle_t variable that can

+ * then be used as a parameter to xStreamBufferSend(), xStreamBufferReceive(),

+ * etc.

+ */

+struct StreamBufferDef_t;

+typedef struct StreamBufferDef_t * StreamBufferHandle_t;

+

+

+/**

+ * message_buffer.h

+ *

+<pre>

+StreamBufferHandle_t xStreamBufferCreate( size_t xBufferSizeBytes, size_t xTriggerLevelBytes );

+</pre>

+ *

+ * Creates a new stream buffer using dynamically allocated memory.  See

+ * xStreamBufferCreateStatic() for a version that uses statically allocated

+ * memory (memory that is allocated at compile time).

+ *

+ * configSUPPORT_DYNAMIC_ALLOCATION must be set to 1 or left undefined in

+ * FreeRTOSConfig.h for xStreamBufferCreate() to be available.

+ *

+ * @param xBufferSizeBytes The total number of bytes the stream buffer will be

+ * able to hold at any one time.

+ *

+ * @param xTriggerLevelBytes The number of bytes that must be in the stream

+ * buffer before a task that is blocked on the stream buffer to wait for data is

+ * moved out of the blocked state.  For example, if a task is blocked on a read

+ * of an empty stream buffer that has a trigger level of 1 then the task will be

+ * unblocked when a single byte is written to the buffer or the task's block

+ * time expires.  As another example, if a task is blocked on a read of an empty

+ * stream buffer that has a trigger level of 10 then the task will not be

+ * unblocked until the stream buffer contains at least 10 bytes or the task's

+ * block time expires.  If a reading task's block time expires before the

+ * trigger level is reached then the task will still receive however many bytes

+ * are actually available.  Setting a trigger level of 0 will result in a

+ * trigger level of 1 being used.  It is not valid to specify a trigger level

+ * that is greater than the buffer size.

+ *

+ * @return If NULL is returned, then the stream buffer cannot be created

+ * because there is insufficient heap memory available for FreeRTOS to allocate

+ * the stream buffer data structures and storage area.  A non-NULL value being

+ * returned indicates that the stream buffer has been created successfully -

+ * the returned value should be stored as the handle to the created stream

+ * buffer.

+ *

+ * Example use:

+<pre>

+

+void vAFunction( void )

+{

+StreamBufferHandle_t xStreamBuffer;

+const size_t xStreamBufferSizeBytes = 100, xTriggerLevel = 10;

+

+    // Create a stream buffer that can hold 100 bytes.  The memory used to hold

+    // both the stream buffer structure and the data in the stream buffer is

+    // allocated dynamically.

+    xStreamBuffer = xStreamBufferCreate( xStreamBufferSizeBytes, xTriggerLevel );

+

+    if( xStreamBuffer == NULL )

+    {

+        // There was not enough heap memory space available to create the

+        // stream buffer.

+    }

+    else

+    {

+        // The stream buffer was created successfully and can now be used.

+    }

+}

+</pre>

+ * \defgroup xStreamBufferCreate xStreamBufferCreate

+ * \ingroup StreamBufferManagement

+ */

+#define xStreamBufferCreate( xBufferSizeBytes, xTriggerLevelBytes ) xStreamBufferGenericCreate( xBufferSizeBytes, xTriggerLevelBytes, pdFALSE )

+

+/**

+ * stream_buffer.h

+ *

+<pre>

+StreamBufferHandle_t xStreamBufferCreateStatic( size_t xBufferSizeBytes,

+                                                size_t xTriggerLevelBytes,

+                                                uint8_t *pucStreamBufferStorageArea,

+                                                StaticStreamBuffer_t *pxStaticStreamBuffer );

+</pre>

+ * Creates a new stream buffer using statically allocated memory.  See

+ * xStreamBufferCreate() for a version that uses dynamically allocated memory.

+ *

+ * configSUPPORT_STATIC_ALLOCATION must be set to 1 in FreeRTOSConfig.h for

+ * xStreamBufferCreateStatic() to be available.

+ *

+ * @param xBufferSizeBytes The size, in bytes, of the buffer pointed to by the

+ * pucStreamBufferStorageArea parameter.

+ *

+ * @param xTriggerLevelBytes The number of bytes that must be in the stream

+ * buffer before a task that is blocked on the stream buffer to wait for data is

+ * moved out of the blocked state.  For example, if a task is blocked on a read

+ * of an empty stream buffer that has a trigger level of 1 then the task will be

+ * unblocked when a single byte is written to the buffer or the task's block

+ * time expires.  As another example, if a task is blocked on a read of an empty

+ * stream buffer that has a trigger level of 10 then the task will not be

+ * unblocked until the stream buffer contains at least 10 bytes or the task's

+ * block time expires.  If a reading task's block time expires before the

+ * trigger level is reached then the task will still receive however many bytes

+ * are actually available.  Setting a trigger level of 0 will result in a

+ * trigger level of 1 being used.  It is not valid to specify a trigger level

+ * that is greater than the buffer size.

+ *

+ * @param pucStreamBufferStorageArea Must point to a uint8_t array that is at

+ * least xBufferSizeBytes + 1 big.  This is the array to which streams are

+ * copied when they are written to the stream buffer.

+ *

+ * @param pxStaticStreamBuffer Must point to a variable of type

+ * StaticStreamBuffer_t, which will be used to hold the stream buffer's data

+ * structure.

+ *

+ * @return If the stream buffer is created successfully then a handle to the

+ * created stream buffer is returned. If either pucStreamBufferStorageArea or

+ * pxStaticstreamBuffer are NULL then NULL is returned.

+ *

+ * Example use:

+<pre>

+

+// Used to dimension the array used to hold the streams.  The available space

+// will actually be one less than this, so 999.

+#define STORAGE_SIZE_BYTES 1000

+

+// Defines the memory that will actually hold the streams within the stream

+// buffer.

+static uint8_t ucStorageBuffer[ STORAGE_SIZE_BYTES ];

+

+// The variable used to hold the stream buffer structure.

+StaticStreamBuffer_t xStreamBufferStruct;

+

+void MyFunction( void )

+{

+StreamBufferHandle_t xStreamBuffer;

+const size_t xTriggerLevel = 1;

+

+    xStreamBuffer = xStreamBufferCreateStatic( sizeof( ucBufferStorage ),

+                                               xTriggerLevel,

+                                               ucBufferStorage,

+                                               &xStreamBufferStruct );

+

+    // As neither the pucStreamBufferStorageArea or pxStaticStreamBuffer

+    // parameters were NULL, xStreamBuffer will not be NULL, and can be used to

+    // reference the created stream buffer in other stream buffer API calls.

+

+    // Other code that uses the stream buffer can go here.

+}

+

+</pre>

+ * \defgroup xStreamBufferCreateStatic xStreamBufferCreateStatic

+ * \ingroup StreamBufferManagement

+ */

+#define xStreamBufferCreateStatic( xBufferSizeBytes, xTriggerLevelBytes, pucStreamBufferStorageArea, pxStaticStreamBuffer ) xStreamBufferGenericCreateStatic( xBufferSizeBytes, xTriggerLevelBytes, pdFALSE, pucStreamBufferStorageArea, pxStaticStreamBuffer )

+

+/**

+ * stream_buffer.h

+ *

+<pre>

+size_t xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,

+                          const void *pvTxData,

+                          size_t xDataLengthBytes,

+                          TickType_t xTicksToWait );

+</pre>

+ *

+ * Sends bytes to a stream buffer.  The bytes are copied into the stream buffer.

+ *

+ * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer

+ * implementation (so also the message buffer implementation, as message buffers

+ * are built on top of stream buffers) assumes there is only one task or

+ * interrupt that will write to the buffer (the writer), and only one task or

+ * interrupt that will read from the buffer (the reader).  It is safe for the

+ * writer and reader to be different tasks or interrupts, but, unlike other

+ * FreeRTOS objects, it is not safe to have multiple different writers or

+ * multiple different readers.  If there are to be multiple different writers

+ * then the application writer must place each call to a writing API function

+ * (such as xStreamBufferSend()) inside a critical section and set the send

+ * block time to 0.  Likewise, if there are to be multiple different readers

+ * then the application writer must place each call to a reading API function

+ * (such as xStreamBufferRead()) inside a critical section and set the receive

+ * block time to 0.

+ *

+ * Use xStreamBufferSend() to write to a stream buffer from a task.  Use

+ * xStreamBufferSendFromISR() to write to a stream buffer from an interrupt

+ * service routine (ISR).

+ *

+ * @param xStreamBuffer The handle of the stream buffer to which a stream is

+ * being sent.

+ *

+ * @param pvTxData A pointer to the buffer that holds the bytes to be copied

+ * into the stream buffer.

+ *

+ * @param xDataLengthBytes   The maximum number of bytes to copy from pvTxData

+ * into the stream buffer.

+ *

+ * @param xTicksToWait The maximum amount of time the task should remain in the

+ * Blocked state to wait for enough space to become available in the stream

+ * buffer, should the stream buffer contain too little space to hold the

+ * another xDataLengthBytes bytes.  The block time is specified in tick periods,

+ * so the absolute time it represents is dependent on the tick frequency.  The

+ * macro pdMS_TO_TICKS() can be used to convert a time specified in milliseconds

+ * into a time specified in ticks.  Setting xTicksToWait to portMAX_DELAY will

+ * cause the task to wait indefinitely (without timing out), provided

+ * INCLUDE_vTaskSuspend is set to 1 in FreeRTOSConfig.h.  If a task times out

+ * before it can write all xDataLengthBytes into the buffer it will still write

+ * as many bytes as possible.  A task does not use any CPU time when it is in

+ * the blocked state.

+ *

+ * @return The number of bytes written to the stream buffer.  If a task times

+ * out before it can write all xDataLengthBytes into the buffer it will still

+ * write as many bytes as possible.

+ *

+ * Example use:

+<pre>

+void vAFunction( StreamBufferHandle_t xStreamBuffer )

+{

+size_t xBytesSent;

+uint8_t ucArrayToSend[] = { 0, 1, 2, 3 };

+char *pcStringToSend = "String to send";

+const TickType_t x100ms = pdMS_TO_TICKS( 100 );

+

+    // Send an array to the stream buffer, blocking for a maximum of 100ms to

+    // wait for enough space to be available in the stream buffer.

+    xBytesSent = xStreamBufferSend( xStreamBuffer, ( void * ) ucArrayToSend, sizeof( ucArrayToSend ), x100ms );

+

+    if( xBytesSent != sizeof( ucArrayToSend ) )

+    {

+        // The call to xStreamBufferSend() times out before there was enough

+        // space in the buffer for the data to be written, but it did

+        // successfully write xBytesSent bytes.

+    }

+

+    // Send the string to the stream buffer.  Return immediately if there is not

+    // enough space in the buffer.

+    xBytesSent = xStreamBufferSend( xStreamBuffer, ( void * ) pcStringToSend, strlen( pcStringToSend ), 0 );

+

+    if( xBytesSent != strlen( pcStringToSend ) )

+    {

+        // The entire string could not be added to the stream buffer because

+        // there was not enough free space in the buffer, but xBytesSent bytes

+        // were sent.  Could try again to send the remaining bytes.

+    }

+}

+</pre>

+ * \defgroup xStreamBufferSend xStreamBufferSend

+ * \ingroup StreamBufferManagement

+ */

+size_t xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,

+						  const void *pvTxData,

+						  size_t xDataLengthBytes,

+						  TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;

+

+/**

+ * stream_buffer.h

+ *

+<pre>

+size_t xStreamBufferSendFromISR( StreamBufferHandle_t xStreamBuffer,

+                                 const void *pvTxData,

+                                 size_t xDataLengthBytes,

+                                 BaseType_t *pxHigherPriorityTaskWoken );

+</pre>

+ *

+ * Interrupt safe version of the API function that sends a stream of bytes to

+ * the stream buffer.

+ *

+ * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer

+ * implementation (so also the message buffer implementation, as message buffers

+ * are built on top of stream buffers) assumes there is only one task or

+ * interrupt that will write to the buffer (the writer), and only one task or

+ * interrupt that will read from the buffer (the reader).  It is safe for the

+ * writer and reader to be different tasks or interrupts, but, unlike other

+ * FreeRTOS objects, it is not safe to have multiple different writers or

+ * multiple different readers.  If there are to be multiple different writers

+ * then the application writer must place each call to a writing API function

+ * (such as xStreamBufferSend()) inside a critical section and set the send

+ * block time to 0.  Likewise, if there are to be multiple different readers

+ * then the application writer must place each call to a reading API function

+ * (such as xStreamBufferRead()) inside a critical section and set the receive

+ * block time to 0.

+ *

+ * Use xStreamBufferSend() to write to a stream buffer from a task.  Use

+ * xStreamBufferSendFromISR() to write to a stream buffer from an interrupt

+ * service routine (ISR).

+ *

+ * @param xStreamBuffer The handle of the stream buffer to which a stream is

+ * being sent.

+ *

+ * @param pvTxData A pointer to the data that is to be copied into the stream

+ * buffer.

+ *

+ * @param xDataLengthBytes The maximum number of bytes to copy from pvTxData

+ * into the stream buffer.

+ *

+ * @param pxHigherPriorityTaskWoken  It is possible that a stream buffer will

+ * have a task blocked on it waiting for data.  Calling

+ * xStreamBufferSendFromISR() can make data available, and so cause a task that

+ * was waiting for data to leave the Blocked state.  If calling

+ * xStreamBufferSendFromISR() causes a task to leave the Blocked state, and the

+ * unblocked task has a priority higher than the currently executing task (the

+ * task that was interrupted), then, internally, xStreamBufferSendFromISR()

+ * will set *pxHigherPriorityTaskWoken to pdTRUE.  If

+ * xStreamBufferSendFromISR() sets this value to pdTRUE, then normally a

+ * context switch should be performed before the interrupt is exited.  This will

+ * ensure that the interrupt returns directly to the highest priority Ready

+ * state task.  *pxHigherPriorityTaskWoken should be set to pdFALSE before it

+ * is passed into the function.  See the example code below for an example.

+ *

+ * @return The number of bytes actually written to the stream buffer, which will

+ * be less than xDataLengthBytes if the stream buffer didn't have enough free

+ * space for all the bytes to be written.

+ *

+ * Example use:

+<pre>

+// A stream buffer that has already been created.

+StreamBufferHandle_t xStreamBuffer;

+

+void vAnInterruptServiceRoutine( void )

+{

+size_t xBytesSent;

+char *pcStringToSend = "String to send";

+BaseType_t xHigherPriorityTaskWoken = pdFALSE; // Initialised to pdFALSE.

+

+    // Attempt to send the string to the stream buffer.

+    xBytesSent = xStreamBufferSendFromISR( xStreamBuffer,

+                                           ( void * ) pcStringToSend,

+                                           strlen( pcStringToSend ),

+                                           &xHigherPriorityTaskWoken );

+

+    if( xBytesSent != strlen( pcStringToSend ) )

+    {

+        // There was not enough free space in the stream buffer for the entire

+        // string to be written, ut xBytesSent bytes were written.

+    }

+

+    // If xHigherPriorityTaskWoken was set to pdTRUE inside

+    // xStreamBufferSendFromISR() then a task that has a priority above the

+    // priority of the currently executing task was unblocked and a context

+    // switch should be performed to ensure the ISR returns to the unblocked

+    // task.  In most FreeRTOS ports this is done by simply passing

+    // xHigherPriorityTaskWoken into taskYIELD_FROM_ISR(), which will test the

+    // variables value, and perform the context switch if necessary.  Check the

+    // documentation for the port in use for port specific instructions.

+    taskYIELD_FROM_ISR( xHigherPriorityTaskWoken );

+}

+</pre>

+ * \defgroup xStreamBufferSendFromISR xStreamBufferSendFromISR

+ * \ingroup StreamBufferManagement

+ */

+size_t xStreamBufferSendFromISR( StreamBufferHandle_t xStreamBuffer,

+								 const void *pvTxData,

+								 size_t xDataLengthBytes,

+								 BaseType_t * const pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;

+

+/**

+ * stream_buffer.h

+ *

+<pre>

+size_t xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,

+                             void *pvRxData,

+                             size_t xBufferLengthBytes,

+                             TickType_t xTicksToWait );

+</pre>

+ *

+ * Receives bytes from a stream buffer.

+ *

+ * ***NOTE***:  Uniquely among FreeRTOS objects, the stream buffer

+ * implementation (so also the message buffer implementation, as message buffers

+ * are built on top of stream buffers) assumes there is only one task or

+ * interrupt that will write to the buffer (the writer), and only one task or

+ * interrupt that will read from the buffer (the reader).  It is safe for the

+ * writer and reader to be different tasks or interrupts, but, unlike other

+ * FreeRTOS objects, it is not safe to have multiple different writers or

+ * multiple different readers.  If there are to be multiple different writers

+ * then the application writer must place each call to a writing API function

+ * (such as xStreamBufferSend()) inside a critical section and set the send

+ * block time to 0.  Likewise, if there are to be multiple different readers

+ * then the application writer must place each call to a reading API function

+ * (such as xStreamBufferRead()) inside a critical section and set the receive

+ * block time to 0.

+ *

+ * Use xStreamBufferReceive() to read from a stream buffer from a task.  Use

+ * xStreamBufferReceiveFromISR() to read from a stream buffer from an

+ * interrupt service routine (ISR).

+ *

+ * @param xStreamBuffer The handle of the stream buffer from which bytes are to

+ * be received.

+ *

+ * @param pvRxData A pointer to the buffer into which the received bytes will be

+ * copied.

+ *

+ * @param xBufferLengthBytes The length of the buffer pointed to by the

+ * pvRxData parameter.  This sets the maximum number of bytes to receive in one

+ * call.  xStreamBufferReceive will return as many bytes as possible up to a

+ * maximum set by xBufferLengthBytes.

+ *

+ * @param xTicksToWait The maximum amount of time the task should remain in the

+ * Blocked state to wait for data to become available if the stream buffer is

+ * empty.  xStreamBufferReceive() will return immediately if xTicksToWait is

+ * zero.  The block time is specified in tick periods, so the absolute time it

+ * represents is dependent on the tick frequency.  The macro pdMS_TO_TICKS() can

+ * be used to convert a time specified in milliseconds into a time specified in

+ * ticks.  Setting xTicksToWait to portMAX_DELAY will cause the task to wait

+ * indefinitely (without timing out), provided INCLUDE_vTaskSuspend is set to 1

+ * in FreeRTOSConfig.h.  A task does not use any CPU time when it is in the

+ * Blocked state.

+ *

+ * @return The number of bytes actually read from the stream buffer, which will

+ * be less than xBufferLengthBytes if the call to xStreamBufferReceive() timed

+ * out before xBufferLengthBytes were available.

+ *

+ * Example use:

+<pre>

+void vAFunction( StreamBuffer_t xStreamBuffer )

+{

+uint8_t ucRxData[ 20 ];

+size_t xReceivedBytes;

+const TickType_t xBlockTime = pdMS_TO_TICKS( 20 );

+

+    // Receive up to another sizeof( ucRxData ) bytes from the stream buffer.

+    // Wait in the Blocked state (so not using any CPU processing time) for a

+    // maximum of 100ms for the full sizeof( ucRxData ) number of bytes to be

+    // available.

+    xReceivedBytes = xStreamBufferReceive( xStreamBuffer,

+                                           ( void * ) ucRxData,

+                                           sizeof( ucRxData ),

+                                           xBlockTime );

+

+    if( xReceivedBytes > 0 )

+    {

+        // A ucRxData contains another xRecievedBytes bytes of data, which can

+        // be processed here....

+    }

+}

+</pre>

+ * \defgroup xStreamBufferReceive xStreamBufferReceive

+ * \ingroup StreamBufferManagement

+ */

+size_t xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,

+							 void *pvRxData,

+							 size_t xBufferLengthBytes,

+							 TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;

+

+/**

+ * stream_buffer.h

+ *

+<pre>

+size_t xStreamBufferReceiveFromISR( StreamBufferHandle_t xStreamBuffer,

+                                    void *pvRxData,

+                                    size_t xBufferLengthBytes,

+                                    BaseType_t *pxHigherPriorityTaskWoken );

+</pre>

+ *

+ * An interrupt safe version of the API function that receives bytes from a

+ * stream buffer.

+ *

+ * Use xStreamBufferReceive() to read bytes from a stream buffer from a task.

+ * Use xStreamBufferReceiveFromISR() to read bytes from a stream buffer from an

+ * interrupt service routine (ISR).

+ *

+ * @param xStreamBuffer The handle of the stream buffer from which a stream

+ * is being received.

+ *

+ * @param pvRxData A pointer to the buffer into which the received bytes are

+ * copied.

+ *

+ * @param xBufferLengthBytes The length of the buffer pointed to by the

+ * pvRxData parameter.  This sets the maximum number of bytes to receive in one

+ * call.  xStreamBufferReceive will return as many bytes as possible up to a

+ * maximum set by xBufferLengthBytes.

+ *

+ * @param pxHigherPriorityTaskWoken  It is possible that a stream buffer will

+ * have a task blocked on it waiting for space to become available.  Calling

+ * xStreamBufferReceiveFromISR() can make space available, and so cause a task

+ * that is waiting for space to leave the Blocked state.  If calling

+ * xStreamBufferReceiveFromISR() causes a task to leave the Blocked state, and

+ * the unblocked task has a priority higher than the currently executing task

+ * (the task that was interrupted), then, internally,

+ * xStreamBufferReceiveFromISR() will set *pxHigherPriorityTaskWoken to pdTRUE.

+ * If xStreamBufferReceiveFromISR() sets this value to pdTRUE, then normally a

+ * context switch should be performed before the interrupt is exited.  That will

+ * ensure the interrupt returns directly to the highest priority Ready state

+ * task.  *pxHigherPriorityTaskWoken should be set to pdFALSE before it is

+ * passed into the function.  See the code example below for an example.

+ *

+ * @return The number of bytes read from the stream buffer, if any.

+ *

+ * Example use:

+<pre>

+// A stream buffer that has already been created.

+StreamBuffer_t xStreamBuffer;

+

+void vAnInterruptServiceRoutine( void )

+{

+uint8_t ucRxData[ 20 ];

+size_t xReceivedBytes;

+BaseType_t xHigherPriorityTaskWoken = pdFALSE;  // Initialised to pdFALSE.

+

+    // Receive the next stream from the stream buffer.

+    xReceivedBytes = xStreamBufferReceiveFromISR( xStreamBuffer,

+                                                  ( void * ) ucRxData,

+                                                  sizeof( ucRxData ),

+                                                  &xHigherPriorityTaskWoken );

+

+    if( xReceivedBytes > 0 )

+    {

+        // ucRxData contains xReceivedBytes read from the stream buffer.

+        // Process the stream here....

+    }

+

+    // If xHigherPriorityTaskWoken was set to pdTRUE inside

+    // xStreamBufferReceiveFromISR() then a task that has a priority above the

+    // priority of the currently executing task was unblocked and a context

+    // switch should be performed to ensure the ISR returns to the unblocked

+    // task.  In most FreeRTOS ports this is done by simply passing

+    // xHigherPriorityTaskWoken into taskYIELD_FROM_ISR(), which will test the

+    // variables value, and perform the context switch if necessary.  Check the

+    // documentation for the port in use for port specific instructions.

+    taskYIELD_FROM_ISR( xHigherPriorityTaskWoken );

+}

+</pre>

+ * \defgroup xStreamBufferReceiveFromISR xStreamBufferReceiveFromISR

+ * \ingroup StreamBufferManagement

+ */

+size_t xStreamBufferReceiveFromISR( StreamBufferHandle_t xStreamBuffer,

+									void *pvRxData,

+									size_t xBufferLengthBytes,

+									BaseType_t * const pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;

+

+/**

+ * stream_buffer.h

+ *

+<pre>

+void vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer );

+</pre>

+ *

+ * Deletes a stream buffer that was previously created using a call to

+ * xStreamBufferCreate() or xStreamBufferCreateStatic().  If the stream

+ * buffer was created using dynamic memory (that is, by xStreamBufferCreate()),

+ * then the allocated memory is freed.

+ *

+ * A stream buffer handle must not be used after the stream buffer has been

+ * deleted.

+ *

+ * @param xStreamBuffer The handle of the stream buffer to be deleted.

+ *

+ * \defgroup vStreamBufferDelete vStreamBufferDelete

+ * \ingroup StreamBufferManagement

+ */

+void vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;

+

+/**

+ * stream_buffer.h

+ *

+<pre>

+BaseType_t xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer );

+</pre>

+ *

+ * Queries a stream buffer to see if it is full.  A stream buffer is full if it

+ * does not have any free space, and therefore cannot accept any more data.

+ *

+ * @param xStreamBuffer The handle of the stream buffer being queried.

+ *

+ * @return If the stream buffer is full then pdTRUE is returned.  Otherwise

+ * pdFALSE is returned.

+ *

+ * \defgroup xStreamBufferIsFull xStreamBufferIsFull

+ * \ingroup StreamBufferManagement

+ */

+BaseType_t xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;

+

+/**

+ * stream_buffer.h

+ *

+<pre>

+BaseType_t xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer );

+</pre>

+ *

+ * Queries a stream buffer to see if it is empty.  A stream buffer is empty if

+ * it does not contain any data.

+ *

+ * @param xStreamBuffer The handle of the stream buffer being queried.

+ *

+ * @return If the stream buffer is empty then pdTRUE is returned.  Otherwise

+ * pdFALSE is returned.

+ *

+ * \defgroup xStreamBufferIsEmpty xStreamBufferIsEmpty

+ * \ingroup StreamBufferManagement

+ */

+BaseType_t xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;

+

+/**

+ * stream_buffer.h

+ *

+<pre>

+BaseType_t xStreamBufferReset( StreamBufferHandle_t xStreamBuffer );

+</pre>

+ *

+ * Resets a stream buffer to its initial, empty, state.  Any data that was in

+ * the stream buffer is discarded.  A stream buffer can only be reset if there

+ * are no tasks blocked waiting to either send to or receive from the stream

+ * buffer.

+ *

+ * @param xStreamBuffer The handle of the stream buffer being reset.

+ *

+ * @return If the stream buffer is reset then pdPASS is returned.  If there was

+ * a task blocked waiting to send to or read from the stream buffer then the

+ * stream buffer is not reset and pdFAIL is returned.

+ *

+ * \defgroup xStreamBufferReset xStreamBufferReset

+ * \ingroup StreamBufferManagement

+ */

+BaseType_t xStreamBufferReset( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;

+

+/**

+ * stream_buffer.h

+ *

+<pre>

+size_t xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer );

+</pre>

+ *

+ * Queries a stream buffer to see how much free space it contains, which is

+ * equal to the amount of data that can be sent to the stream buffer before it

+ * is full.

+ *

+ * @param xStreamBuffer The handle of the stream buffer being queried.

+ *

+ * @return The number of bytes that can be written to the stream buffer before

+ * the stream buffer would be full.

+ *

+ * \defgroup xStreamBufferSpacesAvailable xStreamBufferSpacesAvailable

+ * \ingroup StreamBufferManagement

+ */

+size_t xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;

+

+/**

+ * stream_buffer.h

+ *

+<pre>

+size_t xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer );

+</pre>

+ *

+ * Queries a stream buffer to see how much data it contains, which is equal to

+ * the number of bytes that can be read from the stream buffer before the stream

+ * buffer would be empty.

+ *

+ * @param xStreamBuffer The handle of the stream buffer being queried.

+ *

+ * @return The number of bytes that can be read from the stream buffer before

+ * the stream buffer would be empty.

+ *

+ * \defgroup xStreamBufferBytesAvailable xStreamBufferBytesAvailable

+ * \ingroup StreamBufferManagement

+ */

+size_t xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;

+

+/**

+ * stream_buffer.h

+ *

+<pre>

+BaseType_t xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer, size_t xTriggerLevel );

+</pre>

+ *

+ * A stream buffer's trigger level is the number of bytes that must be in the

+ * stream buffer before a task that is blocked on the stream buffer to

+ * wait for data is moved out of the blocked state.  For example, if a task is

+ * blocked on a read of an empty stream buffer that has a trigger level of 1

+ * then the task will be unblocked when a single byte is written to the buffer

+ * or the task's block time expires.  As another example, if a task is blocked

+ * on a read of an empty stream buffer that has a trigger level of 10 then the

+ * task will not be unblocked until the stream buffer contains at least 10 bytes

+ * or the task's block time expires.  If a reading task's block time expires

+ * before the trigger level is reached then the task will still receive however

+ * many bytes are actually available.  Setting a trigger level of 0 will result

+ * in a trigger level of 1 being used.  It is not valid to specify a trigger

+ * level that is greater than the buffer size.

+ *

+ * A trigger level is set when the stream buffer is created, and can be modified

+ * using xStreamBufferSetTriggerLevel().

+ *

+ * @param xStreamBuffer The handle of the stream buffer being updated.

+ *

+ * @param xTriggerLevel The new trigger level for the stream buffer.

+ *

+ * @return If xTriggerLevel was less than or equal to the stream buffer's length

+ * then the trigger level will be updated and pdTRUE is returned.  Otherwise

+ * pdFALSE is returned.

+ *

+ * \defgroup xStreamBufferSetTriggerLevel xStreamBufferSetTriggerLevel

+ * \ingroup StreamBufferManagement

+ */

+BaseType_t xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer, size_t xTriggerLevel ) PRIVILEGED_FUNCTION;

+

+/**

+ * stream_buffer.h

+ *

+<pre>

+BaseType_t xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken );

+</pre>

+ *

+ * For advanced users only.

+ *

+ * The sbSEND_COMPLETED() macro is called from within the FreeRTOS APIs when

+ * data is sent to a message buffer or stream buffer.  If there was a task that

+ * was blocked on the message or stream buffer waiting for data to arrive then

+ * the sbSEND_COMPLETED() macro sends a notification to the task to remove it

+ * from the Blocked state.  xStreamBufferSendCompletedFromISR() does the same

+ * thing.  It is provided to enable application writers to implement their own

+ * version of sbSEND_COMPLETED(), and MUST NOT BE USED AT ANY OTHER TIME.

+ *

+ * See the example implemented in FreeRTOS/Demo/Minimal/MessageBufferAMP.c for

+ * additional information.

+ *

+ * @param xStreamBuffer The handle of the stream buffer to which data was

+ * written.

+ *

+ * @param pxHigherPriorityTaskWoken *pxHigherPriorityTaskWoken should be

+ * initialised to pdFALSE before it is passed into

+ * xStreamBufferSendCompletedFromISR().  If calling

+ * xStreamBufferSendCompletedFromISR() removes a task from the Blocked state,

+ * and the task has a priority above the priority of the currently running task,

+ * then *pxHigherPriorityTaskWoken will get set to pdTRUE indicating that a

+ * context switch should be performed before exiting the ISR.

+ *

+ * @return If a task was removed from the Blocked state then pdTRUE is returned.

+ * Otherwise pdFALSE is returned.

+ *

+ * \defgroup xStreamBufferSendCompletedFromISR xStreamBufferSendCompletedFromISR

+ * \ingroup StreamBufferManagement

+ */

+BaseType_t xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;

+

+/**

+ * stream_buffer.h

+ *

+<pre>

+BaseType_t xStreamBufferReceiveCompletedFromISR( StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken );

+</pre>

+ *

+ * For advanced users only.

+ *

+ * The sbRECEIVE_COMPLETED() macro is called from within the FreeRTOS APIs when

+ * data is read out of a message buffer or stream buffer.  If there was a task

+ * that was blocked on the message or stream buffer waiting for data to arrive

+ * then the sbRECEIVE_COMPLETED() macro sends a notification to the task to

+ * remove it from the Blocked state.  xStreamBufferReceiveCompletedFromISR()

+ * does the same thing.  It is provided to enable application writers to

+ * implement their own version of sbRECEIVE_COMPLETED(), and MUST NOT BE USED AT

+ * ANY OTHER TIME.

+ *

+ * See the example implemented in FreeRTOS/Demo/Minimal/MessageBufferAMP.c for

+ * additional information.

+ *

+ * @param xStreamBuffer The handle of the stream buffer from which data was

+ * read.

+ *

+ * @param pxHigherPriorityTaskWoken *pxHigherPriorityTaskWoken should be

+ * initialised to pdFALSE before it is passed into

+ * xStreamBufferReceiveCompletedFromISR().  If calling

+ * xStreamBufferReceiveCompletedFromISR() removes a task from the Blocked state,

+ * and the task has a priority above the priority of the currently running task,

+ * then *pxHigherPriorityTaskWoken will get set to pdTRUE indicating that a

+ * context switch should be performed before exiting the ISR.

+ *

+ * @return If a task was removed from the Blocked state then pdTRUE is returned.

+ * Otherwise pdFALSE is returned.

+ *

+ * \defgroup xStreamBufferReceiveCompletedFromISR xStreamBufferReceiveCompletedFromISR

+ * \ingroup StreamBufferManagement

+ */

+BaseType_t xStreamBufferReceiveCompletedFromISR( StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken ) PRIVILEGED_FUNCTION;

+

+/* Functions below here are not part of the public API. */

+StreamBufferHandle_t xStreamBufferGenericCreate( size_t xBufferSizeBytes,

+												 size_t xTriggerLevelBytes,

+												 BaseType_t xIsMessageBuffer ) PRIVILEGED_FUNCTION;

+

+StreamBufferHandle_t xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes,

+													   size_t xTriggerLevelBytes,

+													   BaseType_t xIsMessageBuffer,

+													   uint8_t * const pucStreamBufferStorageArea,

+													   StaticStreamBuffer_t * const pxStaticStreamBuffer ) PRIVILEGED_FUNCTION;

+

+size_t xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;

+

+#if( configUSE_TRACE_FACILITY == 1 )

+	void vStreamBufferSetStreamBufferNumber( StreamBufferHandle_t xStreamBuffer, UBaseType_t uxStreamBufferNumber ) PRIVILEGED_FUNCTION;

+	UBaseType_t uxStreamBufferGetStreamBufferNumber( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;

+	uint8_t ucStreamBufferGetStreamBufferType( StreamBufferHandle_t xStreamBuffer ) PRIVILEGED_FUNCTION;

+#endif

+

+#if defined( __cplusplus )

+}

+#endif

+

+#endif	/* !defined( STREAM_BUFFER_H ) */

diff --git a/src/FreeRTOS/Source/include/task.h b/src/FreeRTOS/Source/include/task.h
index b8d6dd8..f957ab5 100644
--- a/src/FreeRTOS/Source/include/task.h
+++ b/src/FreeRTOS/Source/include/task.h
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 

 #ifndef INC_TASK_H

@@ -85,10 +43,18 @@ extern "C" {
  * MACROS AND DEFINITIONS

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

 

-#define tskKERNEL_VERSION_NUMBER "V8.2.3"

-#define tskKERNEL_VERSION_MAJOR 8

+#define tskKERNEL_VERSION_NUMBER "V10.2.0"

+#define tskKERNEL_VERSION_MAJOR 10

 #define tskKERNEL_VERSION_MINOR 2

-#define tskKERNEL_VERSION_BUILD 3

+#define tskKERNEL_VERSION_BUILD 0

+

+/* MPU region parameters passed in ulParameters

+ * of MemoryRegion_t struct. */

+#define tskMPU_REGION_READ_ONLY			( 1UL << 0UL )

+#define tskMPU_REGION_READ_WRITE		( 1UL << 1UL )

+#define tskMPU_REGION_EXECUTE_NEVER		( 1UL << 2UL )

+#define tskMPU_REGION_NORMAL_MEMORY		( 1UL << 3UL )

+#define tskMPU_REGION_DEVICE_MEMORY		( 1UL << 4UL )

 

 /**

  * task. h

@@ -100,7 +66,8 @@ extern "C" {
  * \defgroup TaskHandle_t TaskHandle_t

  * \ingroup Tasks

  */

-typedef void * TaskHandle_t;

+struct tskTaskControlBlock; /* The old naming convention is used to prevent breaking kernel aware debuggers. */

+typedef struct tskTaskControlBlock* TaskHandle_t;

 

 /*

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

@@ -115,7 +82,8 @@ typedef enum
 	eReady,			/* The task being queried is in a read or pending ready list. */

 	eBlocked,		/* The task being queried is in the Blocked state. */

 	eSuspended,		/* The task being queried is in the Suspended state, or is in the Blocked state with an infinite time out. */

-	eDeleted		/* The task being queried has been deleted, but its TCB has not yet been freed. */

+	eDeleted,		/* The task being queried has been deleted, but its TCB has not yet been freed. */

+	eInvalid		/* Used as an 'invalid state' value. */

 } eTaskState;

 

 /* Actions that can be performed when vTaskNotify() is called. */

@@ -154,11 +122,14 @@ typedef struct xTASK_PARAMETERS
 {

 	TaskFunction_t pvTaskCode;

 	const char * const pcName;	/*lint !e971 Unqualified char types are allowed for strings and single characters only. */

-	uint16_t usStackDepth;

+	configSTACK_DEPTH_TYPE usStackDepth;

 	void *pvParameters;

 	UBaseType_t uxPriority;

 	StackType_t *puxStackBuffer;

 	MemoryRegion_t xRegions[ portNUM_CONFIGURABLE_REGIONS ];

+	#if ( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )

+		StaticTask_t * const pxTaskBuffer;

+	#endif

 } TaskParameters_t;

 

 /* Used with the uxTaskGetSystemState() function to return the state of each task

@@ -172,7 +143,8 @@ typedef struct xTASK_STATUS
 	UBaseType_t uxCurrentPriority;	/* The priority at which the task was running (may be inherited) when the structure was populated. */

 	UBaseType_t uxBasePriority;		/* The priority to which the task will return if the task's current priority has been inherited to avoid unbounded priority inversion when obtaining a mutex.  Only valid if configUSE_MUTEXES is defined as 1 in FreeRTOSConfig.h. */

 	uint32_t ulRunTimeCounter;		/* The total run time allocated to the task so far, as defined by the run time stats clock.  See http://www.freertos.org/rtos-run-time-stats.html.  Only valid when configGENERATE_RUN_TIME_STATS is defined as 1 in FreeRTOSConfig.h. */

-	uint16_t usStackHighWaterMark;	/* The minimum amount of stack space that has remained for the task since the task was created.  The closer this value is to zero the closer the task has come to overflowing its stack. */

+	StackType_t *pxStackBase;		/* Points to the lowest address of the task's stack area. */

+	configSTACK_DEPTH_TYPE usStackHighWaterMark;	/* The minimum amount of stack space that has remained for the task since the task was created.  The closer this value is to zero the closer the task has come to overflowing its stack. */

 } TaskStatus_t;

 

 /* Possible return values for eTaskConfirmSleepModeStatus(). */

@@ -183,7 +155,6 @@ typedef enum
 	eNoTasksWaitingTimeout	/* No tasks are waiting for a timeout so it is safe to enter a sleep mode that can only be exited by an external interrupt. */

 } eSleepModeStatus;

 

-

 /**

  * Defines the priority used by the idle task.  This must not be modified.

  *

@@ -268,7 +239,7 @@ is used in assert() statements. */
  BaseType_t xTaskCreate(

 							  TaskFunction_t pvTaskCode,

 							  const char * const pcName,

-							  uint16_t usStackDepth,

+							  configSTACK_DEPTH_TYPE usStackDepth,

 							  void *pvParameters,

 							  UBaseType_t uxPriority,

 							  TaskHandle_t *pvCreatedTask

@@ -276,6 +247,19 @@ is used in assert() statements. */
  *

  * Create a new task and add it to the list of tasks that are ready to run.

  *

+ * Internally, within the FreeRTOS implementation, tasks use two blocks of

+ * memory.  The first block is used to hold the task's data structures.  The

+ * second block is used by the task as its stack.  If a task is created using

+ * xTaskCreate() then both blocks of memory are automatically dynamically

+ * allocated inside the xTaskCreate() function.  (see

+ * http://www.freertos.org/a00111.html).  If a task is created using

+ * xTaskCreateStatic() then the application writer must provide the required

+ * memory.  xTaskCreateStatic() therefore allows a task to be created without

+ * using any dynamic memory allocation.

+ *

+ * See xTaskCreateStatic() for a version that does not use any dynamic memory

+ * allocation.

+ *

  * 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

@@ -342,13 +326,139 @@ is used in assert() statements. */
  * \defgroup xTaskCreate xTaskCreate

  * \ingroup Tasks

  */

-#define xTaskCreate( pvTaskCode, pcName, usStackDepth, pvParameters, uxPriority, pxCreatedTask ) xTaskGenericCreate( ( pvTaskCode ), ( pcName ), ( usStackDepth ), ( pvParameters ), ( uxPriority ), ( pxCreatedTask ), ( NULL ), ( NULL ) )

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

+	BaseType_t xTaskCreate(	TaskFunction_t pxTaskCode,

+							const char * const pcName,	/*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+							const configSTACK_DEPTH_TYPE usStackDepth,

+							void * const pvParameters,

+							UBaseType_t uxPriority,

+							TaskHandle_t * const pxCreatedTask ) PRIVILEGED_FUNCTION;

+#endif

+

+/**

+ * task. h

+ *<pre>

+ TaskHandle_t xTaskCreateStatic( TaskFunction_t pvTaskCode,

+								 const char * const pcName,

+								 uint32_t ulStackDepth,

+								 void *pvParameters,

+								 UBaseType_t uxPriority,

+								 StackType_t *pxStackBuffer,

+								 StaticTask_t *pxTaskBuffer );</pre>

+ *

+ * Create a new task and add it to the list of tasks that are ready to run.

+ *

+ * Internally, within the FreeRTOS implementation, tasks use two blocks of

+ * memory.  The first block is used to hold the task's data structures.  The

+ * second block is used by the task as its stack.  If a task is created using

+ * xTaskCreate() then both blocks of memory are automatically dynamically

+ * allocated inside the xTaskCreate() function.  (see

+ * http://www.freertos.org/a00111.html).  If a task is created using

+ * xTaskCreateStatic() then the application writer must provide the required

+ * memory.  xTaskCreateStatic() therefore allows a task to be created without

+ * using any dynamic memory allocation.

+ *

+ * @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.  The maximum length of the string is defined by

+ * configMAX_TASK_NAME_LEN in FreeRTOSConfig.h.

+ *

+ * @param ulStackDepth 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 32-bits wide and ulStackDepth is defined as 100 then 400 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 will run.

+ *

+ * @param pxStackBuffer Must point to a StackType_t array that has at least

+ * ulStackDepth indexes - the array will then be used as the task's stack,

+ * removing the need for the stack to be allocated dynamically.

+ *

+ * @param pxTaskBuffer Must point to a variable of type StaticTask_t, which will

+ * then be used to hold the task's data structures, removing the need for the

+ * memory to be allocated dynamically.

+ *

+ * @return If neither pxStackBuffer or pxTaskBuffer are NULL, then the task will

+ * be created and a handle to the created task is returned.  If either

+ * pxStackBuffer or pxTaskBuffer are NULL then the task will not be created and

+ * NULL is returned.

+ *

+ * Example usage:

+   <pre>

+

+    // Dimensions the buffer that the task being created will use as its stack.

+    // NOTE:  This is the number of words the stack will hold, not the number of

+    // bytes.  For example, if each stack item is 32-bits, and this is set to 100,

+    // then 400 bytes (100 * 32-bits) will be allocated.

+    #define STACK_SIZE 200

+

+    // Structure that will hold the TCB of the task being created.

+    StaticTask_t xTaskBuffer;

+

+    // Buffer that the task being created will use as its stack.  Note this is

+    // an array of StackType_t variables.  The size of StackType_t is dependent on

+    // the RTOS port.

+    StackType_t xStack[ STACK_SIZE ];

+

+    // Function that implements the task being created.

+    void vTaskCode( void * pvParameters )

+    {

+        // The parameter value is expected to be 1 as 1 is passed in the

+        // pvParameters value in the call to xTaskCreateStatic().

+        configASSERT( ( uint32_t ) pvParameters == 1UL );

+

+        for( ;; )

+        {

+            // Task code goes here.

+        }

+    }

+

+    // Function that creates a task.

+    void vOtherFunction( void )

+    {

+        TaskHandle_t xHandle = NULL;

+

+        // Create the task without using any dynamic memory allocation.

+        xHandle = xTaskCreateStatic(

+                      vTaskCode,       // Function that implements the task.

+                      "NAME",          // Text name for the task.

+                      STACK_SIZE,      // Stack size in words, not bytes.

+                      ( void * ) 1,    // Parameter passed into the task.

+                      tskIDLE_PRIORITY,// Priority at which the task is created.

+                      xStack,          // Array to use as the task's stack.

+                      &xTaskBuffer );  // Variable to hold the task's data structure.

+

+        // puxStackBuffer and pxTaskBuffer were not NULL, so the task will have

+        // been created, and xHandle will be the task's handle.  Use the handle

+        // to suspend the task.

+        vTaskSuspend( xHandle );

+    }

+   </pre>

+ * \defgroup xTaskCreateStatic xTaskCreateStatic

+ * \ingroup Tasks

+ */

+#if( configSUPPORT_STATIC_ALLOCATION == 1 )

+	TaskHandle_t xTaskCreateStatic(	TaskFunction_t pxTaskCode,

+									const char * const pcName, /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+									const uint32_t ulStackDepth,

+									void * const pvParameters,

+									UBaseType_t uxPriority,

+									StackType_t * const puxStackBuffer,

+									StaticTask_t * const pxTaskBuffer ) PRIVILEGED_FUNCTION;

+#endif /* configSUPPORT_STATIC_ALLOCATION */

 

 /**

  * task. h

  *<pre>

  BaseType_t xTaskCreateRestricted( TaskParameters_t *pxTaskDefinition, TaskHandle_t *pxCreatedTask );</pre>

  *

+ * Only available when configSUPPORT_DYNAMIC_ALLOCATION is set to 1.

+ *

  * xTaskCreateRestricted() should only be used in systems that include an MPU

  * implementation.

  *

@@ -356,6 +466,9 @@ is used in assert() statements. */
  * The function parameters define the memory regions and associated access

  * permissions allocated to the task.

  *

+ * See xTaskCreateRestrictedStatic() for a version that does not use any

+ * dynamic memory allocation.

+ *

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

@@ -411,7 +524,97 @@ TaskHandle_t xHandle;
  * \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) )

+#if( portUSING_MPU_WRAPPERS == 1 )

+	BaseType_t xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask ) PRIVILEGED_FUNCTION;

+#endif

+

+/**

+ * task. h

+ *<pre>

+ BaseType_t xTaskCreateRestrictedStatic( TaskParameters_t *pxTaskDefinition, TaskHandle_t *pxCreatedTask );</pre>

+ *

+ * Only available when configSUPPORT_STATIC_ALLOCATION is set to 1.

+ *

+ * xTaskCreateRestrictedStatic() should only be used in systems that include an

+ * MPU implementation.

+ *

+ * Internally, within the FreeRTOS implementation, tasks use two blocks of

+ * memory.  The first block is used to hold the task's data structures.  The

+ * second block is used by the task as its stack.  If a task is created using

+ * xTaskCreateRestricted() then the stack is provided by the application writer,

+ * and the memory used to hold the task's data structure is automatically

+ * dynamically allocated inside the xTaskCreateRestricted() function.  If a task

+ * is created using xTaskCreateRestrictedStatic() then the application writer

+ * must provide the memory used to hold the task's data structures too.

+ * xTaskCreateRestrictedStatic() therefore allows a memory protected task to be

+ * created without using any dynamic memory allocation.

+ *

+ * @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.  If configSUPPORT_STATIC_ALLOCATION is set to 1 the structure

+ * contains an additional member, which is used to point to a variable of type

+ * StaticTask_t - which is then used to hold the task's data structure.

+ *

+ * @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 projdefs.h

+ *

+ * Example usage:

+   <pre>

+// Create an TaskParameters_t structure that defines the task to be created.

+// The StaticTask_t variable is only included in the structure when

+// configSUPPORT_STATIC_ALLOCATION is set to 1.  The PRIVILEGED_DATA macro can

+// be used to force the variable into the RTOS kernel's privileged data area.

+static PRIVILEGED_DATA StaticTask_t xTaskBuffer;

+static const TaskParameters_t 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 }

+	}

+

+	&xTaskBuffer; // Holds the task's data structure.

+};

+

+int main( void )

+{

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

+	// and/or timer task.

+	for( ;; );

+}

+   </pre>

+ * \defgroup xTaskCreateRestrictedStatic xTaskCreateRestrictedStatic

+ * \ingroup Tasks

+ */

+#if( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )

+	BaseType_t xTaskCreateRestrictedStatic( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask ) PRIVILEGED_FUNCTION;

+#endif

 

 /**

  * task. h

@@ -615,7 +818,32 @@ void vTaskDelayUntil( TickType_t * const pxPreviousWakeTime, const TickType_t xT
 

 /**

  * task. h

- * <pre>UBaseType_t uxTaskPriorityGet( TaskHandle_t xTask );</pre>

+ * <pre>BaseType_t xTaskAbortDelay( TaskHandle_t xTask );</pre>

+ *

+ * INCLUDE_xTaskAbortDelay must be defined as 1 in FreeRTOSConfig.h for this

+ * function to be available.

+ *

+ * A task will enter the Blocked state when it is waiting for an event.  The

+ * event it is waiting for can be a temporal event (waiting for a time), such

+ * as when vTaskDelay() is called, or an event on an object, such as when

+ * xQueueReceive() or ulTaskNotifyTake() is called.  If the handle of a task

+ * that is in the Blocked state is used in a call to xTaskAbortDelay() then the

+ * task will leave the Blocked state, and return from whichever function call

+ * placed the task into the Blocked state.

+ *

+ * @param xTask The handle of the task to remove from the Blocked state.

+ *

+ * @return If the task referenced by xTask was not in the Blocked state then

+ * pdFAIL is returned.  Otherwise pdPASS is returned.

+ *

+ * \defgroup xTaskAbortDelay xTaskAbortDelay

+ * \ingroup TaskCtrl

+ */

+BaseType_t xTaskAbortDelay( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;

+

+/**

+ * task. h

+ * <pre>UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask );</pre>

  *

  * INCLUDE_uxTaskPriorityGet must be defined as 1 for this function to be available.

  * See the configuration section for more information.

@@ -658,15 +886,15 @@ void vTaskDelayUntil( TickType_t * const pxPreviousWakeTime, const TickType_t xT
  * \defgroup uxTaskPriorityGet uxTaskPriorityGet

  * \ingroup TaskCtrl

  */

-UBaseType_t uxTaskPriorityGet( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;

+UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;

 

 /**

  * task. h

- * <pre>UBaseType_t uxTaskPriorityGetFromISR( TaskHandle_t xTask );</pre>

+ * <pre>UBaseType_t uxTaskPriorityGetFromISR( const TaskHandle_t xTask );</pre>

  *

  * A version of uxTaskPriorityGet() that can be used from an ISR.

  */

-UBaseType_t uxTaskPriorityGetFromISR( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;

+UBaseType_t uxTaskPriorityGetFromISR( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;

 

 /**

  * task. h

@@ -688,6 +916,62 @@ eTaskState eTaskGetState( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;
 

 /**

  * task. h

+ * <pre>void vTaskGetInfo( TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, BaseType_t xGetFreeStackSpace, eTaskState eState );</pre>

+ *

+ * configUSE_TRACE_FACILITY must be defined as 1 for this function to be

+ * available.  See the configuration section for more information.

+ *

+ * Populates a TaskStatus_t structure with information about a task.

+ *

+ * @param xTask Handle of the task being queried.  If xTask is NULL then

+ * information will be returned about the calling task.

+ *

+ * @param pxTaskStatus A pointer to the TaskStatus_t structure that will be

+ * filled with information about the task referenced by the handle passed using

+ * the xTask parameter.

+ *

+ * @xGetFreeStackSpace The TaskStatus_t structure contains a member to report

+ * the stack high water mark of the task being queried.  Calculating the stack

+ * high water mark takes a relatively long time, and can make the system

+ * temporarily unresponsive - so the xGetFreeStackSpace parameter is provided to

+ * allow the high water mark checking to be skipped.  The high watermark value

+ * will only be written to the TaskStatus_t structure if xGetFreeStackSpace is

+ * not set to pdFALSE;

+ *

+ * @param eState The TaskStatus_t structure contains a member to report the

+ * state of the task being queried.  Obtaining the task state is not as fast as

+ * a simple assignment - so the eState parameter is provided to allow the state

+ * information to be omitted from the TaskStatus_t structure.  To obtain state

+ * information then set eState to eInvalid - otherwise the value passed in

+ * eState will be reported as the task state in the TaskStatus_t structure.

+ *

+ * Example usage:

+   <pre>

+ void vAFunction( void )

+ {

+ TaskHandle_t xHandle;

+ TaskStatus_t xTaskDetails;

+

+    // Obtain the handle of a task from its name.

+    xHandle = xTaskGetHandle( "Task_Name" );

+

+    // Check the handle is not NULL.

+    configASSERT( xHandle );

+

+    // Use the handle to obtain further information about the task.

+    vTaskGetInfo( xHandle,

+                  &xTaskDetails,

+                  pdTRUE, // Include the high water mark in xTaskDetails.

+                  eInvalid ); // Include the task state in xTaskDetails.

+ }

+   </pre>

+ * \defgroup vTaskGetInfo vTaskGetInfo

+ * \ingroup TaskCtrl

+ */

+void vTaskGetInfo( TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, BaseType_t xGetFreeStackSpace, eTaskState eState ) PRIVILEGED_FUNCTION;

+

+/**

+ * task. h

  * <pre>void vTaskPrioritySet( TaskHandle_t xTask, UBaseType_t uxNewPriority );</pre>

  *

  * INCLUDE_vTaskPrioritySet must be defined as 1 for this function to be available.

@@ -1098,17 +1382,32 @@ UBaseType_t uxTaskGetNumberOfTasks( void ) PRIVILEGED_FUNCTION;
 

 /**

  * task. h

- * <PRE>char *pcTaskGetTaskName( TaskHandle_t xTaskToQuery );</PRE>

+ * <PRE>char *pcTaskGetName( TaskHandle_t xTaskToQuery );</PRE>

  *

  * @return The text (human readable) name of the task referenced by the handle

  * xTaskToQuery.  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.

+ * handle, or by setting xTaskToQuery to NULL.

+ *

+ * \defgroup pcTaskGetName pcTaskGetName

+ * \ingroup TaskUtils

+ */

+char *pcTaskGetName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+

+/**

+ * task. h

+ * <PRE>TaskHandle_t xTaskGetHandle( const char *pcNameToQuery );</PRE>

+ *

+ * NOTE:  This function takes a relatively long time to complete and should be

+ * used sparingly.

+ *

+ * @return The handle of the task that has the human readable name pcNameToQuery.

+ * NULL is returned if no matching name is found.  INCLUDE_xTaskGetHandle

+ * must be set to 1 in FreeRTOSConfig.h for pcTaskGetHandle() to be available.

  *

- * \defgroup pcTaskGetTaskName pcTaskGetTaskName

+ * \defgroup pcTaskGetHandle pcTaskGetHandle

  * \ingroup TaskUtils

  */

-char *pcTaskGetTaskName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+TaskHandle_t xTaskGetHandle( const char *pcNameToQuery ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

 

 /**

  * task.h

@@ -1122,6 +1421,12 @@ char *pcTaskGetTaskName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION; /*lint
  * 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.

  *

+ * uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the

+ * same except for their return type.  Using configSTACK_DEPTH_TYPE allows the

+ * user to determine the return type.  It gets around the problem of the value

+ * overflowing on 8-bit types without breaking backward compatibility for

+ * applications that expect an 8-bit return type.

+ *

  * @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.

  *

@@ -1131,6 +1436,33 @@ char *pcTaskGetTaskName( TaskHandle_t xTaskToQuery ) PRIVILEGED_FUNCTION; /*lint
  */

 UBaseType_t uxTaskGetStackHighWaterMark( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;

 

+/**

+ * task.h

+ * <PRE>configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2( TaskHandle_t xTask );</PRE>

+ *

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

+ *

+ * uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the

+ * same except for their return type.  Using configSTACK_DEPTH_TYPE allows the

+ * user to determine the return type.  It gets around the problem of the value

+ * overflowing on 8-bit types without breaking backward compatibility for

+ * applications that expect an 8-bit return type.

+ *

+ * @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 words, so

+ * actual spaces on the stack rather than bytes) since the task referenced by

+ * xTask was created.

+ */

+configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;

+

 /* When using trace macros it is sometimes necessary to include task.h before

 FreeRTOS.h.  When this is done TaskHookFunction_t will not yet have been defined,

 so the following two prototypes will cause a compilation error.  This can be

@@ -1153,9 +1485,20 @@ constant. */
 		 * task.h

 		 * <pre>void xTaskGetApplicationTaskTag( TaskHandle_t xTask );</pre>

 		 *

-		 * Returns the pxHookFunction value assigned to the task xTask.

+		 * Returns the pxHookFunction value assigned to the task xTask.  Do not

+		 * call from an interrupt service routine - call

+		 * xTaskGetApplicationTaskTagFromISR() instead.

 		 */

 		TaskHookFunction_t xTaskGetApplicationTaskTag( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;

+

+		/**

+		 * task.h

+		 * <pre>void xTaskGetApplicationTaskTagFromISR( TaskHandle_t xTask );</pre>

+		 *

+		 * Returns the pxHookFunction value assigned to the task xTask.  Can

+		 * be called from an interrupt service routine.

+		 */

+		TaskHookFunction_t xTaskGetApplicationTaskTagFromISR( TaskHandle_t xTask ) PRIVILEGED_FUNCTION;

 	#endif /* configUSE_APPLICATION_TASK_TAG ==1 */

 #endif /* ifdef configUSE_APPLICATION_TASK_TAG */

 

@@ -1394,6 +1737,36 @@ void vTaskList( char * pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unquali
 void vTaskGetRunTimeStats( char *pcWriteBuffer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

 

 /**

+* task. h

+* <PRE>TickType_t xTaskGetIdleRunTimeCounter( void );</PRE>

+*

+* configGENERATE_RUN_TIME_STATS and configUSE_STATS_FORMATTING_FUNCTIONS

+* must both 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.

+*

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

+* While uxTaskGetSystemState() and vTaskGetRunTimeStats() writes the total

+* execution time of each task into a buffer, xTaskGetIdleRunTimeCounter()

+* returns the total execution time of just the idle task.

+*

+* @return The total run time of the idle task.  This is the amount of time the

+* idle task has actually been executing.  The unit of time is dependent on the

+* frequency configured using the portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() and

+* portGET_RUN_TIME_COUNTER_VALUE() macros.

+*

+* \defgroup xTaskGetIdleRunTimeCounter xTaskGetIdleRunTimeCounter

+* \ingroup TaskUtils

+*/

+TickType_t xTaskGetIdleRunTimeCounter( void ) PRIVILEGED_FUNCTION;

+

+/**

  * task. h

  * <PRE>BaseType_t xTaskNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction );</PRE>

  *

@@ -1894,7 +2267,7 @@ void vTaskPlaceOnUnorderedEventList( List_t * pxEventList, const TickType_t xIte
  * indefinitely, whereas vTaskPlaceOnEventList() does.

  *

  */

-void vTaskPlaceOnEventListRestricted( List_t * const pxEventList, const TickType_t xTicksToWait, const BaseType_t xWaitIndefinitely ) PRIVILEGED_FUNCTION;

+void vTaskPlaceOnEventListRestricted( List_t * const pxEventList, TickType_t xTicksToWait, const BaseType_t xWaitIndefinitely ) PRIVILEGED_FUNCTION;

 

 /*

  * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS AN

@@ -1905,14 +2278,14 @@ void vTaskPlaceOnEventListRestricted( List_t * const pxEventList, const TickType
  * Removes a task from both the specified event list and the list of blocked

  * tasks, and places it on a ready queue.

  *

- * xTaskRemoveFromEventList()/xTaskRemoveFromUnorderedEventList() will be called

+ * xTaskRemoveFromEventList()/vTaskRemoveFromUnorderedEventList() will be called

  * if either an event occurs to unblock a task, or the block timeout period

  * expires.

  *

  * xTaskRemoveFromEventList() is used when the event list is in task priority

  * order.  It removes the list item from the head of the event list as that will

  * have the highest priority owning task of all the tasks on the event list.

- * xTaskRemoveFromUnorderedEventList() is used when the event list is not

+ * vTaskRemoveFromUnorderedEventList() is used when the event list is not

  * ordered and the event list items hold something other than the owning tasks

  * priority.  In this case the event list item value is updated to the value

  * passed in the xItemValue parameter.

@@ -1921,7 +2294,7 @@ void vTaskPlaceOnEventListRestricted( List_t * const pxEventList, const TickType
  * making the call, otherwise pdFALSE.

  */

 BaseType_t xTaskRemoveFromEventList( const List_t * const pxEventList ) PRIVILEGED_FUNCTION;

-BaseType_t xTaskRemoveFromUnorderedEventList( ListItem_t * pxEventListItem, const TickType_t xItemValue ) PRIVILEGED_FUNCTION;

+void vTaskRemoveFromUnorderedEventList( ListItem_t * pxEventListItem, const TickType_t xItemValue ) PRIVILEGED_FUNCTION;

 

 /*

  * THIS FUNCTION MUST NOT BE USED FROM APPLICATION CODE.  IT IS ONLY

@@ -1971,7 +2344,7 @@ BaseType_t 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( TaskHandle_t const pxMutexHolder ) PRIVILEGED_FUNCTION;

+BaseType_t xTaskPriorityInherit( TaskHandle_t const pxMutexHolder ) PRIVILEGED_FUNCTION;

 

 /*

  * Set the priority of a task back to its proper priority in the case that it

@@ -1980,10 +2353,14 @@ void vTaskPriorityInherit( TaskHandle_t const pxMutexHolder ) PRIVILEGED_FUNCTIO
 BaseType_t xTaskPriorityDisinherit( TaskHandle_t const pxMutexHolder ) PRIVILEGED_FUNCTION;

 

 /*

- * Generic version of the task creation function which is in turn called by the

- * xTaskCreate() and xTaskCreateRestricted() macros.

+ * If a higher priority task attempting to obtain a mutex caused a lower

+ * priority task to inherit the higher priority task's priority - but the higher

+ * priority task then timed out without obtaining the mutex, then the lower

+ * priority task will disinherit the priority again - but only down as far as

+ * the highest priority task that is still waiting for the mutex (if there were

+ * more than one task waiting for the mutex).

  */

-BaseType_t xTaskGenericCreate( TaskFunction_t pxTaskCode, const char * const pcName, const uint16_t usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pxCreatedTask, StackType_t * const puxStackBuffer, const MemoryRegion_t * const xRegions ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+void vTaskPriorityDisinheritAfterTimeout( TaskHandle_t const pxMutexHolder, UBaseType_t uxHighestPriorityWaitingTask ) PRIVILEGED_FUNCTION;

 

 /*

  * Get the uxTCBNumber assigned to the task referenced by the xTask parameter.

@@ -2007,7 +2384,7 @@ void vTaskSetTaskNumber( TaskHandle_t xTask, const UBaseType_t uxHandle ) PRIVIL
 void vTaskStepTick( const TickType_t xTicksToJump ) PRIVILEGED_FUNCTION;

 

 /*

- * Only avilable when configUSE_TICKLESS_IDLE is set to 1.

+ * Only available when configUSE_TICKLESS_IDLE is set to 1.

  * Provided for use within portSUPPRESS_TICKS_AND_SLEEP() to allow the port

  * specific sleep function to determine if it is ok to proceed with the sleep,

  * and if it is ok to proceed, if it is ok to sleep indefinitely.

@@ -2026,7 +2403,14 @@ eSleepModeStatus eTaskConfirmSleepModeStatus( void ) PRIVILEGED_FUNCTION;
  * For internal use only.  Increment the mutex held count when a mutex is

  * taken and return the handle of the task that has taken the mutex.

  */

-void *pvTaskIncrementMutexHeldCount( void ) PRIVILEGED_FUNCTION;

+TaskHandle_t pvTaskIncrementMutexHeldCount( void ) PRIVILEGED_FUNCTION;

+

+/*

+ * For internal use only.  Same as vTaskSetTimeOutState(), but without a critial

+ * section.

+ */

+void vTaskInternalSetTimeOutState( TimeOut_t * const pxTimeOut ) PRIVILEGED_FUNCTION;

+

 

 #ifdef __cplusplus

 }

diff --git a/src/FreeRTOS/Source/include/timers.h b/src/FreeRTOS/Source/include/timers.h
index 3c6c6bf..7aaf1ae 100644
--- a/src/FreeRTOS/Source/include/timers.h
+++ b/src/FreeRTOS/Source/include/timers.h
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 

 #ifndef TIMERS_H

@@ -75,10 +33,10 @@
 	#error "include FreeRTOS.h must appear in source files before include timers.h"

 #endif

 

-/*lint -e537 This headers are only multiply included if the application code

+/*lint -save -e537 This headers are only multiply included if the application code

 happens to also be including task.h. */

 #include "task.h"

-/*lint +e537 */

+/*lint -restore */

 

 #ifdef __cplusplus

 extern "C" {

@@ -115,7 +73,8 @@ or interrupt version of the queue send function should be used. */
  * reference the subject timer in calls to other software timer API functions

  * (for example, xTimerStart(), xTimerReset(), etc.).

  */

-typedef void * TimerHandle_t;

+struct tmrTimerControl; /* The old naming convention is used to prevent breaking kernel aware debuggers. */

+typedef struct tmrTimerControl * TimerHandle_t;

 

 /*

  * Defines the prototype to which timer callback functions must conform.

@@ -135,9 +94,17 @@ typedef void (*PendedFunction_t)( void *, uint32_t );
  * 								void * pvTimerID,

  * 								TimerCallbackFunction_t 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.

+ * Creates a new software timer instance, and returns a handle by which the

+ * created software timer can be referenced.

+ *

+ * Internally, within the FreeRTOS implementation, software timers use a block

+ * of memory, in which the timer data structure is stored.  If a software timer

+ * is created using xTimerCreate() then the required memory is automatically

+ * dynamically allocated inside the xTimerCreate() function.  (see

+ * http://www.freertos.org/a00111.html).  If a software timer is created using

+ * xTimerCreateStatic() then the application writer must provide the memory that

+ * will get used by the software timer.  xTimerCreateStatic() therefore allows a

+ * software timer to be created without using any dynamic memory allocation.

  *

  * Timers are created in the dormant state.  The xTimerStart(), xTimerReset(),

  * xTimerStartFromISR(), xTimerResetFromISR(), xTimerChangePeriod() and

@@ -250,14 +217,151 @@ typedef void (*PendedFunction_t)( void *, uint32_t );
  *

  *     // Starting the scheduler will start the timers running as they have already

  *     // been set into the active state.

- *     xTaskStartScheduler();

+ *     vTaskStartScheduler();

  *

  *     // Should not reach here.

  *     for( ;; );

  * }

  * @endverbatim

  */

-TimerHandle_t xTimerCreate( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

+	TimerHandle_t xTimerCreate(	const char * const pcTimerName,			/*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+								const TickType_t xTimerPeriodInTicks,

+								const UBaseType_t uxAutoReload,

+								void * const pvTimerID,

+								TimerCallbackFunction_t pxCallbackFunction ) PRIVILEGED_FUNCTION;

+#endif

+

+/**

+ * TimerHandle_t xTimerCreateStatic(const char * const pcTimerName,

+ * 									TickType_t xTimerPeriodInTicks,

+ * 									UBaseType_t uxAutoReload,

+ * 									void * pvTimerID,

+ * 									TimerCallbackFunction_t pxCallbackFunction,

+ *									StaticTimer_t *pxTimerBuffer );

+ *

+ * Creates a new software timer instance, and returns a handle by which the

+ * created software timer can be referenced.

+ *

+ * Internally, within the FreeRTOS implementation, software timers use a block

+ * of memory, in which the timer data structure is stored.  If a software timer

+ * is created using xTimerCreate() then the required memory is automatically

+ * dynamically allocated inside the xTimerCreate() function.  (see

+ * http://www.freertos.org/a00111.html).  If a software timer is created using

+ * xTimerCreateStatic() then the application writer must provide the memory that

+ * will get used by the software timer.  xTimerCreateStatic() therefore allows a

+ * software timer to be created without using any dynamic memory allocation.

+ *

+ * 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_PERIOD_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_PERIOD_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 TimerCallbackFunction_t,

+ * which is "void vCallbackFunction( TimerHandle_t xTimer );".

+ *

+ * @param pxTimerBuffer Must point to a variable of type StaticTimer_t, which

+ * will be then be used to hold the software timer's data structures, removing

+ * the need for the memory to be allocated dynamically.

+ *

+ * @return If the timer is created then a handle to the created timer is

+ * returned.  If pxTimerBuffer was NULL then NULL is returned.

+ *

+ * Example usage:

+ * @verbatim

+ *

+ * // The buffer used to hold the software timer's data structure.

+ * static StaticTimer_t xTimerBuffer;

+ *

+ * // A variable that will be incremented by the software timer's callback

+ * // function.

+ * UBaseType_t uxVariableToIncrement = 0;

+ *

+ * // A software timer callback function that increments a variable passed to

+ * // it when the software timer was created.  After the 5th increment the

+ * // callback function stops the software timer.

+ * static void prvTimerCallback( TimerHandle_t xExpiredTimer )

+ * {

+ * UBaseType_t *puxVariableToIncrement;

+ * BaseType_t xReturned;

+ *

+ *     // Obtain the address of the variable to increment from the timer ID.

+ *     puxVariableToIncrement = ( UBaseType_t * ) pvTimerGetTimerID( xExpiredTimer );

+ *

+ *     // Increment the variable to show the timer callback has executed.

+ *     ( *puxVariableToIncrement )++;

+ *

+ *     // If this callback has executed the required number of times, stop the

+ *     // timer.

+ *     if( *puxVariableToIncrement == 5 )

+ *     {

+ *         // This is called from a timer callback so must not block.

+ *         xTimerStop( xExpiredTimer, staticDONT_BLOCK );

+ *     }

+ * }

+ *

+ *

+ * void main( void )

+ * {

+ *     // Create the software time.  xTimerCreateStatic() has an extra parameter

+ *     // than the normal xTimerCreate() API function.  The parameter is a pointer

+ *     // to the StaticTimer_t structure that will hold the software timer

+ *     // structure.  If the parameter is passed as NULL then the structure will be

+ *     // allocated dynamically, just as if xTimerCreate() had been called.

+ *     xTimer = xTimerCreateStatic( "T1",             // Text name for the task.  Helps debugging only.  Not used by FreeRTOS.

+ *                                  xTimerPeriod,     // The period of the timer in ticks.

+ *                                  pdTRUE,           // This is an auto-reload timer.

+ *                                  ( void * ) &uxVariableToIncrement,    // A variable incremented by the software timer's callback function

+ *                                  prvTimerCallback, // The function to execute when the timer expires.

+ *                                  &xTimerBuffer );  // The buffer that will hold the software timer structure.

+ *

+ *     // The scheduler has not started yet so a block time is not used.

+ *     xReturned = xTimerStart( xTimer, 0 );

+ *

+ *     // ...

+ *     // Create tasks here.

+ *     // ...

+ *

+ *     // Starting the scheduler will start the timers running as they have already

+ *     // been set into the active state.

+ *     vTaskStartScheduler();

+ *

+ *     // Should not reach here.

+ *     for( ;; );

+ * }

+ * @endverbatim

+ */

+#if( configSUPPORT_STATIC_ALLOCATION == 1 )

+	TimerHandle_t xTimerCreateStatic(	const char * const pcTimerName,			/*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+										const TickType_t xTimerPeriodInTicks,

+										const UBaseType_t uxAutoReload,

+										void * const pvTimerID,

+										TimerCallbackFunction_t pxCallbackFunction,

+										StaticTimer_t *pxTimerBuffer ) PRIVILEGED_FUNCTION;

+#endif /* configSUPPORT_STATIC_ALLOCATION */

 

 /**

  * void *pvTimerGetTimerID( TimerHandle_t xTimer );

@@ -342,9 +446,6 @@ BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;
 /**

  * TaskHandle_t xTimerGetTimerDaemonTaskHandle( void );

  *

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

  */

@@ -677,7 +778,7 @@ TaskHandle_t xTimerGetTimerDaemonTaskHandle( void ) PRIVILEGED_FUNCTION;
  *

  *     // Starting the scheduler will start the timer running as it has already

  *     // been set into the active state.

- *     xTaskStartScheduler();

+ *     vTaskStartScheduler();

  *

  *     // Should not reach here.

  *     for( ;; );

@@ -1120,7 +1221,7 @@ BaseType_t xTimerPendFunctionCallFromISR( PendedFunction_t xFunctionToPend, void
 BaseType_t xTimerPendFunctionCall( PendedFunction_t xFunctionToPend, void *pvParameter1, uint32_t ulParameter2, TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;

 

 /**

- * const char * const pcTimerGetTimerName( TimerHandle_t xTimer );

+ * const char * const pcTimerGetName( TimerHandle_t xTimer );

  *

  * Returns the name that was assigned to a timer when the timer was created.

  *

@@ -1128,7 +1229,50 @@ BaseType_t xTimerPendFunctionCall( PendedFunction_t xFunctionToPend, void *pvPar
  *

  * @return The name assigned to the timer specified by the xTimer parameter.

  */

-const char * pcTimerGetTimerName( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+const char * pcTimerGetName( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+

+/**

+ * void vTimerSetReloadMode( TimerHandle_t xTimer, const UBaseType_t uxAutoReload );

+ *

+ * Updates a timer to be either an autoreload timer, in which case the timer

+ * automatically resets itself each time it expires, or a one shot timer, in

+ * which case the timer will only expire once unless it is manually restarted.

+ *

+ * @param xTimer The handle of the timer being updated.

+ *

+ * @param uxAutoReload If uxAutoReload is set to pdTRUE then the timer will

+ * expire repeatedly with a frequency set by the timer's period (see the

+ * xTimerPeriodInTicks parameter of the xTimerCreate() API function).  If

+ * uxAutoReload is set to pdFALSE then the timer will be a one-shot timer and

+ * enter the dormant state after it expires.

+ */

+void vTimerSetReloadMode( TimerHandle_t xTimer, const UBaseType_t uxAutoReload ) PRIVILEGED_FUNCTION;

+

+/**

+ * TickType_t xTimerGetPeriod( TimerHandle_t xTimer );

+ *

+ * Returns the period of a timer.

+ *

+ * @param xTimer The handle of the timer being queried.

+ *

+ * @return The period of the timer in ticks.

+ */

+TickType_t xTimerGetPeriod( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;

+

+/**

+* TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer );

+*

+* Returns the time in ticks at which the timer will expire.  If this is less

+* than the current tick count then the expiry time has overflowed from the

+* current time.

+*

+* @param xTimer The handle of the timer being queried.

+*

+* @return If the timer is running then the time in ticks at which the timer

+* will next expire is returned.  If the timer is not running then the return

+* value is undefined.

+*/

+TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;

 

 /*

  * Functions beyond this part are not part of the public API and are intended

@@ -1137,6 +1281,11 @@ const char * pcTimerGetTimerName( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION; /*
 BaseType_t xTimerCreateTimerTask( void ) PRIVILEGED_FUNCTION;

 BaseType_t xTimerGenericCommand( TimerHandle_t xTimer, const BaseType_t xCommandID, const TickType_t xOptionalValue, BaseType_t * const pxHigherPriorityTaskWoken, const TickType_t xTicksToWait ) PRIVILEGED_FUNCTION;

 

+#if( configUSE_TRACE_FACILITY == 1 )

+	void vTimerSetTimerNumber( TimerHandle_t xTimer, UBaseType_t uxTimerNumber ) PRIVILEGED_FUNCTION;

+	UBaseType_t uxTimerGetTimerNumber( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION;

+#endif

+

 #ifdef __cplusplus

 }

 #endif

diff --git a/src/FreeRTOS/Source/list.c b/src/FreeRTOS/Source/list.c
index ebacafd..75f9b44 100644
--- a/src/FreeRTOS/Source/list.c
+++ b/src/FreeRTOS/Source/list.c
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 

 #include <stdlib.h>

@@ -81,7 +39,7 @@ void vListInitialise( List_t * const 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 = ( ListItem_t * ) &( pxList->xListEnd );			/*lint !e826 !e740 The mini list structure is used as the list end to save RAM.  This is checked and valid. */

+	pxList->pxIndex = ( ListItem_t * ) &( pxList->xListEnd );			/*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM.  This is checked and valid. */

 

 	/* The list end value is the highest possible value in the list to

 	ensure it remains at the end of the list. */

@@ -89,8 +47,8 @@ void vListInitialise( List_t * const pxList )
 

 	/* The list end next and previous pointers point to itself so we know

 	when the list is empty. */

-	pxList->xListEnd.pxNext = ( ListItem_t * ) &( pxList->xListEnd );	/*lint !e826 !e740 The mini list structure is used as the list end to save RAM.  This is checked and valid. */

-	pxList->xListEnd.pxPrevious = ( ListItem_t * ) &( pxList->xListEnd );/*lint !e826 !e740 The mini list structure is used as the list end to save RAM.  This is checked and valid. */

+	pxList->xListEnd.pxNext = ( ListItem_t * ) &( pxList->xListEnd );	/*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM.  This is checked and valid. */

+	pxList->xListEnd.pxPrevious = ( ListItem_t * ) &( pxList->xListEnd );/*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM.  This is checked and valid. */

 

 	pxList->uxNumberOfItems = ( UBaseType_t ) 0U;

 

@@ -104,7 +62,7 @@ void vListInitialise( List_t * const pxList )
 void vListInitialiseItem( ListItem_t * const pxItem )

 {

 	/* Make sure the list item is not recorded as being on a list. */

-	pxItem->pvContainer = NULL;

+	pxItem->pxContainer = NULL;

 

 	/* Write known values into the list item if

 	configUSE_LIST_DATA_INTEGRITY_CHECK_BYTES is set to 1. */

@@ -136,7 +94,7 @@ ListItem_t * const pxIndex = pxList->pxIndex;
 	pxIndex->pxPrevious = pxNewListItem;

 

 	/* Remember which list the item is in. */

-	pxNewListItem->pvContainer = ( void * ) pxList;

+	pxNewListItem->pxContainer = pxList;

 

 	( pxList->uxNumberOfItems )++;

 }

@@ -156,7 +114,7 @@ const TickType_t xValueOfInsertion = pxNewListItem->xItemValue;
 	/* Insert the new list item into the list, sorted in xItemValue order.

 

 	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

+	new list item should be placed after it.  This ensures that TCBs which are

 	stored in ready lists (all of which have the same xItemValue value) get a

 	share of the CPU.  However, if the xItemValue is the same as the back marker

 	the iteration loop below will not end.  Therefore the value is checked

@@ -169,18 +127,18 @@ const TickType_t xValueOfInsertion = pxNewListItem->xItemValue;
 	{

 		/* *** NOTE ***********************************************************

 		If you find your application is crashing here then likely causes are

-		listed below.  In addition see http://www.freertos.org/FAQHelp.html for

+		listed below.  In addition see https://www.freertos.org/FAQHelp.html for

 		more tips, and ensure configASSERT() is defined!

-		http://www.freertos.org/a00110.html#configASSERT

+		https://www.freertos.org/a00110.html#configASSERT

 

 			1) Stack overflow -

-			   see http://www.freertos.org/Stacks-and-stack-overflow-checking.html

+			   see https://www.freertos.org/Stacks-and-stack-overflow-checking.html

 			2) Incorrect interrupt priority assignment, especially on Cortex-M

 			   parts where numerically high priority values denote low actual

 			   interrupt priorities, which can seem counter intuitive.  See

-			   http://www.freertos.org/RTOS-Cortex-M3-M4.html and the definition

+			   https://www.freertos.org/RTOS-Cortex-M3-M4.html and the definition

 			   of configMAX_SYSCALL_INTERRUPT_PRIORITY on

-			   http://www.freertos.org/a00110.html

+			   https://www.freertos.org/a00110.html

 			3) Calling an API function from within a critical section or when

 			   the scheduler is suspended, or calling an API function that does

 			   not end in "FromISR" from an interrupt.

@@ -189,7 +147,7 @@ const TickType_t xValueOfInsertion = pxNewListItem->xItemValue;
 			   before vTaskStartScheduler() has been called?).

 		**********************************************************************/

 

-		for( pxIterator = ( ListItem_t * ) &( pxList->xListEnd ); pxIterator->pxNext->xItemValue <= xValueOfInsertion; pxIterator = pxIterator->pxNext ) /*lint !e826 !e740 The mini list structure is used as the list end to save RAM.  This is checked and valid. */

+		for( pxIterator = ( ListItem_t * ) &( pxList->xListEnd ); pxIterator->pxNext->xItemValue <= xValueOfInsertion; pxIterator = pxIterator->pxNext ) /*lint !e826 !e740 !e9087 The mini list structure is used as the list end to save RAM.  This is checked and valid. *//*lint !e440 The iterator moves to a different value, not xValueOfInsertion. */

 		{

 			/* There is nothing to do here, just iterating to the wanted

 			insertion position. */

@@ -203,7 +161,7 @@ const TickType_t xValueOfInsertion = pxNewListItem->xItemValue;
 

 	/* Remember which list the item is in.  This allows fast removal of the

 	item later. */

-	pxNewListItem->pvContainer = ( void * ) pxList;

+	pxNewListItem->pxContainer = pxList;

 

 	( pxList->uxNumberOfItems )++;

 }

@@ -213,7 +171,7 @@ UBaseType_t uxListRemove( ListItem_t * const pxItemToRemove )
 {

 /* The list item knows which list it is in.  Obtain the list from the list

 item. */

-List_t * const pxList = ( List_t * ) pxItemToRemove->pvContainer;

+List_t * const pxList = pxItemToRemove->pxContainer;

 

 	pxItemToRemove->pxNext->pxPrevious = pxItemToRemove->pxPrevious;

 	pxItemToRemove->pxPrevious->pxNext = pxItemToRemove->pxNext;

@@ -231,7 +189,7 @@ List_t * const pxList = ( List_t * ) pxItemToRemove->pvContainer;
 		mtCOVERAGE_TEST_MARKER();

 	}

 

-	pxItemToRemove->pvContainer = NULL;

+	pxItemToRemove->pxContainer = NULL;

 	( pxList->uxNumberOfItems )--;

 

 	return pxList->uxNumberOfItems;

diff --git a/src/FreeRTOS/Source/portable/GCC/ARM_CM4F/port.c b/src/FreeRTOS/Source/portable/GCC/ARM_CM4F/port.c
index 4732d98..e75f81e 100644
--- a/src/FreeRTOS/Source/portable/GCC/ARM_CM4F/port.c
+++ b/src/FreeRTOS/Source/portable/GCC/ARM_CM4F/port.c
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

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

  * Implementation of functions defined in portable.h for the ARM CM4F port.

@@ -129,11 +87,15 @@ r0p1 port. */
 

 /* Constants required to set up the initial stack. */

 #define portINITIAL_XPSR					( 0x01000000 )

-#define portINITIAL_EXEC_RETURN				( 0xfffffffd )

+#define portINITIAL_EXC_RETURN				( 0xfffffffd )

 

 /* The systick is a 24-bit counter. */

 #define portMAX_24_BIT_NUMBER				( 0xffffffUL )

 

+/* For strict compliance with the Cortex-M spec the task start address should

+have bit-0 clear, as it is loaded into the PC on exit from an ISR. */

+#define portSTART_ADDRESS_MASK		( ( StackType_t ) 0xfffffffeUL )

+

 /* A fiddle factor to estimate the number of SysTick counts that would have

 occurred while the SysTick counter is stopped during tickless idle

 calculations. */

@@ -148,10 +110,6 @@ debugger. */
 	#define portTASK_RETURN_ADDRESS	prvTaskExitError

 #endif

 

-/* Each task maintains its own interrupt status in the critical nesting

-variable. */

-static UBaseType_t uxCriticalNesting = 0xaaaaaaaa;

-

 /*

  * Setup the timer to generate the tick interrupts.  The implementation in this

  * file is weak to allow application writers to change the timer used to

@@ -174,7 +132,7 @@ static void prvPortStartFirstTask( void ) __attribute__ (( naked ));
 /*

  * Function to enable the VFP.

  */

- static void vPortEnableVFP( void ) __attribute__ (( naked ));

+static void vPortEnableVFP( void ) __attribute__ (( naked ));

 

 /*

  * Used to catch tasks that attempt to return from their implementing function.

@@ -183,10 +141,14 @@ static void prvTaskExitError( void );
 

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

 

+/* Each task maintains its own interrupt status in the critical nesting

+variable. */

+static UBaseType_t uxCriticalNesting = 0xaaaaaaaa;

+

 /*

  * The number of SysTick increments that make up one tick period.

  */

-#if configUSE_TICKLESS_IDLE == 1

+#if( configUSE_TICKLESS_IDLE == 1 )

 	static uint32_t ulTimerCountsForOneTick = 0;

 #endif /* configUSE_TICKLESS_IDLE */

 

@@ -194,7 +156,7 @@ static void prvTaskExitError( void );
  * The maximum number of tick periods that can be suppressed is limited by the

  * 24 bit resolution of the SysTick timer.

  */

-#if configUSE_TICKLESS_IDLE == 1

+#if( configUSE_TICKLESS_IDLE == 1 )

 	static uint32_t xMaximumPossibleSuppressedTicks = 0;

 #endif /* configUSE_TICKLESS_IDLE */

 

@@ -202,7 +164,7 @@ static void prvTaskExitError( void );
  * Compensate for the CPU cycles that pass while the SysTick is stopped (low

  * power functionality only.

  */

-#if configUSE_TICKLESS_IDLE == 1

+#if( configUSE_TICKLESS_IDLE == 1 )

 	static uint32_t ulStoppedTimerCompensation = 0;

 #endif /* configUSE_TICKLESS_IDLE */

 

@@ -211,7 +173,7 @@ static void prvTaskExitError( void );
  * FreeRTOS API functions are not called from interrupts that have been assigned

  * a priority above configMAX_SYSCALL_INTERRUPT_PRIORITY.

  */

-#if ( configASSERT_DEFINED == 1 )

+#if( configASSERT_DEFINED == 1 )

 	 static uint8_t ucMaxSysCallPriority = 0;

 	 static uint32_t ulMaxPRIGROUPValue = 0;

 	 static const volatile uint8_t * const pcInterruptPriorityRegisters = ( const volatile uint8_t * const ) portNVIC_IP_REGISTERS_OFFSET_16;

@@ -233,7 +195,7 @@ StackType_t *pxPortInitialiseStack( StackType_t *pxTopOfStack, TaskFunction_t px
 

 	*pxTopOfStack = portINITIAL_XPSR;	/* xPSR */

 	pxTopOfStack--;

-	*pxTopOfStack = ( StackType_t ) pxCode;	/* PC */

+	*pxTopOfStack = ( ( StackType_t ) pxCode ) & portSTART_ADDRESS_MASK;	/* PC */

 	pxTopOfStack--;

 	*pxTopOfStack = ( StackType_t ) portTASK_RETURN_ADDRESS;	/* LR */

 

@@ -244,7 +206,7 @@ StackType_t *pxPortInitialiseStack( StackType_t *pxTopOfStack, TaskFunction_t px
 	/* A save method is being used that requires each task to maintain its

 	own exec return value. */

 	pxTopOfStack--;

-	*pxTopOfStack = portINITIAL_EXEC_RETURN;

+	*pxTopOfStack = portINITIAL_EXC_RETURN;

 

 	pxTopOfStack -= 8;	/* R11, R10, R9, R8, R7, R6, R5 and R4. */

 

@@ -254,6 +216,8 @@ StackType_t *pxPortInitialiseStack( StackType_t *pxTopOfStack, TaskFunction_t px
 

 static void prvTaskExitError( void )

 {

+volatile uint32_t ulDummy = 0;

+

 	/* A function that implements a task must not exit or attempt to return to

 	its caller as there is nothing to return to.  If a task wants to exit it

 	should instead call vTaskDelete( NULL ).

@@ -262,7 +226,16 @@ static void prvTaskExitError( void )
 	defined, then stop here so application writers can catch the error. */

 	configASSERT( uxCriticalNesting == ~0UL );

 	portDISABLE_INTERRUPTS();

-	for( ;; );

+	while( ulDummy == 0 )

+	{

+		/* This file calls prvTaskExitError() after the scheduler has been

+		started to remove a compiler warning about the function being defined

+		but never called.  ulDummy is used purely to quieten other warnings

+		about code appearing after this function is called - making ulDummy

+		volatile makes the compiler think the function could return and

+		therefore not output an 'unreachable code' warning for code that appears

+		after it. */

+	}

 }

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

 

@@ -279,7 +252,7 @@ void vPortSVCHandler( void )
 					"	msr	basepri, r0					\n"

 					"	bx r14							\n"

 					"									\n"

-					"	.align 2						\n"

+					"	.align 4						\n"

 					"pxCurrentTCBConst2: .word pxCurrentTCB				\n"

 				);

 }

@@ -287,11 +260,17 @@ void vPortSVCHandler( void )
 

 static void prvPortStartFirstTask( void )

 {

+	/* Start the first task.  This also clears the bit that indicates the FPU is

+	in use in case the FPU was used before the scheduler was started - which

+	would otherwise result in the unnecessary leaving of space in the SVC stack

+	for lazy saving of FPU registers. */

 	__asm volatile(

 					" ldr r0, =0xE000ED08 	\n" /* Use the NVIC offset register to locate the stack. */

 					" ldr r0, [r0] 			\n"

 					" ldr r0, [r0] 			\n"

 					" msr msp, r0			\n" /* Set the msp back to the start of the stack. */

+					" mov r0, #0			\n" /* Clear the bit that indicates the FPU is in use, see comment above. */

+					" msr control, r0		\n"

 					" cpsie i				\n" /* Globally enable interrupts. */

 					" cpsie f				\n"

 					" dsb					\n"

@@ -350,6 +329,24 @@ BaseType_t xPortStartScheduler( void )
 			ucMaxPriorityValue <<= ( uint8_t ) 0x01;

 		}

 

+		#ifdef __NVIC_PRIO_BITS

+		{

+			/* Check the CMSIS configuration that defines the number of

+			priority bits matches the number of priority bits actually queried

+			from the hardware. */

+			configASSERT( ( portMAX_PRIGROUP_BITS - ulMaxPRIGROUPValue ) == __NVIC_PRIO_BITS );

+		}

+		#endif

+

+		#ifdef configPRIO_BITS

+		{

+			/* Check the FreeRTOS configuration that defines the number of

+			priority bits matches the number of priority bits actually queried

+			from the hardware. */

+			configASSERT( ( portMAX_PRIGROUP_BITS - ulMaxPRIGROUPValue ) == configPRIO_BITS );

+		}

+		#endif

+

 		/* Shift the priority group value back to its position within the AIRCR

 		register. */

 		ulMaxPRIGROUPValue <<= portPRIGROUP_SHIFT;

@@ -384,7 +381,10 @@ BaseType_t xPortStartScheduler( void )
 	/* Should never get here as the tasks will now be executing!  Call the task

 	exit error function to prevent compiler warnings about a static function

 	not being called in the case that the application writer overrides this

-	functionality by defining configTASK_RETURN_ADDRESS. */

+	functionality by defining configTASK_RETURN_ADDRESS.  Call

+	vTaskSwitchContext() so link time optimisation does not remove the

+	symbol. */

+	vTaskSwitchContext();

 	prvTaskExitError();

 

 	/* Should not get here! */

@@ -445,18 +445,17 @@ void xPortPendSVHandler( void )
 	"	vstmdbeq r0!, {s16-s31}				\n"

 	"										\n"

 	"	stmdb r0!, {r4-r11, r14}			\n" /* Save the core registers. */

-	"										\n"

 	"	str r0, [r2]						\n" /* Save the new top of stack into the first member of the TCB. */

 	"										\n"

-	"	stmdb sp!, {r3}						\n"

+	"	stmdb sp!, {r0, r3}					\n"

 	"	mov r0, %0 							\n"

 	"	msr basepri, r0						\n"

 	"	dsb									\n"

-	"   isb									\n"

+	"	isb									\n"

 	"	bl vTaskSwitchContext				\n"

 	"	mov r0, #0							\n"

 	"	msr basepri, r0						\n"

-	"	ldmia sp!, {r3}						\n"

+	"	ldmia sp!, {r0, r3}					\n"

 	"										\n"

 	"	ldr r1, [r3]						\n" /* The first item in pxCurrentTCB is the task top of stack. */

 	"	ldr r0, [r1]						\n"

@@ -479,7 +478,7 @@ void xPortPendSVHandler( void )
 	"										\n"

 	"	bx r14								\n"

 	"										\n"

-	"	.align 2							\n"

+	"	.align 4							\n"

 	"pxCurrentTCBConst: .word pxCurrentTCB	\n"

 	::"i"(configMAX_SYSCALL_INTERRUPT_PRIORITY)

 	);

@@ -492,7 +491,7 @@ void xPortSysTickHandler( void )
 	executes all interrupts must be unmasked.  There is therefore no need to

 	save and then restore the interrupt mask value as its value is already

 	known. */

-	( void ) portSET_INTERRUPT_MASK_FROM_ISR();

+	portDISABLE_INTERRUPTS();

 	{

 		/* Increment the RTOS tick. */

 		if( xTaskIncrementTick() != pdFALSE )

@@ -502,15 +501,15 @@ void xPortSysTickHandler( void )
 			portNVIC_INT_CTRL_REG = portNVIC_PENDSVSET_BIT;

 		}

 	}

-	portCLEAR_INTERRUPT_MASK_FROM_ISR( 0 );

+	portENABLE_INTERRUPTS();

 }

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

 

-#if configUSE_TICKLESS_IDLE == 1

+#if( configUSE_TICKLESS_IDLE == 1 )

 

 	__attribute__((weak)) void vPortSuppressTicksAndSleep( TickType_t xExpectedIdleTime )

 	{

-	uint32_t ulReloadValue, ulCompleteTickPeriods, ulCompletedSysTickDecrements, ulSysTickCTRL;

+	uint32_t ulReloadValue, ulCompleteTickPeriods, ulCompletedSysTickDecrements;

 	TickType_t xModifiableIdleTime;

 

 		/* Make sure the SysTick reload value does not overflow the counter. */

@@ -536,7 +535,9 @@ void xPortSysTickHandler( void )
 

 		/* Enter a critical section but don't use the taskENTER_CRITICAL()

 		method as that will mask interrupts that should exit sleep mode. */

-		__asm volatile( "cpsid i" );

+		__asm volatile( "cpsid i" ::: "memory" );

+		__asm volatile( "dsb" );

+		__asm volatile( "isb" );

 

 		/* If a context switch is pending or a task is waiting for the scheduler

 		to be unsuspended then abandon the low power entry. */

@@ -555,7 +556,7 @@ void xPortSysTickHandler( void )
 

 			/* Re-enable interrupts - see comments above the cpsid instruction()

 			above. */

-			__asm volatile( "cpsie i" );

+			__asm volatile( "cpsie i" ::: "memory" );

 		}

 		else

 		{

@@ -578,29 +579,47 @@ void xPortSysTickHandler( void )
 			configPRE_SLEEP_PROCESSING( xModifiableIdleTime );

 			if( xModifiableIdleTime > 0 )

 			{

-				__asm volatile( "dsb" );

+				__asm volatile( "dsb" ::: "memory" );

 				__asm volatile( "wfi" );

 				__asm volatile( "isb" );

 			}

 			configPOST_SLEEP_PROCESSING( xExpectedIdleTime );

 

-			/* Stop SysTick.  Again, the time the SysTick is stopped for is

-			accounted for as best it can be, but using the tickless mode will

-			inevitably result in some tiny drift of the time maintained by the

-			kernel with respect to calendar time. */

-			ulSysTickCTRL = portNVIC_SYSTICK_CTRL_REG;

-			portNVIC_SYSTICK_CTRL_REG = ( ulSysTickCTRL & ~portNVIC_SYSTICK_ENABLE_BIT );

-

-			/* Re-enable interrupts - see comments above the cpsid instruction()

-			above. */

-			__asm volatile( "cpsie i" );

-

-			if( ( ulSysTickCTRL & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )

+			/* Re-enable interrupts to allow the interrupt that brought the MCU

+			out of sleep mode to execute immediately.  see comments above

+			__disable_interrupt() call above. */

+			__asm volatile( "cpsie i" ::: "memory" );

+			__asm volatile( "dsb" );

+			__asm volatile( "isb" );

+

+			/* Disable interrupts again because the clock is about to be stopped

+			and interrupts that execute while the clock is stopped will increase

+			any slippage between the time maintained by the RTOS and calendar

+			time. */

+			__asm volatile( "cpsid i" ::: "memory" );

+			__asm volatile( "dsb" );

+			__asm volatile( "isb" );

+

+			/* Disable the SysTick clock without reading the

+			portNVIC_SYSTICK_CTRL_REG register to ensure the

+			portNVIC_SYSTICK_COUNT_FLAG_BIT is not cleared if it is set.  Again,

+			the time the SysTick is stopped for is accounted for as best it can

+			be, but using the tickless mode will inevitably result in some tiny

+			drift of the time maintained by the kernel with respect to calendar

+			time*/

+			portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT );

+

+			/* Determine if the SysTick clock has already counted to zero and

+			been set back to the current reload value (the reload back being

+			correct for the entire expected idle time) or if the SysTick is yet

+			to count to zero (in which case an interrupt other than the SysTick

+			must have brought the system out of sleep mode). */

+			if( ( portNVIC_SYSTICK_CTRL_REG & portNVIC_SYSTICK_COUNT_FLAG_BIT ) != 0 )

 			{

 				uint32_t ulCalculatedLoadValue;

 

-				/* The tick interrupt has already executed, and the SysTick

-				count reloaded with ulReloadValue.  Reset the

+				/* The tick interrupt is already pending, and the SysTick count

+				reloaded with ulReloadValue.  Reset the

 				portNVIC_SYSTICK_LOAD_REG with whatever remains of this tick

 				period. */

 				ulCalculatedLoadValue = ( ulTimerCountsForOneTick - 1UL ) - ( ulReloadValue - portNVIC_SYSTICK_CURRENT_VALUE_REG );

@@ -615,11 +634,9 @@ void xPortSysTickHandler( void )
 

 				portNVIC_SYSTICK_LOAD_REG = ulCalculatedLoadValue;

 

-				/* The tick interrupt handler will already have pended the tick

-				processing in the kernel.  As the pending tick will be

-				processed as soon as this function exits, the tick value

-				maintained by the tick is stepped forward by one less than the

-				time spent waiting. */

+				/* As the pending tick will be processed as soon as this

+				function exits, the tick value maintained by the tick is stepped

+				forward by one less than the time spent waiting. */

 				ulCompleteTickPeriods = xExpectedIdleTime - 1UL;

 			}

 			else

@@ -636,22 +653,19 @@ void xPortSysTickHandler( void )
 

 				/* The reload value is set to whatever fraction of a single tick

 				period remains. */

-				portNVIC_SYSTICK_LOAD_REG = ( ( ulCompleteTickPeriods + 1 ) * ulTimerCountsForOneTick ) - ulCompletedSysTickDecrements;

+				portNVIC_SYSTICK_LOAD_REG = ( ( ulCompleteTickPeriods + 1UL ) * ulTimerCountsForOneTick ) - ulCompletedSysTickDecrements;

 			}

 

 			/* Restart SysTick so it runs from portNVIC_SYSTICK_LOAD_REG

 			again, then set portNVIC_SYSTICK_LOAD_REG back to its standard

-			value.  The critical section is used to ensure the tick interrupt

-			can only execute once in the case that the reload register is near

-			zero. */

+			value. */

 			portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;

-			portENTER_CRITICAL();

-			{

-				portNVIC_SYSTICK_CTRL_REG |= portNVIC_SYSTICK_ENABLE_BIT;

-				vTaskStepTick( ulCompleteTickPeriods );

-				portNVIC_SYSTICK_LOAD_REG = ulTimerCountsForOneTick - 1UL;

-			}

-			portEXIT_CRITICAL();

+			portNVIC_SYSTICK_CTRL_REG |= portNVIC_SYSTICK_ENABLE_BIT;

+			vTaskStepTick( ulCompleteTickPeriods );

+			portNVIC_SYSTICK_LOAD_REG = ulTimerCountsForOneTick - 1UL;

+

+			/* Exit with interrpts enabled. */

+			__asm volatile( "cpsie i" ::: "memory" );

 		}

 	}

 

@@ -665,7 +679,7 @@ void xPortSysTickHandler( void )
 __attribute__(( weak )) void vPortSetupTimerInterrupt( void )

 {

 	/* Calculate the constants required to configure the tick interrupt. */

-	#if configUSE_TICKLESS_IDLE == 1

+	#if( configUSE_TICKLESS_IDLE == 1 )

 	{

 		ulTimerCountsForOneTick = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ );

 		xMaximumPossibleSuppressedTicks = portMAX_24_BIT_NUMBER / ulTimerCountsForOneTick;

@@ -673,6 +687,10 @@ __attribute__(( weak )) void vPortSetupTimerInterrupt( void )
 	}

 	#endif /* configUSE_TICKLESS_IDLE */

 

+	/* Stop and clear the SysTick. */

+	portNVIC_SYSTICK_CTRL_REG = 0UL;

+	portNVIC_SYSTICK_CURRENT_VALUE_REG = 0UL;

+

 	/* Configure SysTick to interrupt at the requested rate. */

 	portNVIC_SYSTICK_LOAD_REG = ( configSYSTICK_CLOCK_HZ / configTICK_RATE_HZ ) - 1UL;

 	portNVIC_SYSTICK_CTRL_REG = ( portNVIC_SYSTICK_CLK_BIT | portNVIC_SYSTICK_INT_BIT | portNVIC_SYSTICK_ENABLE_BIT );

@@ -702,7 +720,7 @@ static void vPortEnableVFP( void )
 	uint8_t ucCurrentPriority;

 

 		/* Obtain the number of the currently executing interrupt. */

-		__asm volatile( "mrs %0, ipsr" : "=r"( ulCurrentInterrupt ) );

+		__asm volatile( "mrs %0, ipsr" : "=r"( ulCurrentInterrupt ) :: "memory" );

 

 		/* Is the interrupt number a user defined interrupt? */

 		if( ulCurrentInterrupt >= portFIRST_USER_INTERRUPT_NUMBER )

@@ -748,7 +766,7 @@ static void vPortEnableVFP( void )
 		devices by calling NVIC_SetPriorityGrouping( 0 ); before starting the

 		scheduler.  Note however that some vendor specific peripheral libraries

 		assume a non-zero priority group setting, in which cases using a value

-		of zero will result in unpredicable behaviour. */

+		of zero will result in unpredictable behaviour. */

 		configASSERT( ( portAIRCR_REG & portPRIORITY_GROUP_MASK ) <= ulMaxPRIGROUPValue );

 	}

 

diff --git a/src/FreeRTOS/Source/portable/GCC/ARM_CM4F/portmacro.h b/src/FreeRTOS/Source/portable/GCC/ARM_CM4F/portmacro.h
index 073e408..85c718c 100644
--- a/src/FreeRTOS/Source/portable/GCC/ARM_CM4F/portmacro.h
+++ b/src/FreeRTOS/Source/portable/GCC/ARM_CM4F/portmacro.h
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 

 #ifndef PORTMACRO_H

@@ -125,7 +83,7 @@ typedef unsigned long UBaseType_t;
 																				\

 	/* Barriers are normally not required but do ensure the code is completely	\

 	within the specified behaviour for the architecture. */						\

-	__asm volatile( "dsb" );													\

+	__asm volatile( "dsb" ::: "memory" );										\

 	__asm volatile( "isb" );													\

 }

 

@@ -173,7 +131,7 @@ not necessary for to use this port.  They are defined so the common demo files
 	{

 	uint8_t ucReturn;

 

-		__asm volatile ( "clz %0, %1" : "=r" ( ucReturn ) : "r" ( ulBitmap ) );

+		__asm volatile ( "clz %0, %1" : "=r" ( ucReturn ) : "r" ( ulBitmap ) : "memory" );

 		return ucReturn;

 	}

 

@@ -188,7 +146,7 @@ not necessary for to use this port.  They are defined so the common demo files
 

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

 

-	#define portGET_HIGHEST_PRIORITY( uxTopPriority, uxReadyPriorities ) uxTopPriority = ( 31 - ucPortCountLeadingZeros( ( uxReadyPriorities ) ) )

+	#define portGET_HIGHEST_PRIORITY( uxTopPriority, uxReadyPriorities ) uxTopPriority = ( 31UL - ( uint32_t ) ucPortCountLeadingZeros( ( uxReadyPriorities ) ) )

 

 #endif /* configUSE_PORT_OPTIMISED_TASK_SELECTION */

 

@@ -202,10 +160,32 @@ not necessary for to use this port.  They are defined so the common demo files
 /* portNOP() is not required by this port. */

 #define portNOP()

 

+#define portINLINE	__inline

+

 #ifndef portFORCE_INLINE

 	#define portFORCE_INLINE inline __attribute__(( always_inline))

 #endif

 

+portFORCE_INLINE static BaseType_t xPortIsInsideInterrupt( void )

+{

+uint32_t ulCurrentInterrupt;

+BaseType_t xReturn;

+

+	/* Obtain the number of the currently executing interrupt. */

+	__asm volatile( "mrs %0, ipsr" : "=r"( ulCurrentInterrupt ) :: "memory" );

+

+	if( ulCurrentInterrupt == 0 )

+	{

+		xReturn = pdFALSE;

+	}

+	else

+	{

+		xReturn = pdTRUE;

+	}

+

+	return xReturn;

+}

+

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

 

 portFORCE_INLINE static void vPortRaiseBASEPRI( void )

@@ -218,7 +198,7 @@ uint32_t ulNewBASEPRI;
 		"	msr basepri, %0											\n" \

 		"	isb														\n" \

 		"	dsb														\n" \

-		:"=r" (ulNewBASEPRI) : "i" ( configMAX_SYSCALL_INTERRUPT_PRIORITY )

+		:"=r" (ulNewBASEPRI) : "i" ( configMAX_SYSCALL_INTERRUPT_PRIORITY ) : "memory"

 	);

 }

 

@@ -235,7 +215,7 @@ uint32_t ulOriginalBASEPRI, ulNewBASEPRI;
 		"	msr basepri, %1											\n" \

 		"	isb														\n" \

 		"	dsb														\n" \

-		:"=r" (ulOriginalBASEPRI), "=r" (ulNewBASEPRI) : "i" ( configMAX_SYSCALL_INTERRUPT_PRIORITY )

+		:"=r" (ulOriginalBASEPRI), "=r" (ulNewBASEPRI) : "i" ( configMAX_SYSCALL_INTERRUPT_PRIORITY ) : "memory"

 	);

 

 	/* This return will not be reached but is necessary to prevent compiler

@@ -248,7 +228,7 @@ portFORCE_INLINE static void vPortSetBASEPRI( uint32_t ulNewMaskValue )
 {

 	__asm volatile

 	(

-		"	msr basepri, %0	" :: "r" ( ulNewMaskValue )

+		"	msr basepri, %0	" :: "r" ( ulNewMaskValue ) : "memory"

 	);

 }

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

diff --git a/src/FreeRTOS/Source/portable/MemMang/heap_1.c b/src/FreeRTOS/Source/portable/MemMang/heap_1.c
index aeca287..3b1a133 100644
--- a/src/FreeRTOS/Source/portable/MemMang/heap_1.c
+++ b/src/FreeRTOS/Source/portable/MemMang/heap_1.c
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 

 /*

@@ -87,11 +45,23 @@ task.h is included from an application file. */
 

 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE

 

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 0 )

+	#error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0

+#endif

+

 /* A few bytes might be lost to byte aligning the heap start address. */

 #define configADJUSTED_HEAP_SIZE	( configTOTAL_HEAP_SIZE - portBYTE_ALIGNMENT )

 

 /* Allocate the memory for the heap. */

-static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];

+#if( configAPPLICATION_ALLOCATED_HEAP == 1 )

+	/* The application writer has already defined the array used for the RTOS

+	heap - probably so it can be placed in a special segment or address. */

+	extern uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];

+#else

+	static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];

+#endif /* configAPPLICATION_ALLOCATED_HEAP */

+

+/* Index into the ucHeap array. */

 static size_t xNextFreeByte = ( size_t ) 0;

 

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

@@ -102,12 +72,14 @@ void *pvReturn = NULL;
 static uint8_t *pucAlignedHeap = NULL;

 

 	/* Ensure that blocks are always aligned to the required number of bytes. */

-	#if portBYTE_ALIGNMENT != 1

+	#if( portBYTE_ALIGNMENT != 1 )

+	{

 		if( xWantedSize & portBYTE_ALIGNMENT_MASK )

 		{

 			/* Byte alignment required. */

 			xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );

 		}

+	}

 	#endif

 

 	vTaskSuspendAll();

diff --git a/src/FreeRTOS/Source/portable/MemMang/heap_2.c.disabled b/src/FreeRTOS/Source/portable/MemMang/heap_2.c.disabled
index 2e7aa19..fc80f24 100644
--- a/src/FreeRTOS/Source/portable/MemMang/heap_2.c.disabled
+++ b/src/FreeRTOS/Source/portable/MemMang/heap_2.c.disabled
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 /*

  * A sample implementation of pvPortMalloc() and vPortFree() that permits

@@ -88,6 +46,10 @@ task.h is included from an application file. */
 

 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE

 

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 0 )

+	#error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0

+#endif

+

 /* A few bytes might be lost to byte aligning the heap start address. */

 #define configADJUSTED_HEAP_SIZE	( configTOTAL_HEAP_SIZE - portBYTE_ALIGNMENT )

 

@@ -97,7 +59,14 @@ task.h is included from an application file. */
 static void prvHeapInit( void );

 

 /* Allocate the memory for the heap. */

-static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];

+#if( configAPPLICATION_ALLOCATED_HEAP == 1 )

+	/* The application writer has already defined the array used for the RTOS

+	heap - probably so it can be placed in a special segment or address. */

+	extern uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];

+#else

+	static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];

+#endif /* configAPPLICATION_ALLOCATED_HEAP */

+

 

 /* Define the linked list structure.  This is used to link free blocks in order

 of their size. */

@@ -127,7 +96,7 @@ static size_t xFreeBytesRemaining = configADJUSTED_HEAP_SIZE;
  */

 #define prvInsertBlockIntoFreeList( pxBlockToInsert )								\

 {																					\

-BlockLink_t *pxIterator;																\

+BlockLink_t *pxIterator;															\

 size_t xBlockSize;																	\

 																					\

 	xBlockSize = pxBlockToInsert->xBlockSize;										\

diff --git a/src/FreeRTOS/Source/portable/MemMang/heap_3.c.disabled b/src/FreeRTOS/Source/portable/MemMang/heap_3.c.disabled
index df3a946..b0aae86 100644
--- a/src/FreeRTOS/Source/portable/MemMang/heap_3.c.disabled
+++ b/src/FreeRTOS/Source/portable/MemMang/heap_3.c.disabled
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 

 /*

@@ -91,6 +49,10 @@ task.h is included from an application file. */
 

 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE

 

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 0 )

+	#error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0

+#endif

+

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

 

 void *pvPortMalloc( size_t xWantedSize )

diff --git a/src/FreeRTOS/Source/portable/MemMang/heap_4.c.disabled b/src/FreeRTOS/Source/portable/MemMang/heap_4.c.disabled
index f139ef0..674aad1 100644
--- a/src/FreeRTOS/Source/portable/MemMang/heap_4.c.disabled
+++ b/src/FreeRTOS/Source/portable/MemMang/heap_4.c.disabled
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 /*

  * A sample implementation of pvPortMalloc() and vPortFree() that combines

@@ -87,6 +45,10 @@ task.h is included from an application file. */
 

 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE

 

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 0 )

+	#error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0

+#endif

+

 /* Block sizes must not get too small. */

 #define heapMINIMUM_BLOCK_SIZE	( ( size_t ) ( xHeapStructSize << 1 ) )

 

@@ -293,7 +255,7 @@ void *pvReturn = NULL;
 	}

 	#endif

 

-	configASSERT( ( ( ( uint32_t ) pvReturn ) & portBYTE_ALIGNMENT_MASK ) == 0 );

+	configASSERT( ( ( ( size_t ) pvReturn ) & ( size_t ) portBYTE_ALIGNMENT_MASK ) == 0 );

 	return pvReturn;

 }

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

diff --git a/src/FreeRTOS/Source/portable/MemMang/heap_5.c.disabled b/src/FreeRTOS/Source/portable/MemMang/heap_5.c.disabled
index 2f7b50a..a5a6545 100644
--- a/src/FreeRTOS/Source/portable/MemMang/heap_5.c.disabled
+++ b/src/FreeRTOS/Source/portable/MemMang/heap_5.c.disabled
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 /*

  * A sample implementation of pvPortMalloc() that allows the heap to be defined

@@ -121,6 +79,10 @@ task.h is included from an application file. */
 

 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE

 

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 0 )

+	#error This file must not be used if configSUPPORT_DYNAMIC_ALLOCATION is 0

+#endif

+

 /* Block sizes must not get too small. */

 #define heapMINIMUM_BLOCK_SIZE	( ( size_t ) ( xHeapStructSize << 1 ) )

 

diff --git a/src/FreeRTOS/Source/queue.c b/src/FreeRTOS/Source/queue.c
index c71ef50..9e0b28b 100644
--- a/src/FreeRTOS/Source/queue.c
+++ b/src/FreeRTOS/Source/queue.c
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 #include <stdlib.h>

 #include <string.h>

@@ -83,32 +41,41 @@ task.h is included from an application file. */
 	#include "croutine.h"

 #endif

 

-/* Lint e961 and e750 are suppressed as a MISRA exception justified because the

-MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined for the

-header files above, but not in this file, in order to generate the correct

-privileged Vs unprivileged linkage and placement. */

-#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750. */

+/* Lint e9021, e961 and e750 are suppressed as a MISRA exception justified

+because the MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined

+for the header files above, but not in this file, in order to generate the

+correct privileged Vs unprivileged linkage and placement. */

+#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750 !e9021. */

 

 

-/* Constants used with the xRxLock and xTxLock structure members. */

-#define queueUNLOCKED					( ( BaseType_t ) -1 )

-#define queueLOCKED_UNMODIFIED			( ( BaseType_t ) 0 )

+/* Constants used with the cRxLock and cTxLock structure members. */

+#define queueUNLOCKED					( ( int8_t ) -1 )

+#define queueLOCKED_UNMODIFIED			( ( int8_t ) 0 )

 

 /* When the Queue_t structure is used to represent a base queue its pcHead and

 pcTail members are used as pointers into the queue storage area.  When the

 Queue_t structure is used to represent a mutex pcHead and pcTail pointers are

 not necessary, and the pcHead pointer is set to NULL to indicate that the

-pcTail pointer actually points to the mutex holder (if any).  Map alternative

-names to the pcHead and pcTail structure members to ensure the readability of

-the code is maintained despite this dual use of two structure members.  An

-alternative implementation would be to use a union, but use of a union is

-against the coding standard (although an exception to the standard has been

-permitted where the dual use also significantly changes the type of the

-structure member). */

-#define pxMutexHolder					pcTail

+structure instead holds a pointer to the mutex holder (if any).  Map alternative

+names to the pcHead and structure member to ensure the readability of the code

+is maintained.  The QueuePointers_t and SemaphoreData_t types are used to form

+a union as their usage is mutually exclusive dependent on what the queue is

+being used for. */

 #define uxQueueType						pcHead

 #define queueQUEUE_IS_MUTEX				NULL

 

+typedef struct QueuePointers

+{

+	int8_t *pcTail;					/*< Points to the byte at the end of the queue storage area.  Once more byte is allocated than necessary to store the queue items, this is used as a marker. */

+	int8_t *pcReadFrom;				/*< Points to the last place that a queued item was read from when the structure is used as a queue. */

+} QueuePointers_t;

+

+typedef struct SemaphoreData

+{

+	TaskHandle_t xMutexHolder;		 /*< The handle of the task that holds the mutex. */

+	UBaseType_t uxRecursiveCallCount;/*< Maintains a count of the number of times a recursive mutex has been recursively 'taken' when the structure is used as a mutex. */

+} SemaphoreData_t;

+

 /* Semaphores do not actually store or copy data, so have an item size of

 zero. */

 #define queueSEMAPHORE_QUEUE_ITEM_LENGTH ( ( UBaseType_t ) 0 )

@@ -125,18 +92,17 @@ zero. */
 /*

  * Definition of the queue used by the scheduler.

  * Items are queued by copy, not reference.  See the following link for the

- * rationale: http://www.freertos.org/Embedded-RTOS-Queues.html

+ * rationale: https://www.freertos.org/Embedded-RTOS-Queues.html

  */

-typedef struct QueueDefinition

+typedef struct QueueDefinition 		/* The old naming convention is used to prevent breaking kernel aware debuggers. */

 {

 	int8_t *pcHead;					/*< Points to the beginning of the queue storage area. */

-	int8_t *pcTail;					/*< Points to the byte at the end of the queue storage area.  Once more byte is allocated than necessary to store the queue items, this is used as a marker. */

 	int8_t *pcWriteTo;				/*< Points to the free next place in the storage area. */

 

-	union							/* Use of a union is an exception to the coding standard to ensure two mutually exclusive structure members don't appear simultaneously (wasting RAM). */

+	union

 	{

-		int8_t *pcReadFrom;			/*< Points to the last place that a queued item was read from when the structure is used as a queue. */

-		UBaseType_t uxRecursiveCallCount;/*< Maintains a count of the number of times a recursive mutex has been recursively 'taken' when the structure is used as a mutex. */

+		QueuePointers_t xQueue;		/*< Data required exclusively when this structure is used as a queue. */

+		SemaphoreData_t xSemaphore; /*< Data required exclusively when this structure is used as a semaphore. */

 	} u;

 

 	List_t xTasksWaitingToSend;		/*< List of tasks that are blocked waiting to post onto this queue.  Stored in priority order. */

@@ -146,18 +112,22 @@ typedef struct QueueDefinition
 	UBaseType_t uxLength;			/*< The length of the queue defined as the number of items it will hold, not the number of bytes. */

 	UBaseType_t uxItemSize;			/*< The size of each items that the queue will hold. */

 

-	volatile BaseType_t xRxLock;	/*< Stores the number of items received from the queue (removed from the queue) while the queue was locked.  Set to queueUNLOCKED when the queue is not locked. */

-	volatile BaseType_t xTxLock;	/*< Stores the number of items transmitted to the queue (added to the queue) while the queue was locked.  Set to queueUNLOCKED when the queue is not locked. */

+	volatile int8_t cRxLock;		/*< Stores the number of items received from the queue (removed from the queue) while the queue was locked.  Set to queueUNLOCKED when the queue is not locked. */

+	volatile int8_t cTxLock;		/*< Stores the number of items transmitted to the queue (added to the queue) while the queue was locked.  Set to queueUNLOCKED when the queue is not locked. */

 

-	#if ( configUSE_TRACE_FACILITY == 1 )

-		UBaseType_t uxQueueNumber;

-		uint8_t ucQueueType;

+	#if( ( configSUPPORT_STATIC_ALLOCATION == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )

+		uint8_t ucStaticallyAllocated;	/*< Set to pdTRUE if the memory used by the queue was statically allocated to ensure no attempt is made to free the memory. */

 	#endif

 

 	#if ( configUSE_QUEUE_SETS == 1 )

 		struct QueueDefinition *pxQueueSetContainer;

 	#endif

 

+	#if ( configUSE_TRACE_FACILITY == 1 )

+		UBaseType_t uxQueueNumber;

+		uint8_t ucQueueType;

+	#endif

+

 } xQUEUE;

 

 /* The old xQUEUE name is maintained above then typedefed to the new Queue_t

@@ -236,6 +206,31 @@ static void prvCopyDataFromQueue( Queue_t * const pxQueue, void * const pvBuffer
 	static BaseType_t prvNotifyQueueSetContainer( const Queue_t * const pxQueue, const BaseType_t xCopyPosition ) PRIVILEGED_FUNCTION;

 #endif

 

+/*

+ * Called after a Queue_t structure has been allocated either statically or

+ * dynamically to fill in the structure's members.

+ */

+static void prvInitialiseNewQueue( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, const uint8_t ucQueueType, Queue_t *pxNewQueue ) PRIVILEGED_FUNCTION;

+

+/*

+ * Mutexes are a special type of queue.  When a mutex is created, first the

+ * queue is created, then prvInitialiseMutex() is called to configure the queue

+ * as a mutex.

+ */

+#if( configUSE_MUTEXES == 1 )

+	static void prvInitialiseMutex( Queue_t *pxNewQueue ) PRIVILEGED_FUNCTION;

+#endif

+

+#if( configUSE_MUTEXES == 1 )

+	/*

+	 * If a task waiting for a mutex causes the mutex holder to inherit a

+	 * priority, but the waiting task times out, then the holder should

+	 * disinherit the priority - but only down to the highest priority of any

+	 * other tasks that are waiting for the same mutex.  This function returns

+	 * that priority.

+	 */

+	static UBaseType_t prvGetDisinheritPriorityAfterTimeout( const Queue_t * const pxQueue ) PRIVILEGED_FUNCTION;

+#endif

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

 

 /*

@@ -245,13 +240,13 @@ static void prvCopyDataFromQueue( Queue_t * const pxQueue, void * const pvBuffer
 #define prvLockQueue( pxQueue )								\

 	taskENTER_CRITICAL();									\

 	{														\

-		if( ( pxQueue )->xRxLock == queueUNLOCKED )			\

+		if( ( pxQueue )->cRxLock == queueUNLOCKED )			\

 		{													\

-			( pxQueue )->xRxLock = queueLOCKED_UNMODIFIED;	\

+			( pxQueue )->cRxLock = queueLOCKED_UNMODIFIED;	\

 		}													\

-		if( ( pxQueue )->xTxLock == queueUNLOCKED )			\

+		if( ( pxQueue )->cTxLock == queueUNLOCKED )			\

 		{													\

-			( pxQueue )->xTxLock = queueLOCKED_UNMODIFIED;	\

+			( pxQueue )->cTxLock = queueLOCKED_UNMODIFIED;	\

 		}													\

 	}														\

 	taskEXIT_CRITICAL()

@@ -259,18 +254,18 @@ static void prvCopyDataFromQueue( Queue_t * const pxQueue, void * const pvBuffer
 

 BaseType_t xQueueGenericReset( QueueHandle_t xQueue, BaseType_t xNewQueue )

 {

-Queue_t * const pxQueue = ( Queue_t * ) xQueue;

+Queue_t * const pxQueue = xQueue;

 

 	configASSERT( pxQueue );

 

 	taskENTER_CRITICAL();

 	{

-		pxQueue->pcTail = pxQueue->pcHead + ( pxQueue->uxLength * pxQueue->uxItemSize );

+		pxQueue->u.xQueue.pcTail = pxQueue->pcHead + ( pxQueue->uxLength * pxQueue->uxItemSize ); /*lint !e9016 Pointer arithmetic allowed on char types, especially when it assists conveying intent. */

 		pxQueue->uxMessagesWaiting = ( UBaseType_t ) 0U;

 		pxQueue->pcWriteTo = pxQueue->pcHead;

-		pxQueue->u.pcReadFrom = pxQueue->pcHead + ( ( pxQueue->uxLength - ( UBaseType_t ) 1U ) * pxQueue->uxItemSize );

-		pxQueue->xRxLock = queueUNLOCKED;

-		pxQueue->xTxLock = queueUNLOCKED;

+		pxQueue->u.xQueue.pcReadFrom = pxQueue->pcHead + ( ( pxQueue->uxLength - 1U ) * pxQueue->uxItemSize ); /*lint !e9016 Pointer arithmetic allowed on char types, especially when it assists conveying intent. */

+		pxQueue->cRxLock = queueUNLOCKED;

+		pxQueue->cTxLock = queueUNLOCKED;

 

 		if( xNewQueue == pdFALSE )

 		{

@@ -281,7 +276,7 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 			it will be possible to write to it. */

 			if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )

 			{

-				if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) == pdTRUE )

+				if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )

 				{

 					queueYIELD_IF_USING_PREEMPTION();

 				}

@@ -310,129 +305,184 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 }

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

 

-QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, const uint8_t ucQueueType )

-{

-Queue_t *pxNewQueue;

-size_t xQueueSizeInBytes;

-QueueHandle_t xReturn = NULL;

+#if( configSUPPORT_STATIC_ALLOCATION == 1 )

 

-	/* Remove compiler warnings about unused parameters should

-	configUSE_TRACE_FACILITY not be set to 1. */

-	( void ) ucQueueType;

+	QueueHandle_t xQueueGenericCreateStatic( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, StaticQueue_t *pxStaticQueue, const uint8_t ucQueueType )

+	{

+	Queue_t *pxNewQueue;

 

-	configASSERT( uxQueueLength > ( UBaseType_t ) 0 );

+		configASSERT( uxQueueLength > ( UBaseType_t ) 0 );

 

-	if( uxItemSize == ( UBaseType_t ) 0 )

-	{

-		/* There is not going to be a queue storage area. */

-		xQueueSizeInBytes = ( size_t ) 0;

-	}

-	else

-	{

-		/* The queue is one byte longer than asked for to make wrap checking

-		easier/faster. */

-		xQueueSizeInBytes = ( size_t ) ( uxQueueLength * uxItemSize ) + ( size_t ) 1; /*lint !e961 MISRA exception as the casts are only redundant for some ports. */

+		/* The StaticQueue_t structure and the queue storage area must be

+		supplied. */

+		configASSERT( pxStaticQueue != NULL );

+

+		/* A queue storage area should be provided if the item size is not 0, and

+		should not be provided if the item size is 0. */

+		configASSERT( !( ( pucQueueStorage != NULL ) && ( uxItemSize == 0 ) ) );

+		configASSERT( !( ( pucQueueStorage == NULL ) && ( uxItemSize != 0 ) ) );

+

+		#if( configASSERT_DEFINED == 1 )

+		{

+			/* Sanity check that the size of the structure used to declare a

+			variable of type StaticQueue_t or StaticSemaphore_t equals the size of

+			the real queue and semaphore structures. */

+			volatile size_t xSize = sizeof( StaticQueue_t );

+			configASSERT( xSize == sizeof( Queue_t ) );

+			( void ) xSize; /* Keeps lint quiet when configASSERT() is not defined. */

+		}

+		#endif /* configASSERT_DEFINED */

+

+		/* The address of a statically allocated queue was passed in, use it.

+		The address of a statically allocated storage area was also passed in

+		but is already set. */

+		pxNewQueue = ( Queue_t * ) pxStaticQueue; /*lint !e740 !e9087 Unusual cast is ok as the structures are designed to have the same alignment, and the size is checked by an assert. */

+

+		if( pxNewQueue != NULL )

+		{

+			#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

+			{

+				/* Queues can be allocated wither statically or dynamically, so

+				note this queue was allocated statically in case the queue is

+				later deleted. */

+				pxNewQueue->ucStaticallyAllocated = pdTRUE;

+			}

+			#endif /* configSUPPORT_DYNAMIC_ALLOCATION */

+

+			prvInitialiseNewQueue( uxQueueLength, uxItemSize, pucQueueStorage, ucQueueType, pxNewQueue );

+		}

+		else

+		{

+			traceQUEUE_CREATE_FAILED( ucQueueType );

+			mtCOVERAGE_TEST_MARKER();

+		}

+

+		return pxNewQueue;

 	}

 

-	/* Allocate the new queue structure and storage area. */

-	pxNewQueue = ( Queue_t * ) pvPortMalloc( sizeof( Queue_t ) + xQueueSizeInBytes );

+#endif /* configSUPPORT_STATIC_ALLOCATION */

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

+

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

 

-	if( pxNewQueue != NULL )

+	QueueHandle_t xQueueGenericCreate( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, const uint8_t ucQueueType )

 	{

+	Queue_t *pxNewQueue;

+	size_t xQueueSizeInBytes;

+	uint8_t *pucQueueStorage;

+

+		configASSERT( uxQueueLength > ( UBaseType_t ) 0 );

+

 		if( uxItemSize == ( UBaseType_t ) 0 )

 		{

-			/* No RAM was allocated for the queue storage area, but PC head

-			cannot be set to NULL because NULL is used as a key to say the queue

-			is used as a mutex.  Therefore just set pcHead to point to the queue

-			as a benign value that is known to be within the memory map. */

-			pxNewQueue->pcHead = ( int8_t * ) pxNewQueue;

+			/* There is not going to be a queue storage area. */

+			xQueueSizeInBytes = ( size_t ) 0;

 		}

 		else

 		{

-			/* Jump past the queue structure to find the location of the queue

-			storage area. */

-			pxNewQueue->pcHead = ( ( int8_t * ) pxNewQueue ) + sizeof( Queue_t );

+			/* Allocate enough space to hold the maximum number of items that

+			can be in the queue at any time. */

+			xQueueSizeInBytes = ( size_t ) ( uxQueueLength * uxItemSize ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */

 		}

 

-		/* Initialise the queue members as described above where the queue type

-		is defined. */

-		pxNewQueue->uxLength = uxQueueLength;

-		pxNewQueue->uxItemSize = uxItemSize;

-		( void ) xQueueGenericReset( pxNewQueue, pdTRUE );

+		/* Allocate the queue and storage area.  Justification for MISRA

+		deviation as follows:  pvPortMalloc() always ensures returned memory

+		blocks are aligned per the requirements of the MCU stack.  In this case

+		pvPortMalloc() must return a pointer that is guaranteed to meet the

+		alignment requirements of the Queue_t structure - which in this case

+		is an int8_t *.  Therefore, whenever the stack alignment requirements

+		are greater than or equal to the pointer to char requirements the cast

+		is safe.  In other cases alignment requirements are not strict (one or

+		two bytes). */

+		pxNewQueue = ( Queue_t * ) pvPortMalloc( sizeof( Queue_t ) + xQueueSizeInBytes ); /*lint !e9087 !e9079 see comment above. */

 

-		#if ( configUSE_TRACE_FACILITY == 1 )

+		if( pxNewQueue != NULL )

 		{

-			pxNewQueue->ucQueueType = ucQueueType;

-		}

-		#endif /* configUSE_TRACE_FACILITY */

+			/* Jump past the queue structure to find the location of the queue

+			storage area. */

+			pucQueueStorage = ( uint8_t * ) pxNewQueue;

+			pucQueueStorage += sizeof( Queue_t ); /*lint !e9016 Pointer arithmetic allowed on char types, especially when it assists conveying intent. */

+

+			#if( configSUPPORT_STATIC_ALLOCATION == 1 )

+			{

+				/* Queues can be created either statically or dynamically, so

+				note this task was created dynamically in case it is later

+				deleted. */

+				pxNewQueue->ucStaticallyAllocated = pdFALSE;

+			}

+			#endif /* configSUPPORT_STATIC_ALLOCATION */

 

-		#if( configUSE_QUEUE_SETS == 1 )

+			prvInitialiseNewQueue( uxQueueLength, uxItemSize, pucQueueStorage, ucQueueType, pxNewQueue );

+		}

+		else

 		{

-			pxNewQueue->pxQueueSetContainer = NULL;

+			traceQUEUE_CREATE_FAILED( ucQueueType );

+			mtCOVERAGE_TEST_MARKER();

 		}

-		#endif /* configUSE_QUEUE_SETS */

 

-		traceQUEUE_CREATE( pxNewQueue );

-		xReturn = pxNewQueue;

+		return pxNewQueue;

+	}

+

+#endif /* configSUPPORT_STATIC_ALLOCATION */

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

+

+static void prvInitialiseNewQueue( const UBaseType_t uxQueueLength, const UBaseType_t uxItemSize, uint8_t *pucQueueStorage, const uint8_t ucQueueType, Queue_t *pxNewQueue )

+{

+	/* Remove compiler warnings about unused parameters should

+	configUSE_TRACE_FACILITY not be set to 1. */

+	( void ) ucQueueType;

+

+	if( uxItemSize == ( UBaseType_t ) 0 )

+	{

+		/* No RAM was allocated for the queue storage area, but PC head cannot

+		be set to NULL because NULL is used as a key to say the queue is used as

+		a mutex.  Therefore just set pcHead to point to the queue as a benign

+		value that is known to be within the memory map. */

+		pxNewQueue->pcHead = ( int8_t * ) pxNewQueue;

 	}

 	else

 	{

-		mtCOVERAGE_TEST_MARKER();

+		/* Set the head to the start of the queue storage area. */

+		pxNewQueue->pcHead = ( int8_t * ) pucQueueStorage;

 	}

 

-	configASSERT( xReturn );

+	/* Initialise the queue members as described where the queue type is

+	defined. */

+	pxNewQueue->uxLength = uxQueueLength;

+	pxNewQueue->uxItemSize = uxItemSize;

+	( void ) xQueueGenericReset( pxNewQueue, pdTRUE );

 

-	return xReturn;

+	#if ( configUSE_TRACE_FACILITY == 1 )

+	{

+		pxNewQueue->ucQueueType = ucQueueType;

+	}

+	#endif /* configUSE_TRACE_FACILITY */

+

+	#if( configUSE_QUEUE_SETS == 1 )

+	{

+		pxNewQueue->pxQueueSetContainer = NULL;

+	}

+	#endif /* configUSE_QUEUE_SETS */

+

+	traceQUEUE_CREATE( pxNewQueue );

 }

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

 

-#if ( configUSE_MUTEXES == 1 )

+#if( configUSE_MUTEXES == 1 )

 

-	QueueHandle_t xQueueCreateMutex( const uint8_t ucQueueType )

+	static void prvInitialiseMutex( Queue_t *pxNewQueue )

 	{

-	Queue_t *pxNewQueue;

-

-		/* Prevent compiler warnings about unused parameters if

-		configUSE_TRACE_FACILITY does not equal 1. */

-		( void ) ucQueueType;

-

-		/* Allocate the new queue structure. */

-		pxNewQueue = ( Queue_t * ) pvPortMalloc( sizeof( Queue_t ) );

 		if( pxNewQueue != NULL )

 		{

-			/* Information required for priority inheritance. */

-			pxNewQueue->pxMutexHolder = NULL;

+			/* The queue create function will set all the queue structure members

+			correctly for a generic queue, but this function is creating a

+			mutex.  Overwrite those members that need to be set differently -

+			in particular the information required for priority inheritance. */

+			pxNewQueue->u.xSemaphore.xMutexHolder = NULL;

 			pxNewQueue->uxQueueType = queueQUEUE_IS_MUTEX;

 

-			/* Queues used as a mutex no data is actually copied into or out

-			of the queue. */

-			pxNewQueue->pcWriteTo = NULL;

-			pxNewQueue->u.pcReadFrom = NULL;

-

-			/* Each mutex has a length of 1 (like a binary semaphore) and

-			an item size of 0 as nothing is actually copied into or out

-			of the mutex. */

-			pxNewQueue->uxMessagesWaiting = ( UBaseType_t ) 0U;

-			pxNewQueue->uxLength = ( UBaseType_t ) 1U;

-			pxNewQueue->uxItemSize = ( UBaseType_t ) 0U;

-			pxNewQueue->xRxLock = queueUNLOCKED;

-			pxNewQueue->xTxLock = queueUNLOCKED;

-

-			#if ( configUSE_TRACE_FACILITY == 1 )

-			{

-				pxNewQueue->ucQueueType = ucQueueType;

-			}

-			#endif

-

-			#if ( configUSE_QUEUE_SETS == 1 )

-			{

-				pxNewQueue->pxQueueSetContainer = NULL;

-			}

-			#endif

-

-			/* Ensure the event queues start with the correct state. */

-			vListInitialise( &( pxNewQueue->xTasksWaitingToSend ) );

-			vListInitialise( &( pxNewQueue->xTasksWaitingToReceive ) );

+			/* In case this is a recursive mutex. */

+			pxNewQueue->u.xSemaphore.uxRecursiveCallCount = 0;

 

 			traceCREATE_MUTEX( pxNewQueue );

 

@@ -443,8 +493,42 @@ QueueHandle_t xReturn = NULL;
 		{

 			traceCREATE_MUTEX_FAILED();

 		}

+	}

 

-		return pxNewQueue;

+#endif /* configUSE_MUTEXES */

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

+

+#if( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )

+

+	QueueHandle_t xQueueCreateMutex( const uint8_t ucQueueType )

+	{

+	QueueHandle_t xNewQueue;

+	const UBaseType_t uxMutexLength = ( UBaseType_t ) 1, uxMutexSize = ( UBaseType_t ) 0;

+

+		xNewQueue = xQueueGenericCreate( uxMutexLength, uxMutexSize, ucQueueType );

+		prvInitialiseMutex( ( Queue_t * ) xNewQueue );

+

+		return xNewQueue;

+	}

+

+#endif /* configUSE_MUTEXES */

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

+

+#if( ( configUSE_MUTEXES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )

+

+	QueueHandle_t xQueueCreateMutexStatic( const uint8_t ucQueueType, StaticQueue_t *pxStaticQueue )

+	{

+	QueueHandle_t xNewQueue;

+	const UBaseType_t uxMutexLength = ( UBaseType_t ) 1, uxMutexSize = ( UBaseType_t ) 0;

+

+		/* Prevent compiler warnings about unused parameters if

+		configUSE_TRACE_FACILITY does not equal 1. */

+		( void ) ucQueueType;

+

+		xNewQueue = xQueueGenericCreateStatic( uxMutexLength, uxMutexSize, NULL, pxStaticQueue, ucQueueType );

+		prvInitialiseMutex( ( Queue_t * ) xNewQueue );

+

+		return xNewQueue;

 	}

 

 #endif /* configUSE_MUTEXES */

@@ -452,9 +536,10 @@ QueueHandle_t xReturn = NULL;
 

 #if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )

 

-	void* xQueueGetMutexHolder( QueueHandle_t xSemaphore )

+	TaskHandle_t xQueueGetMutexHolder( QueueHandle_t xSemaphore )

 	{

-	void *pxReturn;

+	TaskHandle_t pxReturn;

+	Queue_t * const pxSemaphore = ( Queue_t * ) xSemaphore;

 

 		/* This function is called by xSemaphoreGetMutexHolder(), and should not

 		be called directly.  Note:  This is a good way of determining if the

@@ -463,9 +548,9 @@ QueueHandle_t xReturn = NULL;
 		following critical section exiting and the function returning. */

 		taskENTER_CRITICAL();

 		{

-			if( ( ( Queue_t * ) xSemaphore )->uxQueueType == queueQUEUE_IS_MUTEX )

+			if( pxSemaphore->uxQueueType == queueQUEUE_IS_MUTEX )

 			{

-				pxReturn = ( void * ) ( ( Queue_t * ) xSemaphore )->pxMutexHolder;

+				pxReturn = pxSemaphore->u.xSemaphore.xMutexHolder;

 			}

 			else

 			{

@@ -480,6 +565,32 @@ QueueHandle_t xReturn = NULL;
 #endif

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

 

+#if ( ( configUSE_MUTEXES == 1 ) && ( INCLUDE_xSemaphoreGetMutexHolder == 1 ) )

+

+	TaskHandle_t xQueueGetMutexHolderFromISR( QueueHandle_t xSemaphore )

+	{

+	TaskHandle_t pxReturn;

+

+		configASSERT( xSemaphore );

+

+		/* Mutexes cannot be used in interrupt service routines, so the mutex

+		holder should not change in an ISR, and therefore a critical section is

+		not required here. */

+		if( ( ( Queue_t * ) xSemaphore )->uxQueueType == queueQUEUE_IS_MUTEX )

+		{

+			pxReturn = ( ( Queue_t * ) xSemaphore )->u.xSemaphore.xMutexHolder;

+		}

+		else

+		{

+			pxReturn = NULL;

+		}

+

+		return pxReturn;

+	} /*lint !e818 xSemaphore cannot be a pointer to const because it is a typedef. */

+

+#endif

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

+

 #if ( configUSE_RECURSIVE_MUTEXES == 1 )

 

 	BaseType_t xQueueGiveMutexRecursive( QueueHandle_t xMutex )

@@ -489,25 +600,25 @@ QueueHandle_t xReturn = NULL;
 

 		configASSERT( pxMutex );

 

-		/* If this is the task that holds the mutex then pxMutexHolder will not

+		/* If this is the task that holds the mutex then xMutexHolder will not

 		change outside of this task.  If this task does not hold the mutex then

 		pxMutexHolder can never coincidentally equal the tasks handle, and as

 		this is the only condition we are interested in it does not matter if

 		pxMutexHolder is accessed simultaneously by another task.  Therefore no

 		mutual exclusion is required to test the pxMutexHolder variable. */

-		if( pxMutex->pxMutexHolder == ( void * ) xTaskGetCurrentTaskHandle() ) /*lint !e961 Not a redundant cast as TaskHandle_t is a typedef. */

+		if( pxMutex->u.xSemaphore.xMutexHolder == xTaskGetCurrentTaskHandle() )

 		{

 			traceGIVE_MUTEX_RECURSIVE( pxMutex );

 

-			/* uxRecursiveCallCount cannot be zero if pxMutexHolder is equal to

+			/* uxRecursiveCallCount cannot be zero if xMutexHolder is equal to

 			the task handle, therefore no underflow check is required.  Also,

 			uxRecursiveCallCount is only modified by the mutex holder, and as

 			there can only be one, no mutual exclusion is required to modify the

 			uxRecursiveCallCount member. */

-			( pxMutex->u.uxRecursiveCallCount )--;

+			( pxMutex->u.xSemaphore.uxRecursiveCallCount )--;

 

-			/* Have we unwound the call count? */

-			if( pxMutex->u.uxRecursiveCallCount == ( UBaseType_t ) 0 )

+			/* Has the recursive call count unwound to 0? */

+			if( pxMutex->u.xSemaphore.uxRecursiveCallCount == ( UBaseType_t ) 0 )

 			{

 				/* Return the mutex.  This will automatically unblock any other

 				task that might be waiting to access the mutex. */

@@ -549,21 +660,21 @@ QueueHandle_t xReturn = NULL;
 

 		traceTAKE_MUTEX_RECURSIVE( pxMutex );

 

-		if( pxMutex->pxMutexHolder == ( void * ) xTaskGetCurrentTaskHandle() ) /*lint !e961 Cast is not redundant as TaskHandle_t is a typedef. */

+		if( pxMutex->u.xSemaphore.xMutexHolder == xTaskGetCurrentTaskHandle() )

 		{

-			( pxMutex->u.uxRecursiveCallCount )++;

+			( pxMutex->u.xSemaphore.uxRecursiveCallCount )++;

 			xReturn = pdPASS;

 		}

 		else

 		{

-			xReturn = xQueueGenericReceive( pxMutex, NULL, xTicksToWait, pdFALSE );

+			xReturn = xQueueSemaphoreTake( pxMutex, xTicksToWait );

 

 			/* pdPASS will only be returned if the mutex was successfully

 			obtained.  The calling task may have entered the Blocked state

 			before reaching here. */

-			if( xReturn == pdPASS )

+			if( xReturn != pdFAIL )

 			{

-				( pxMutex->u.uxRecursiveCallCount )++;

+				( pxMutex->u.xSemaphore.uxRecursiveCallCount )++;

 			}

 			else

 			{

@@ -577,7 +688,35 @@ QueueHandle_t xReturn = NULL;
 #endif /* configUSE_RECURSIVE_MUTEXES */

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

 

-#if ( configUSE_COUNTING_SEMAPHORES == 1 )

+#if( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )

+

+	QueueHandle_t xQueueCreateCountingSemaphoreStatic( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount, StaticQueue_t *pxStaticQueue )

+	{

+	QueueHandle_t xHandle;

+

+		configASSERT( uxMaxCount != 0 );

+		configASSERT( uxInitialCount <= uxMaxCount );

+

+		xHandle = xQueueGenericCreateStatic( uxMaxCount, queueSEMAPHORE_QUEUE_ITEM_LENGTH, NULL, pxStaticQueue, queueQUEUE_TYPE_COUNTING_SEMAPHORE );

+

+		if( xHandle != NULL )

+		{

+			( ( Queue_t * ) xHandle )->uxMessagesWaiting = uxInitialCount;

+

+			traceCREATE_COUNTING_SEMAPHORE();

+		}

+		else

+		{

+			traceCREATE_COUNTING_SEMAPHORE_FAILED();

+		}

+

+		return xHandle;

+	}

+

+#endif /* ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */

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

+

+#if( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )

 

 	QueueHandle_t xQueueCreateCountingSemaphore( const UBaseType_t uxMaxCount, const UBaseType_t uxInitialCount )

 	{

@@ -599,18 +738,17 @@ QueueHandle_t xReturn = NULL;
 			traceCREATE_COUNTING_SEMAPHORE_FAILED();

 		}

 

-		configASSERT( xHandle );

 		return xHandle;

 	}

 

-#endif /* configUSE_COUNTING_SEMAPHORES */

+#endif /* ( ( configUSE_COUNTING_SEMAPHORES == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */

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

 

 BaseType_t xQueueGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, const BaseType_t xCopyPosition )

 {

 BaseType_t xEntryTimeSet = pdFALSE, xYieldRequired;

 TimeOut_t xTimeOut;

-Queue_t * const pxQueue = ( Queue_t * ) xQueue;

+Queue_t * const pxQueue = xQueue;

 

 	configASSERT( pxQueue );

 	configASSERT( !( ( pvItemToQueue == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );

@@ -622,9 +760,9 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 	#endif

 

 

-	/* This function relaxes the coding standard somewhat to allow return

-	statements within the function itself.  This is done in the interest

-	of execution time efficiency. */

+	/*lint -save -e904 This function relaxes the coding standard somewhat to

+	allow return statements within the function itself.  This is done in the

+	interest of execution time efficiency. */

 	for( ;; )

 	{

 		taskENTER_CRITICAL();

@@ -636,13 +774,23 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 			if( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) )

 			{

 				traceQUEUE_SEND( pxQueue );

-				xYieldRequired = prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );

 

 				#if ( configUSE_QUEUE_SETS == 1 )

 				{

+				UBaseType_t uxPreviousMessagesWaiting = pxQueue->uxMessagesWaiting;

+

+					xYieldRequired = prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );

+

 					if( pxQueue->pxQueueSetContainer != NULL )

 					{

-						if( prvNotifyQueueSetContainer( pxQueue, xCopyPosition ) == pdTRUE )

+						if( ( xCopyPosition == queueOVERWRITE ) && ( uxPreviousMessagesWaiting != ( UBaseType_t ) 0 ) )

+						{

+							/* Do not notify the queue set as an existing item

+							was overwritten in the queue so the number of items

+							in the queue has not changed. */

+							mtCOVERAGE_TEST_MARKER();

+						}

+						else if( prvNotifyQueueSetContainer( pxQueue, xCopyPosition ) != pdFALSE )

 						{

 							/* The queue is a member of a queue set, and posting

 							to the queue set caused a higher priority task to

@@ -660,7 +808,7 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 						queue then unblock it now. */

 						if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )

 						{

-							if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) == pdTRUE )

+							if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )

 							{

 								/* The unblocked task has a priority higher than

 								our own so yield immediately.  Yes it is ok to

@@ -689,11 +837,13 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 				}

 				#else /* configUSE_QUEUE_SETS */

 				{

+					xYieldRequired = prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );

+

 					/* If there was a task waiting for data to arrive on the

 					queue then unblock it now. */

 					if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )

 					{

-						if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) == pdTRUE )

+						if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )

 						{

 							/* The unblocked task has a priority higher than

 							our own so yield immediately.  Yes it is ok to do

@@ -741,7 +891,7 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 				{

 					/* The queue was full and a block time was specified so

 					configure the timeout structure. */

-					vTaskSetTimeOutState( &xTimeOut );

+					vTaskInternalSetTimeOutState( &xTimeOut );

 					xEntryTimeSet = pdTRUE;

 				}

 				else

@@ -768,8 +918,8 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 				vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToSend ), xTicksToWait );

 

 				/* Unlocking the queue means queue events can effect the

-				event list.  It is possible	that interrupts occurring now

-				remove this task from the event	list again - but as the

+				event list.  It is possible that interrupts occurring now

+				remove this task from the event list again - but as the

 				scheduler is suspended the task will go onto the pending

 				ready last instead of the actual ready list. */

 				prvUnlockQueue( pxQueue );

@@ -797,265 +947,18 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 			prvUnlockQueue( pxQueue );

 			( void ) xTaskResumeAll();

 

-			/* Return to the original privilege level before exiting the

-			function. */

 			traceQUEUE_SEND_FAILED( pxQueue );

 			return errQUEUE_FULL;

 		}

-	}

+	} /*lint -restore */

 }

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

 

-#if ( configUSE_ALTERNATIVE_API == 1 )

-

-	BaseType_t xQueueAltGenericSend( QueueHandle_t xQueue, const void * const pvItemToQueue, TickType_t xTicksToWait, BaseType_t xCopyPosition )

-	{

-	BaseType_t xEntryTimeSet = pdFALSE;

-	TimeOut_t xTimeOut;

-	Queue_t * const pxQueue = ( Queue_t * ) xQueue;

-

-		configASSERT( pxQueue );

-		configASSERT( !( ( pvItemToQueue == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );

-

-		for( ;; )

-		{

-			taskENTER_CRITICAL();

-			{

-				/* Is there room on the queue now?  To be running we must be

-				the highest priority task wanting to access the queue. */

-				if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )

-				{

-					traceQUEUE_SEND( pxQueue );

-					prvCopyDataToQueue( pxQueue, pvItemToQueue, xCopyPosition );

-

-					/* If there was a task waiting for data to arrive on the

-					queue then unblock it now. */

-					if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )

-					{

-						if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) == pdTRUE )

-						{

-							/* The unblocked task has a priority higher than

-							our own so yield immediately. */

-							portYIELD_WITHIN_API();

-						}

-						else

-						{

-							mtCOVERAGE_TEST_MARKER();

-						}

-					}

-					else

-					{

-						mtCOVERAGE_TEST_MARKER();

-					}

-

-					taskEXIT_CRITICAL();

-					return pdPASS;

-				}

-				else

-				{

-					if( xTicksToWait == ( TickType_t ) 0 )

-					{

-						taskEXIT_CRITICAL();

-						return errQUEUE_FULL;

-					}

-					else if( xEntryTimeSet == pdFALSE )

-					{

-						vTaskSetTimeOutState( &xTimeOut );

-						xEntryTimeSet = pdTRUE;

-					}

-				}

-			}

-			taskEXIT_CRITICAL();

-

-			taskENTER_CRITICAL();

-			{

-				if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )

-				{

-					if( prvIsQueueFull( pxQueue ) != pdFALSE )

-					{

-						traceBLOCKING_ON_QUEUE_SEND( pxQueue );

-						vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToSend ), xTicksToWait );

-						portYIELD_WITHIN_API();

-					}

-					else

-					{

-						mtCOVERAGE_TEST_MARKER();

-					}

-				}

-				else

-				{

-					taskEXIT_CRITICAL();

-					traceQUEUE_SEND_FAILED( pxQueue );

-					return errQUEUE_FULL;

-				}

-			}

-			taskEXIT_CRITICAL();

-		}

-	}

-

-#endif /* configUSE_ALTERNATIVE_API */

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

-

-#if ( configUSE_ALTERNATIVE_API == 1 )

-

-	BaseType_t xQueueAltGenericReceive( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait, BaseType_t xJustPeeking )

-	{

-	BaseType_t xEntryTimeSet = pdFALSE;

-	TimeOut_t xTimeOut;

-	int8_t *pcOriginalReadPosition;

-	Queue_t * const pxQueue = ( Queue_t * ) xQueue;

-

-		configASSERT( pxQueue );

-		configASSERT( !( ( pvBuffer == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );

-

-		for( ;; )

-		{

-			taskENTER_CRITICAL();

-			{

-				if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )

-				{

-					/* Remember our read position in case we are just peeking. */

-					pcOriginalReadPosition = pxQueue->u.pcReadFrom;

-

-					prvCopyDataFromQueue( pxQueue, pvBuffer );

-

-					if( xJustPeeking == pdFALSE )

-					{

-						traceQUEUE_RECEIVE( pxQueue );

-

-						/* Data is actually being removed (not just peeked). */

-						--( pxQueue->uxMessagesWaiting );

-

-						#if ( configUSE_MUTEXES == 1 )

-						{

-							if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )

-							{

-								/* Record the information required to implement

-								priority inheritance should it become necessary. */

-								pxQueue->pxMutexHolder = ( int8_t * ) xTaskGetCurrentTaskHandle();

-							}

-							else

-							{

-								mtCOVERAGE_TEST_MARKER();

-							}

-						}

-						#endif

-

-						if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )

-						{

-							if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) == pdTRUE )

-							{

-								portYIELD_WITHIN_API();

-							}

-							else

-							{

-								mtCOVERAGE_TEST_MARKER();

-							}

-						}

-					}

-					else

-					{

-						traceQUEUE_PEEK( pxQueue );

-

-						/* The data is not being removed, so reset our read

-						pointer. */

-						pxQueue->u.pcReadFrom = pcOriginalReadPosition;

-

-						/* The data is being left in the queue, so see if there are

-						any other tasks waiting for the data. */

-						if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )

-						{

-							/* Tasks that are removed from the event list will get added to

-							the pending ready list as the scheduler is still suspended. */

-							if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )

-							{

-								/* The task waiting has a higher priority than this task. */

-								portYIELD_WITHIN_API();

-							}

-							else

-							{

-								mtCOVERAGE_TEST_MARKER();

-							}

-						}

-						else

-						{

-							mtCOVERAGE_TEST_MARKER();

-						}

-					}

-

-					taskEXIT_CRITICAL();

-					return pdPASS;

-				}

-				else

-				{

-					if( xTicksToWait == ( TickType_t ) 0 )

-					{

-						taskEXIT_CRITICAL();

-						traceQUEUE_RECEIVE_FAILED( pxQueue );

-						return errQUEUE_EMPTY;

-					}

-					else if( xEntryTimeSet == pdFALSE )

-					{

-						vTaskSetTimeOutState( &xTimeOut );

-						xEntryTimeSet = pdTRUE;

-					}

-				}

-			}

-			taskEXIT_CRITICAL();

-

-			taskENTER_CRITICAL();

-			{

-				if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )

-				{

-					if( prvIsQueueEmpty( pxQueue ) != pdFALSE )

-					{

-						traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue );

-

-						#if ( configUSE_MUTEXES == 1 )

-						{

-							if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )

-							{

-								taskENTER_CRITICAL();

-								{

-									vTaskPriorityInherit( ( void * ) pxQueue->pxMutexHolder );

-								}

-								taskEXIT_CRITICAL();

-							}

-							else

-							{

-								mtCOVERAGE_TEST_MARKER();

-							}

-						}

-						#endif

-

-						vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );

-						portYIELD_WITHIN_API();

-					}

-					else

-					{

-						mtCOVERAGE_TEST_MARKER();

-					}

-				}

-				else

-				{

-					taskEXIT_CRITICAL();

-					traceQUEUE_RECEIVE_FAILED( pxQueue );

-					return errQUEUE_EMPTY;

-				}

-			}

-			taskEXIT_CRITICAL();

-		}

-	}

-

-

-#endif /* configUSE_ALTERNATIVE_API */

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

-

 BaseType_t xQueueGenericSendFromISR( QueueHandle_t xQueue, const void * const pvItemToQueue, BaseType_t * const pxHigherPriorityTaskWoken, const BaseType_t xCopyPosition )

 {

 BaseType_t xReturn;

 UBaseType_t uxSavedInterruptStatus;

-Queue_t * const pxQueue = ( Queue_t * ) xQueue;

+Queue_t * const pxQueue = xQueue;

 

 	configASSERT( pxQueue );

 	configASSERT( !( ( pvItemToQueue == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );

@@ -1086,6 +989,8 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 	{

 		if( ( pxQueue->uxMessagesWaiting < pxQueue->uxLength ) || ( xCopyPosition == queueOVERWRITE ) )

 		{

+			const int8_t cTxLock = pxQueue->cTxLock;

+

 			traceQUEUE_SEND_FROM_ISR( pxQueue );

 

 			/* Semaphores use xQueueGiveFromISR(), so pxQueue will not be a

@@ -1097,13 +1002,13 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 

 			/* The event list is not altered if the queue is locked.  This will

 			be done when the queue is unlocked later. */

-			if( pxQueue->xTxLock == queueUNLOCKED )

+			if( cTxLock == queueUNLOCKED )

 			{

 				#if ( configUSE_QUEUE_SETS == 1 )

 				{

 					if( pxQueue->pxQueueSetContainer != NULL )

 					{

-						if( prvNotifyQueueSetContainer( pxQueue, xCopyPosition ) == pdTRUE )

+						if( prvNotifyQueueSetContainer( pxQueue, xCopyPosition ) != pdFALSE )

 						{

 							/* The queue is a member of a queue set, and posting

 							to the queue set caused a higher priority task to

@@ -1183,7 +1088,7 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 			{

 				/* Increment the lock count so the task that unlocks the queue

 				knows that data was posted while it was locked. */

-				++( pxQueue->xTxLock );

+				pxQueue->cTxLock = ( int8_t ) ( cTxLock + 1 );

 			}

 

 			xReturn = pdPASS;

@@ -1204,7 +1109,7 @@ BaseType_t xQueueGiveFromISR( QueueHandle_t xQueue, BaseType_t * const pxHigherP
 {

 BaseType_t xReturn;

 UBaseType_t uxSavedInterruptStatus;

-Queue_t * const pxQueue = ( Queue_t * ) xQueue;

+Queue_t * const pxQueue = xQueue;

 

 	/* Similar to xQueueGenericSendFromISR() but used with semaphores where the

 	item size is 0.  Don't directly wake a task that was blocked on a queue

@@ -1221,7 +1126,7 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 	/* Normally a mutex would not be given from an interrupt, especially if

 	there is a mutex holder, as priority inheritance makes no sense for an

 	interrupts, only tasks. */

-	configASSERT( !( ( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX ) && ( pxQueue->pxMutexHolder != NULL ) ) );

+	configASSERT( !( ( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX ) && ( pxQueue->u.xSemaphore.xMutexHolder != NULL ) ) );

 

 	/* RTOS ports that support interrupt nesting have the concept of a maximum

 	system call (or maximum API call) interrupt priority.  Interrupts that are

@@ -1241,11 +1146,15 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 

 	uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();

 	{

+		const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;

+

 		/* When the queue is used to implement a semaphore no data is ever

 		moved through the queue but it is still valid to see if the queue 'has

 		space'. */

-		if( pxQueue->uxMessagesWaiting < pxQueue->uxLength )

+		if( uxMessagesWaiting < pxQueue->uxLength )

 		{

+			const int8_t cTxLock = pxQueue->cTxLock;

+

 			traceQUEUE_SEND_FROM_ISR( pxQueue );

 

 			/* A task can only have an inherited priority if it is a mutex

@@ -1254,17 +1163,17 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 			can be assumed there is no mutex holder and no need to determine if

 			priority disinheritance is needed.  Simply increase the count of

 			messages (semaphores) available. */

-			++( pxQueue->uxMessagesWaiting );

+			pxQueue->uxMessagesWaiting = uxMessagesWaiting + ( UBaseType_t ) 1;

 

 			/* The event list is not altered if the queue is locked.  This will

 			be done when the queue is unlocked later. */

-			if( pxQueue->xTxLock == queueUNLOCKED )

+			if( cTxLock == queueUNLOCKED )

 			{

 				#if ( configUSE_QUEUE_SETS == 1 )

 				{

 					if( pxQueue->pxQueueSetContainer != NULL )

 					{

-						if( prvNotifyQueueSetContainer( pxQueue, queueSEND_TO_BACK ) == pdTRUE )

+						if( prvNotifyQueueSetContainer( pxQueue, queueSEND_TO_BACK ) != pdFALSE )

 						{

 							/* The semaphore is a member of a queue set, and

 							posting	to the queue set caused a higher priority

@@ -1344,7 +1253,7 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 			{

 				/* Increment the lock count so the task that unlocks the queue

 				knows that data was posted while it was locked. */

-				++( pxQueue->xTxLock );

+				pxQueue->cTxLock = ( int8_t ) ( cTxLock + 1 );

 			}

 

 			xReturn = pdPASS;

@@ -1361,71 +1270,53 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 }

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

 

-BaseType_t xQueueGenericReceive( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait, const BaseType_t xJustPeeking )

+BaseType_t xQueueReceive( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait )

 {

 BaseType_t xEntryTimeSet = pdFALSE;

 TimeOut_t xTimeOut;

-int8_t *pcOriginalReadPosition;

-Queue_t * const pxQueue = ( Queue_t * ) xQueue;

+Queue_t * const pxQueue = xQueue;

 

-	configASSERT( pxQueue );

-	configASSERT( !( ( pvBuffer == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );

+	/* Check the pointer is not NULL. */

+	configASSERT( ( pxQueue ) );

+

+	/* The buffer into which data is received can only be NULL if the data size

+	is zero (so no data is copied into the buffer. */

+	configASSERT( !( ( ( pvBuffer ) == NULL ) && ( ( pxQueue )->uxItemSize != ( UBaseType_t ) 0U ) ) );

+

+	/* Cannot block if the scheduler is suspended. */

 	#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )

 	{

 		configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );

 	}

 	#endif

 

-	/* This function relaxes the coding standard somewhat to allow return

-	statements within the function itself.  This is done in the interest

-	of execution time efficiency. */

 

+	/*lint -save -e904  This function relaxes the coding standard somewhat to

+	allow return statements within the function itself.  This is done in the

+	interest of execution time efficiency. */

 	for( ;; )

 	{

 		taskENTER_CRITICAL();

 		{

+			const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;

+

 			/* Is there data in the queue now?  To be running the calling task

-			must be	the highest priority task wanting to access the queue. */

-			if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )

+			must be the highest priority task wanting to access the queue. */

+			if( uxMessagesWaiting > ( UBaseType_t ) 0 )

 			{

-				/* Remember the read position in case the queue is only being

-				peeked. */

-				pcOriginalReadPosition = pxQueue->u.pcReadFrom;

-

+				/* Data available, remove one item. */

 				prvCopyDataFromQueue( pxQueue, pvBuffer );

+				traceQUEUE_RECEIVE( pxQueue );

+				pxQueue->uxMessagesWaiting = uxMessagesWaiting - ( UBaseType_t ) 1;

 

-				if( xJustPeeking == pdFALSE )

+				/* There is now space in the queue, were any tasks waiting to

+				post to the queue?  If so, unblock the highest priority waiting

+				task. */

+				if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )

 				{

-					traceQUEUE_RECEIVE( pxQueue );

-

-					/* Actually removing data, not just peeking. */

-					--( pxQueue->uxMessagesWaiting );

-

-					#if ( configUSE_MUTEXES == 1 )

-					{

-						if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )

-						{

-							/* Record the information required to implement

-							priority inheritance should it become necessary. */

-							pxQueue->pxMutexHolder = ( int8_t * ) pvTaskIncrementMutexHeldCount(); /*lint !e961 Cast is not redundant as TaskHandle_t is a typedef. */

-						}

-						else

-						{

-							mtCOVERAGE_TEST_MARKER();

-						}

-					}

-					#endif /* configUSE_MUTEXES */

-

-					if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )

+					if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )

 					{

-						if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) == pdTRUE )

-						{

-							queueYIELD_IF_USING_PREEMPTION();

-						}

-						else

-						{

-							mtCOVERAGE_TEST_MARKER();

-						}

+						queueYIELD_IF_USING_PREEMPTION();

 					}

 					else

 					{

@@ -1434,31 +1325,170 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 				}

 				else

 				{

-					traceQUEUE_PEEK( pxQueue );

+					mtCOVERAGE_TEST_MARKER();

+				}

 

-					/* The data is not being removed, so reset the read

-					pointer. */

-					pxQueue->u.pcReadFrom = pcOriginalReadPosition;

+				taskEXIT_CRITICAL();

+				return pdPASS;

+			}

+			else

+			{

+				if( xTicksToWait == ( TickType_t ) 0 )

+				{

+					/* The queue was empty and no block time is specified (or

+					the block time has expired) so leave now. */

+					taskEXIT_CRITICAL();

+					traceQUEUE_RECEIVE_FAILED( pxQueue );

+					return errQUEUE_EMPTY;

+				}

+				else if( xEntryTimeSet == pdFALSE )

+				{

+					/* The queue was empty and a block time was specified so

+					configure the timeout structure. */

+					vTaskInternalSetTimeOutState( &xTimeOut );

+					xEntryTimeSet = pdTRUE;

+				}

+				else

+				{

+					/* Entry time was already set. */

+					mtCOVERAGE_TEST_MARKER();

+				}

+			}

+		}

+		taskEXIT_CRITICAL();

 

-					/* The data is being left in the queue, so see if there are

-					any other tasks waiting for the data. */

-					if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )

+		/* Interrupts and other tasks can send to and receive from the queue

+		now the critical section has been exited. */

+

+		vTaskSuspendAll();

+		prvLockQueue( pxQueue );

+

+		/* Update the timeout state to see if it has expired yet. */

+		if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )

+		{

+			/* The timeout has not expired.  If the queue is still empty place

+			the task on the list of tasks waiting to receive from the queue. */

+			if( prvIsQueueEmpty( pxQueue ) != pdFALSE )

+			{

+				traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue );

+				vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );

+				prvUnlockQueue( pxQueue );

+				if( xTaskResumeAll() == pdFALSE )

+				{

+					portYIELD_WITHIN_API();

+				}

+				else

+				{

+					mtCOVERAGE_TEST_MARKER();

+				}

+			}

+			else

+			{

+				/* The queue contains data again.  Loop back to try and read the

+				data. */

+				prvUnlockQueue( pxQueue );

+				( void ) xTaskResumeAll();

+			}

+		}

+		else

+		{

+			/* Timed out.  If there is no data in the queue exit, otherwise loop

+			back and attempt to read the data. */

+			prvUnlockQueue( pxQueue );

+			( void ) xTaskResumeAll();

+

+			if( prvIsQueueEmpty( pxQueue ) != pdFALSE )

+			{

+				traceQUEUE_RECEIVE_FAILED( pxQueue );

+				return errQUEUE_EMPTY;

+			}

+			else

+			{

+				mtCOVERAGE_TEST_MARKER();

+			}

+		}

+	} /*lint -restore */

+}

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

+

+BaseType_t xQueueSemaphoreTake( QueueHandle_t xQueue, TickType_t xTicksToWait )

+{

+BaseType_t xEntryTimeSet = pdFALSE;

+TimeOut_t xTimeOut;

+Queue_t * const pxQueue = xQueue;

+

+#if( configUSE_MUTEXES == 1 )

+	BaseType_t xInheritanceOccurred = pdFALSE;

+#endif

+

+	/* Check the queue pointer is not NULL. */

+	configASSERT( ( pxQueue ) );

+

+	/* Check this really is a semaphore, in which case the item size will be

+	0. */

+	configASSERT( pxQueue->uxItemSize == 0 );

+

+	/* Cannot block if the scheduler is suspended. */

+	#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )

+	{

+		configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );

+	}

+	#endif

+

+

+	/*lint -save -e904 This function relaxes the coding standard somewhat to allow return

+	statements within the function itself.  This is done in the interest

+	of execution time efficiency. */

+	for( ;; )

+	{

+		taskENTER_CRITICAL();

+		{

+			/* Semaphores are queues with an item size of 0, and where the

+			number of messages in the queue is the semaphore's count value. */

+			const UBaseType_t uxSemaphoreCount = pxQueue->uxMessagesWaiting;

+

+			/* Is there data in the queue now?  To be running the calling task

+			must be the highest priority task wanting to access the queue. */

+			if( uxSemaphoreCount > ( UBaseType_t ) 0 )

+			{

+				traceQUEUE_RECEIVE( pxQueue );

+

+				/* Semaphores are queues with a data size of zero and where the

+				messages waiting is the semaphore's count.  Reduce the count. */

+				pxQueue->uxMessagesWaiting = uxSemaphoreCount - ( UBaseType_t ) 1;

+

+				#if ( configUSE_MUTEXES == 1 )

+				{

+					if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )

 					{

-						if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )

-						{

-							/* The task waiting has a higher priority than this task. */

-							queueYIELD_IF_USING_PREEMPTION();

-						}

-						else

-						{

-							mtCOVERAGE_TEST_MARKER();

-						}

+						/* Record the information required to implement

+						priority inheritance should it become necessary. */

+						pxQueue->u.xSemaphore.xMutexHolder = pvTaskIncrementMutexHeldCount();

 					}

 					else

 					{

 						mtCOVERAGE_TEST_MARKER();

 					}

 				}

+				#endif /* configUSE_MUTEXES */

+

+				/* Check to see if other tasks are blocked waiting to give the

+				semaphore, and if so, unblock the highest priority such task. */

+				if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )

+				{

+					if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToSend ) ) != pdFALSE )

+					{

+						queueYIELD_IF_USING_PREEMPTION();

+					}

+					else

+					{

+						mtCOVERAGE_TEST_MARKER();

+					}

+				}

+				else

+				{

+					mtCOVERAGE_TEST_MARKER();

+				}

 

 				taskEXIT_CRITICAL();

 				return pdPASS;

@@ -1467,17 +1497,26 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 			{

 				if( xTicksToWait == ( TickType_t ) 0 )

 				{

-					/* The queue was empty and no block time is specified (or

-					the block time has expired) so leave now. */

+					/* For inheritance to have occurred there must have been an

+					initial timeout, and an adjusted timeout cannot become 0, as

+					if it were 0 the function would have exited. */

+					#if( configUSE_MUTEXES == 1 )

+					{

+						configASSERT( xInheritanceOccurred == pdFALSE );

+					}

+					#endif /* configUSE_MUTEXES */

+

+					/* The semaphore count was 0 and no block time is specified

+					(or the block time has expired) so exit now. */

 					taskEXIT_CRITICAL();

 					traceQUEUE_RECEIVE_FAILED( pxQueue );

 					return errQUEUE_EMPTY;

 				}

 				else if( xEntryTimeSet == pdFALSE )

 				{

-					/* The queue was empty and a block time was specified so

-					configure the timeout structure. */

-					vTaskSetTimeOutState( &xTimeOut );

+					/* The semaphore count was 0 and a block time was specified

+					so configure the timeout structure ready to block. */

+					vTaskInternalSetTimeOutState( &xTimeOut );

 					xEntryTimeSet = pdTRUE;

 				}

 				else

@@ -1489,7 +1528,7 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 		}

 		taskEXIT_CRITICAL();

 

-		/* Interrupts and other tasks can send to and receive from the queue

+		/* Interrupts and other tasks can give to and take from the semaphore

 		now the critical section has been exited. */

 

 		vTaskSuspendAll();

@@ -1498,6 +1537,10 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 		/* Update the timeout state to see if it has expired yet. */

 		if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )

 		{

+			/* A block time is specified and not expired.  If the semaphore

+			count is 0 then enter the Blocked state to wait for a semaphore to

+			become available.  As semaphores are implemented with queues the

+			queue being empty is equivalent to the semaphore count being 0. */

 			if( prvIsQueueEmpty( pxQueue ) != pdFALSE )

 			{

 				traceBLOCKING_ON_QUEUE_RECEIVE( pxQueue );

@@ -1508,7 +1551,7 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 					{

 						taskENTER_CRITICAL();

 						{

-							vTaskPriorityInherit( ( void * ) pxQueue->pxMutexHolder );

+							xInheritanceOccurred = xTaskPriorityInherit( pxQueue->u.xSemaphore.xMutexHolder );

 						}

 						taskEXIT_CRITICAL();

 					}

@@ -1532,19 +1575,206 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 			}

 			else

 			{

-				/* Try again. */

+				/* There was no timeout and the semaphore count was not 0, so

+				attempt to take the semaphore again. */

 				prvUnlockQueue( pxQueue );

 				( void ) xTaskResumeAll();

 			}

 		}

 		else

 		{

+			/* Timed out. */

 			prvUnlockQueue( pxQueue );

 			( void ) xTaskResumeAll();

-			traceQUEUE_RECEIVE_FAILED( pxQueue );

-			return errQUEUE_EMPTY;

+

+			/* If the semaphore count is 0 exit now as the timeout has

+			expired.  Otherwise return to attempt to take the semaphore that is

+			known to be available.  As semaphores are implemented by queues the

+			queue being empty is equivalent to the semaphore count being 0. */

+			if( prvIsQueueEmpty( pxQueue ) != pdFALSE )

+			{

+				#if ( configUSE_MUTEXES == 1 )

+				{

+					/* xInheritanceOccurred could only have be set if

+					pxQueue->uxQueueType == queueQUEUE_IS_MUTEX so no need to

+					test the mutex type again to check it is actually a mutex. */

+					if( xInheritanceOccurred != pdFALSE )

+					{

+						taskENTER_CRITICAL();

+						{

+							UBaseType_t uxHighestWaitingPriority;

+

+							/* This task blocking on the mutex caused another

+							task to inherit this task's priority.  Now this task

+							has timed out the priority should be disinherited

+							again, but only as low as the next highest priority

+							task that is waiting for the same mutex. */

+							uxHighestWaitingPriority = prvGetDisinheritPriorityAfterTimeout( pxQueue );

+							vTaskPriorityDisinheritAfterTimeout( pxQueue->u.xSemaphore.xMutexHolder, uxHighestWaitingPriority );

+						}

+						taskEXIT_CRITICAL();

+					}

+				}

+				#endif /* configUSE_MUTEXES */

+

+				traceQUEUE_RECEIVE_FAILED( pxQueue );

+				return errQUEUE_EMPTY;

+			}

+			else

+			{

+				mtCOVERAGE_TEST_MARKER();

+			}

 		}

+	} /*lint -restore */

+}

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

+

+BaseType_t xQueuePeek( QueueHandle_t xQueue, void * const pvBuffer, TickType_t xTicksToWait )

+{

+BaseType_t xEntryTimeSet = pdFALSE;

+TimeOut_t xTimeOut;

+int8_t *pcOriginalReadPosition;

+Queue_t * const pxQueue = xQueue;

+

+	/* Check the pointer is not NULL. */

+	configASSERT( ( pxQueue ) );

+

+	/* The buffer into which data is received can only be NULL if the data size

+	is zero (so no data is copied into the buffer. */

+	configASSERT( !( ( ( pvBuffer ) == NULL ) && ( ( pxQueue )->uxItemSize != ( UBaseType_t ) 0U ) ) );

+

+	/* Cannot block if the scheduler is suspended. */

+	#if ( ( INCLUDE_xTaskGetSchedulerState == 1 ) || ( configUSE_TIMERS == 1 ) )

+	{

+		configASSERT( !( ( xTaskGetSchedulerState() == taskSCHEDULER_SUSPENDED ) && ( xTicksToWait != 0 ) ) );

 	}

+	#endif

+

+

+	/*lint -save -e904  This function relaxes the coding standard somewhat to

+	allow return statements within the function itself.  This is done in the

+	interest of execution time efficiency. */

+	for( ;; )

+	{

+		taskENTER_CRITICAL();

+		{

+			const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;

+

+			/* Is there data in the queue now?  To be running the calling task

+			must be the highest priority task wanting to access the queue. */

+			if( uxMessagesWaiting > ( UBaseType_t ) 0 )

+			{

+				/* Remember the read position so it can be reset after the data

+				is read from the queue as this function is only peeking the

+				data, not removing it. */

+				pcOriginalReadPosition = pxQueue->u.xQueue.pcReadFrom;

+

+				prvCopyDataFromQueue( pxQueue, pvBuffer );

+				traceQUEUE_PEEK( pxQueue );

+

+				/* The data is not being removed, so reset the read pointer. */

+				pxQueue->u.xQueue.pcReadFrom = pcOriginalReadPosition;

+

+				/* The data is being left in the queue, so see if there are

+				any other tasks waiting for the data. */

+				if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )

+				{

+					if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )

+					{

+						/* The task waiting has a higher priority than this task. */

+						queueYIELD_IF_USING_PREEMPTION();

+					}

+					else

+					{

+						mtCOVERAGE_TEST_MARKER();

+					}

+				}

+				else

+				{

+					mtCOVERAGE_TEST_MARKER();

+				}

+

+				taskEXIT_CRITICAL();

+				return pdPASS;

+			}

+			else

+			{

+				if( xTicksToWait == ( TickType_t ) 0 )

+				{

+					/* The queue was empty and no block time is specified (or

+					the block time has expired) so leave now. */

+					taskEXIT_CRITICAL();

+					traceQUEUE_PEEK_FAILED( pxQueue );

+					return errQUEUE_EMPTY;

+				}

+				else if( xEntryTimeSet == pdFALSE )

+				{

+					/* The queue was empty and a block time was specified so

+					configure the timeout structure ready to enter the blocked

+					state. */

+					vTaskInternalSetTimeOutState( &xTimeOut );

+					xEntryTimeSet = pdTRUE;

+				}

+				else

+				{

+					/* Entry time was already set. */

+					mtCOVERAGE_TEST_MARKER();

+				}

+			}

+		}

+		taskEXIT_CRITICAL();

+

+		/* Interrupts and other tasks can send to and receive from the queue

+		now the critical section has been exited. */

+

+		vTaskSuspendAll();

+		prvLockQueue( pxQueue );

+

+		/* Update the timeout state to see if it has expired yet. */

+		if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE )

+		{

+			/* Timeout has not expired yet, check to see if there is data in the

+			queue now, and if not enter the Blocked state to wait for data. */

+			if( prvIsQueueEmpty( pxQueue ) != pdFALSE )

+			{

+				traceBLOCKING_ON_QUEUE_PEEK( pxQueue );

+				vTaskPlaceOnEventList( &( pxQueue->xTasksWaitingToReceive ), xTicksToWait );

+				prvUnlockQueue( pxQueue );

+				if( xTaskResumeAll() == pdFALSE )

+				{

+					portYIELD_WITHIN_API();

+				}

+				else

+				{

+					mtCOVERAGE_TEST_MARKER();

+				}

+			}

+			else

+			{

+				/* There is data in the queue now, so don't enter the blocked

+				state, instead return to try and obtain the data. */

+				prvUnlockQueue( pxQueue );

+				( void ) xTaskResumeAll();

+			}

+		}

+		else

+		{

+			/* The timeout has expired.  If there is still no data in the queue

+			exit, otherwise go back and try to read the data again. */

+			prvUnlockQueue( pxQueue );

+			( void ) xTaskResumeAll();

+

+			if( prvIsQueueEmpty( pxQueue ) != pdFALSE )

+			{

+				traceQUEUE_PEEK_FAILED( pxQueue );

+				return errQUEUE_EMPTY;

+			}

+			else

+			{

+				mtCOVERAGE_TEST_MARKER();

+			}

+		}

+	} /*lint -restore */

 }

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

 

@@ -1552,7 +1782,7 @@ BaseType_t xQueueReceiveFromISR( QueueHandle_t xQueue, void * const pvBuffer, Ba
 {

 BaseType_t xReturn;

 UBaseType_t uxSavedInterruptStatus;

-Queue_t * const pxQueue = ( Queue_t * ) xQueue;

+Queue_t * const pxQueue = xQueue;

 

 	configASSERT( pxQueue );

 	configASSERT( !( ( pvBuffer == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );

@@ -1575,19 +1805,23 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 

 	uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();

 	{

+		const UBaseType_t uxMessagesWaiting = pxQueue->uxMessagesWaiting;

+

 		/* Cannot block in an ISR, so check there is data available. */

-		if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )

+		if( uxMessagesWaiting > ( UBaseType_t ) 0 )

 		{

+			const int8_t cRxLock = pxQueue->cRxLock;

+

 			traceQUEUE_RECEIVE_FROM_ISR( pxQueue );

 

 			prvCopyDataFromQueue( pxQueue, pvBuffer );

-			--( pxQueue->uxMessagesWaiting );

+			pxQueue->uxMessagesWaiting = uxMessagesWaiting - ( UBaseType_t ) 1;

 

 			/* If the queue is locked the event list will not be modified.

 			Instead update the lock count so the task that unlocks the queue

 			will know that an ISR has removed data while the queue was

 			locked. */

-			if( pxQueue->xRxLock == queueUNLOCKED )

+			if( cRxLock == queueUNLOCKED )

 			{

 				if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )

 				{

@@ -1618,7 +1852,7 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 			{

 				/* Increment the lock count so the task that unlocks the queue

 				knows that data was removed while it was locked. */

-				++( pxQueue->xRxLock );

+				pxQueue->cRxLock = ( int8_t ) ( cRxLock + 1 );

 			}

 

 			xReturn = pdPASS;

@@ -1640,7 +1874,7 @@ BaseType_t xQueuePeekFromISR( QueueHandle_t xQueue,  void * const pvBuffer )
 BaseType_t xReturn;

 UBaseType_t uxSavedInterruptStatus;

 int8_t *pcOriginalReadPosition;

-Queue_t * const pxQueue = ( Queue_t * ) xQueue;

+Queue_t * const pxQueue = xQueue;

 

 	configASSERT( pxQueue );

 	configASSERT( !( ( pvBuffer == NULL ) && ( pxQueue->uxItemSize != ( UBaseType_t ) 0U ) ) );

@@ -1671,9 +1905,9 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 

 			/* Remember the read position so it can be reset as nothing is

 			actually being removed from the queue. */

-			pcOriginalReadPosition = pxQueue->u.pcReadFrom;

+			pcOriginalReadPosition = pxQueue->u.xQueue.pcReadFrom;

 			prvCopyDataFromQueue( pxQueue, pvBuffer );

-			pxQueue->u.pcReadFrom = pcOriginalReadPosition;

+			pxQueue->u.xQueue.pcReadFrom = pcOriginalReadPosition;

 

 			xReturn = pdPASS;

 		}

@@ -1708,9 +1942,8 @@ UBaseType_t uxReturn;
 UBaseType_t uxQueueSpacesAvailable( const QueueHandle_t xQueue )

 {

 UBaseType_t uxReturn;

-Queue_t *pxQueue;

+Queue_t * const pxQueue = xQueue;

 

-	pxQueue = ( Queue_t * ) xQueue;

 	configASSERT( pxQueue );

 

 	taskENTER_CRITICAL();

@@ -1726,10 +1959,10 @@ Queue_t *pxQueue;
 UBaseType_t uxQueueMessagesWaitingFromISR( const QueueHandle_t xQueue )

 {

 UBaseType_t uxReturn;

+Queue_t * const pxQueue = xQueue;

 

-	configASSERT( xQueue );

-

-	uxReturn = ( ( Queue_t * ) xQueue )->uxMessagesWaiting;

+	configASSERT( pxQueue );

+	uxReturn = pxQueue->uxMessagesWaiting;

 

 	return uxReturn;

 } /*lint !e818 Pointer cannot be declared const as xQueue is a typedef not pointer. */

@@ -1737,17 +1970,43 @@ UBaseType_t uxReturn;
 

 void vQueueDelete( QueueHandle_t xQueue )

 {

-Queue_t * const pxQueue = ( Queue_t * ) xQueue;

+Queue_t * const pxQueue = xQueue;

 

 	configASSERT( pxQueue );

-

 	traceQUEUE_DELETE( pxQueue );

+

 	#if ( configQUEUE_REGISTRY_SIZE > 0 )

 	{

 		vQueueUnregisterQueue( pxQueue );

 	}

 	#endif

-	vPortFree( pxQueue );

+

+	#if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 0 ) )

+	{

+		/* The queue can only have been allocated dynamically - free it

+		again. */

+		vPortFree( pxQueue );

+	}

+	#elif( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )

+	{

+		/* The queue could have been allocated statically or dynamically, so

+		check before attempting to free the memory. */

+		if( pxQueue->ucStaticallyAllocated == ( uint8_t ) pdFALSE )

+		{

+			vPortFree( pxQueue );

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+	}

+	#else

+	{

+		/* The queue must have been statically allocated, so is not going to be

+		deleted.  Avoid compiler warnings about the unused parameter. */

+		( void ) pxQueue;

+	}

+	#endif /* configSUPPORT_DYNAMIC_ALLOCATION */

 }

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

 

@@ -1781,9 +2040,41 @@ Queue_t * const pxQueue = ( Queue_t * ) xQueue;
 #endif /* configUSE_TRACE_FACILITY */

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

 

+#if( configUSE_MUTEXES == 1 )

+

+	static UBaseType_t prvGetDisinheritPriorityAfterTimeout( const Queue_t * const pxQueue )

+	{

+	UBaseType_t uxHighestPriorityOfWaitingTasks;

+

+		/* If a task waiting for a mutex causes the mutex holder to inherit a

+		priority, but the waiting task times out, then the holder should

+		disinherit the priority - but only down to the highest priority of any

+		other tasks that are waiting for the same mutex.  For this purpose,

+		return the priority of the highest priority task that is waiting for the

+		mutex. */

+		if( listCURRENT_LIST_LENGTH( &( pxQueue->xTasksWaitingToReceive ) ) > 0U )

+		{

+			uxHighestPriorityOfWaitingTasks = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) listGET_ITEM_VALUE_OF_HEAD_ENTRY( &( pxQueue->xTasksWaitingToReceive ) );

+		}

+		else

+		{

+			uxHighestPriorityOfWaitingTasks = tskIDLE_PRIORITY;

+		}

+

+		return uxHighestPriorityOfWaitingTasks;

+	}

+

+#endif /* configUSE_MUTEXES */

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

+

 static BaseType_t prvCopyDataToQueue( Queue_t * const pxQueue, const void *pvItemToQueue, const BaseType_t xPosition )

 {

 BaseType_t xReturn = pdFALSE;

+UBaseType_t uxMessagesWaiting;

+

+	/* This function is called from a critical section. */

+

+	uxMessagesWaiting = pxQueue->uxMessagesWaiting;

 

 	if( pxQueue->uxItemSize == ( UBaseType_t ) 0 )

 	{

@@ -1792,8 +2083,8 @@ BaseType_t xReturn = pdFALSE;
 			if( pxQueue->uxQueueType == queueQUEUE_IS_MUTEX )

 			{

 				/* The mutex is no longer being held. */

-				xReturn = xTaskPriorityDisinherit( ( void * ) pxQueue->pxMutexHolder );

-				pxQueue->pxMutexHolder = NULL;

+				xReturn = xTaskPriorityDisinherit( pxQueue->u.xSemaphore.xMutexHolder );

+				pxQueue->u.xSemaphore.xMutexHolder = NULL;

 			}

 			else

 			{

@@ -1804,9 +2095,9 @@ BaseType_t xReturn = pdFALSE;
 	}

 	else if( xPosition == queueSEND_TO_BACK )

 	{

-		( void ) memcpy( ( void * ) pxQueue->pcWriteTo, pvItemToQueue, ( size_t ) pxQueue->uxItemSize ); /*lint !e961 !e418 MISRA exception as the casts are only redundant for some ports, plus previous logic ensures a null pointer can only be passed to memcpy() if the copy size is 0. */

-		pxQueue->pcWriteTo += pxQueue->uxItemSize;

-		if( pxQueue->pcWriteTo >= pxQueue->pcTail ) /*lint !e946 MISRA exception justified as comparison of pointers is the cleanest solution. */

+		( void ) memcpy( ( void * ) pxQueue->pcWriteTo, pvItemToQueue, ( size_t ) pxQueue->uxItemSize ); /*lint !e961 !e418 !e9087 MISRA exception as the casts are only redundant for some ports, plus previous logic ensures a null pointer can only be passed to memcpy() if the copy size is 0.  Cast to void required by function signature and safe as no alignment requirement and copy length specified in bytes. */

+		pxQueue->pcWriteTo += pxQueue->uxItemSize; /*lint !e9016 Pointer arithmetic on char types ok, especially in this use case where it is the clearest way of conveying intent. */

+		if( pxQueue->pcWriteTo >= pxQueue->u.xQueue.pcTail ) /*lint !e946 MISRA exception justified as comparison of pointers is the cleanest solution. */

 		{

 			pxQueue->pcWriteTo = pxQueue->pcHead;

 		}

@@ -1817,11 +2108,11 @@ BaseType_t xReturn = pdFALSE;
 	}

 	else

 	{

-		( void ) memcpy( ( void * ) pxQueue->u.pcReadFrom, pvItemToQueue, ( size_t ) pxQueue->uxItemSize ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */

-		pxQueue->u.pcReadFrom -= pxQueue->uxItemSize;

-		if( pxQueue->u.pcReadFrom < pxQueue->pcHead ) /*lint !e946 MISRA exception justified as comparison of pointers is the cleanest solution. */

+		( void ) memcpy( ( void * ) pxQueue->u.xQueue.pcReadFrom, pvItemToQueue, ( size_t ) pxQueue->uxItemSize ); /*lint !e961 !e9087 !e418 MISRA exception as the casts are only redundant for some ports.  Cast to void required by function signature and safe as no alignment requirement and copy length specified in bytes.  Assert checks null pointer only used when length is 0. */

+		pxQueue->u.xQueue.pcReadFrom -= pxQueue->uxItemSize;

+		if( pxQueue->u.xQueue.pcReadFrom < pxQueue->pcHead ) /*lint !e946 MISRA exception justified as comparison of pointers is the cleanest solution. */

 		{

-			pxQueue->u.pcReadFrom = ( pxQueue->pcTail - pxQueue->uxItemSize );

+			pxQueue->u.xQueue.pcReadFrom = ( pxQueue->u.xQueue.pcTail - pxQueue->uxItemSize );

 		}

 		else

 		{

@@ -1830,13 +2121,13 @@ BaseType_t xReturn = pdFALSE;
 

 		if( xPosition == queueOVERWRITE )

 		{

-			if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )

+			if( uxMessagesWaiting > ( UBaseType_t ) 0 )

 			{

 				/* An item is not being added but overwritten, so subtract

 				one from the recorded number of items in the queue so when

 				one is added again below the number of recorded items remains

 				correct. */

-				--( pxQueue->uxMessagesWaiting );

+				--uxMessagesWaiting;

 			}

 			else

 			{

@@ -1849,7 +2140,7 @@ BaseType_t xReturn = pdFALSE;
 		}

 	}

 

-	++( pxQueue->uxMessagesWaiting );

+	pxQueue->uxMessagesWaiting = uxMessagesWaiting + ( UBaseType_t ) 1;

 

 	return xReturn;

 }

@@ -1859,16 +2150,16 @@ static void prvCopyDataFromQueue( Queue_t * const pxQueue, void * const pvBuffer
 {

 	if( pxQueue->uxItemSize != ( UBaseType_t ) 0 )

 	{

-		pxQueue->u.pcReadFrom += pxQueue->uxItemSize;

-		if( pxQueue->u.pcReadFrom >= pxQueue->pcTail ) /*lint !e946 MISRA exception justified as use of the relational operator is the cleanest solutions. */

+		pxQueue->u.xQueue.pcReadFrom += pxQueue->uxItemSize; /*lint !e9016 Pointer arithmetic on char types ok, especially in this use case where it is the clearest way of conveying intent. */

+		if( pxQueue->u.xQueue.pcReadFrom >= pxQueue->u.xQueue.pcTail ) /*lint !e946 MISRA exception justified as use of the relational operator is the cleanest solutions. */

 		{

-			pxQueue->u.pcReadFrom = pxQueue->pcHead;

+			pxQueue->u.xQueue.pcReadFrom = pxQueue->pcHead;

 		}

 		else

 		{

 			mtCOVERAGE_TEST_MARKER();

 		}

-		( void ) memcpy( ( void * ) pvBuffer, ( void * ) pxQueue->u.pcReadFrom, ( size_t ) pxQueue->uxItemSize ); /*lint !e961 !e418 MISRA exception as the casts are only redundant for some ports.  Also previous logic ensures a null pointer can only be passed to memcpy() when the count is 0. */

+		( void ) memcpy( ( void * ) pvBuffer, ( void * ) pxQueue->u.xQueue.pcReadFrom, ( size_t ) pxQueue->uxItemSize ); /*lint !e961 !e418 !e9087 MISRA exception as the casts are only redundant for some ports.  Also previous logic ensures a null pointer can only be passed to memcpy() when the count is 0.  Cast to void required by function signature and safe as no alignment requirement and copy length specified in bytes. */

 	}

 }

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

@@ -1883,8 +2174,10 @@ static void prvUnlockQueue( Queue_t * const pxQueue )
 	updated. */

 	taskENTER_CRITICAL();

 	{

+		int8_t cTxLock = pxQueue->cTxLock;

+

 		/* See if data was added to the queue while it was locked. */

-		while( pxQueue->xTxLock > queueLOCKED_UNMODIFIED )

+		while( cTxLock > queueLOCKED_UNMODIFIED )

 		{

 			/* Data was posted while the queue was locked.  Are any tasks

 			blocked waiting for data to become available? */

@@ -1892,7 +2185,7 @@ static void prvUnlockQueue( Queue_t * const pxQueue )
 			{

 				if( pxQueue->pxQueueSetContainer != NULL )

 				{

-					if( prvNotifyQueueSetContainer( pxQueue, queueSEND_TO_BACK ) == pdTRUE )

+					if( prvNotifyQueueSetContainer( pxQueue, queueSEND_TO_BACK ) != pdFALSE )

 					{

 						/* The queue is a member of a queue set, and posting to

 						the queue set caused a higher priority task to unblock.

@@ -1906,8 +2199,9 @@ static void prvUnlockQueue( Queue_t * const pxQueue )
 				}

 				else

 				{

-					/* Tasks that are removed from the event list will get added to

-					the pending ready list as the scheduler is still suspended. */

+					/* Tasks that are removed from the event list will get

+					added to the pending ready list as the scheduler is still

+					suspended. */

 					if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToReceive ) ) == pdFALSE )

 					{

 						if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )

@@ -1935,8 +2229,8 @@ static void prvUnlockQueue( Queue_t * const pxQueue )
 				{

 					if( xTaskRemoveFromEventList( &( pxQueue->xTasksWaitingToReceive ) ) != pdFALSE )

 					{

-						/* The task waiting has a higher priority so record that a

-						context	switch is required. */

+						/* The task waiting has a higher priority so record that

+						a context switch is required. */

 						vTaskMissedYield();

 					}

 					else

@@ -1951,17 +2245,19 @@ static void prvUnlockQueue( Queue_t * const pxQueue )
 			}

 			#endif /* configUSE_QUEUE_SETS */

 

-			--( pxQueue->xTxLock );

+			--cTxLock;

 		}

 

-		pxQueue->xTxLock = queueUNLOCKED;

+		pxQueue->cTxLock = queueUNLOCKED;

 	}

 	taskEXIT_CRITICAL();

 

 	/* Do the same for the Rx lock. */

 	taskENTER_CRITICAL();

 	{

-		while( pxQueue->xRxLock > queueLOCKED_UNMODIFIED )

+		int8_t cRxLock = pxQueue->cRxLock;

+

+		while( cRxLock > queueLOCKED_UNMODIFIED )

 		{

 			if( listLIST_IS_EMPTY( &( pxQueue->xTasksWaitingToSend ) ) == pdFALSE )

 			{

@@ -1974,7 +2270,7 @@ static void prvUnlockQueue( Queue_t * const pxQueue )
 					mtCOVERAGE_TEST_MARKER();

 				}

 

-				--( pxQueue->xRxLock );

+				--cRxLock;

 			}

 			else

 			{

@@ -1982,7 +2278,7 @@ static void prvUnlockQueue( Queue_t * const pxQueue )
 			}

 		}

 

-		pxQueue->xRxLock = queueUNLOCKED;

+		pxQueue->cRxLock = queueUNLOCKED;

 	}

 	taskEXIT_CRITICAL();

 }

@@ -2012,9 +2308,10 @@ BaseType_t xReturn;
 BaseType_t xQueueIsQueueEmptyFromISR( const QueueHandle_t xQueue )

 {

 BaseType_t xReturn;

+Queue_t * const pxQueue = xQueue;

 

-	configASSERT( xQueue );

-	if( ( ( Queue_t * ) xQueue )->uxMessagesWaiting == ( UBaseType_t ) 0 )

+	configASSERT( pxQueue );

+	if( pxQueue->uxMessagesWaiting == ( UBaseType_t ) 0 )

 	{

 		xReturn = pdTRUE;

 	}

@@ -2051,9 +2348,10 @@ BaseType_t xReturn;
 BaseType_t xQueueIsQueueFullFromISR( const QueueHandle_t xQueue )

 {

 BaseType_t xReturn;

+Queue_t * const pxQueue = xQueue;

 

-	configASSERT( xQueue );

-	if( ( ( Queue_t * ) xQueue )->uxMessagesWaiting == ( ( Queue_t * ) xQueue )->uxLength )

+	configASSERT( pxQueue );

+	if( pxQueue->uxMessagesWaiting == pxQueue->uxLength )

 	{

 		xReturn = pdTRUE;

 	}

@@ -2071,7 +2369,7 @@ BaseType_t xReturn;
 	BaseType_t xQueueCRSend( QueueHandle_t xQueue, const void *pvItemToQueue, TickType_t xTicksToWait )

 	{

 	BaseType_t xReturn;

-	Queue_t * const pxQueue = ( Queue_t * ) xQueue;

+	Queue_t * const pxQueue = xQueue;

 

 		/* If the queue is already full we may have to block.  A critical section

 		is required to prevent an interrupt removing something from the queue

@@ -2148,7 +2446,7 @@ BaseType_t xReturn;
 	BaseType_t xQueueCRReceive( QueueHandle_t xQueue, void *pvBuffer, TickType_t xTicksToWait )

 	{

 	BaseType_t xReturn;

-	Queue_t * const pxQueue = ( Queue_t * ) xQueue;

+	Queue_t * const pxQueue = xQueue;

 

 		/* If the queue is already empty we may have to block.  A critical section

 		is required to prevent an interrupt adding something to the queue

@@ -2185,17 +2483,17 @@ BaseType_t xReturn;
 			if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )

 			{

 				/* Data is available from the queue. */

-				pxQueue->u.pcReadFrom += pxQueue->uxItemSize;

-				if( pxQueue->u.pcReadFrom >= pxQueue->pcTail )

+				pxQueue->u.xQueue.pcReadFrom += pxQueue->uxItemSize;

+				if( pxQueue->u.xQueue.pcReadFrom >= pxQueue->u.xQueue.pcTail )

 				{

-					pxQueue->u.pcReadFrom = pxQueue->pcHead;

+					pxQueue->u.xQueue.pcReadFrom = pxQueue->pcHead;

 				}

 				else

 				{

 					mtCOVERAGE_TEST_MARKER();

 				}

 				--( pxQueue->uxMessagesWaiting );

-				( void ) memcpy( ( void * ) pvBuffer, ( void * ) pxQueue->u.pcReadFrom, ( unsigned ) pxQueue->uxItemSize );

+				( void ) memcpy( ( void * ) pvBuffer, ( void * ) pxQueue->u.xQueue.pcReadFrom, ( unsigned ) pxQueue->uxItemSize );

 

 				xReturn = pdPASS;

 

@@ -2237,7 +2535,7 @@ BaseType_t xReturn;
 

 	BaseType_t xQueueCRSendFromISR( QueueHandle_t xQueue, const void *pvItemToQueue, BaseType_t xCoRoutinePreviouslyWoken )

 	{

-	Queue_t * const pxQueue = ( Queue_t * ) xQueue;

+	Queue_t * const pxQueue = xQueue;

 

 		/* Cannot block within an ISR so if there is no space on the queue then

 		exit without doing anything. */

@@ -2286,24 +2584,24 @@ BaseType_t xReturn;
 	BaseType_t xQueueCRReceiveFromISR( QueueHandle_t xQueue, void *pvBuffer, BaseType_t *pxCoRoutineWoken )

 	{

 	BaseType_t xReturn;

-	Queue_t * const pxQueue = ( Queue_t * ) xQueue;

+	Queue_t * const pxQueue = xQueue;

 

 		/* We cannot block from an ISR, so check there is data available. If

 		not then just leave without doing anything. */

 		if( pxQueue->uxMessagesWaiting > ( UBaseType_t ) 0 )

 		{

 			/* Copy the data from the queue. */

-			pxQueue->u.pcReadFrom += pxQueue->uxItemSize;

-			if( pxQueue->u.pcReadFrom >= pxQueue->pcTail )

+			pxQueue->u.xQueue.pcReadFrom += pxQueue->uxItemSize;

+			if( pxQueue->u.xQueue.pcReadFrom >= pxQueue->u.xQueue.pcTail )

 			{

-				pxQueue->u.pcReadFrom = pxQueue->pcHead;

+				pxQueue->u.xQueue.pcReadFrom = pxQueue->pcHead;

 			}

 			else

 			{

 				mtCOVERAGE_TEST_MARKER();

 			}

 			--( pxQueue->uxMessagesWaiting );

-			( void ) memcpy( ( void * ) pvBuffer, ( void * ) pxQueue->u.pcReadFrom, ( unsigned ) pxQueue->uxItemSize );

+			( void ) memcpy( ( void * ) pvBuffer, ( void * ) pxQueue->u.xQueue.pcReadFrom, ( unsigned ) pxQueue->uxItemSize );

 

 			if( ( *pxCoRoutineWoken ) == pdFALSE )

 			{

@@ -2372,6 +2670,34 @@ BaseType_t xReturn;
 

 #if ( configQUEUE_REGISTRY_SIZE > 0 )

 

+	const char *pcQueueGetName( QueueHandle_t xQueue ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+	{

+	UBaseType_t ux;

+	const char *pcReturn = NULL; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+

+		/* Note there is nothing here to protect against another task adding or

+		removing entries from the registry while it is being searched. */

+		for( ux = ( UBaseType_t ) 0U; ux < ( UBaseType_t ) configQUEUE_REGISTRY_SIZE; ux++ )

+		{

+			if( xQueueRegistry[ ux ].xHandle == xQueue )

+			{

+				pcReturn = xQueueRegistry[ ux ].pcQueueName;

+				break;

+			}

+			else

+			{

+				mtCOVERAGE_TEST_MARKER();

+			}

+		}

+

+		return pcReturn;

+	} /*lint !e818 xQueue cannot be a pointer to const because it is a typedef. */

+

+#endif /* configQUEUE_REGISTRY_SIZE */

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

+

+#if ( configQUEUE_REGISTRY_SIZE > 0 )

+

 	void vQueueUnregisterQueue( QueueHandle_t xQueue )

 	{

 	UBaseType_t ux;

@@ -2384,6 +2710,11 @@ BaseType_t xReturn;
 			{

 				/* Set the name to NULL to show that this slot if free again. */

 				xQueueRegistry[ ux ].pcQueueName = NULL;

+

+				/* Set the handle to NULL to ensure the same queue handle cannot

+				appear in the registry twice if it is added, removed, then

+				added again. */

+				xQueueRegistry[ ux ].xHandle = ( QueueHandle_t ) 0;

 				break;

 			}

 			else

@@ -2401,7 +2732,7 @@ BaseType_t xReturn;
 

 	void vQueueWaitForMessageRestricted( QueueHandle_t xQueue, TickType_t xTicksToWait, const BaseType_t xWaitIndefinitely )

 	{

-	Queue_t * const pxQueue = ( Queue_t * ) xQueue;

+	Queue_t * const pxQueue = xQueue;

 

 		/* This function should not be called by application code hence the

 		'Restricted' in its name.  It is not part of the public API.  It is

@@ -2433,13 +2764,13 @@ BaseType_t xReturn;
 #endif /* configUSE_TIMERS */

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

 

-#if ( configUSE_QUEUE_SETS == 1 )

+#if( ( configUSE_QUEUE_SETS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )

 

 	QueueSetHandle_t xQueueCreateSet( const UBaseType_t uxEventQueueLength )

 	{

 	QueueSetHandle_t pxQueue;

 

-		pxQueue = xQueueGenericCreate( uxEventQueueLength, sizeof( Queue_t * ), queueQUEUE_TYPE_SET );

+		pxQueue = xQueueGenericCreate( uxEventQueueLength, ( UBaseType_t ) sizeof( Queue_t * ), queueQUEUE_TYPE_SET );

 

 		return pxQueue;

 	}

@@ -2522,7 +2853,7 @@ BaseType_t xReturn;
 	{

 	QueueSetMemberHandle_t xReturn = NULL;

 

-		( void ) xQueueGenericReceive( ( QueueHandle_t ) xQueueSet, &xReturn, xTicksToWait, pdFALSE ); /*lint !e961 Casting from one typedef to another is not redundant. */

+		( void ) xQueueReceive( ( QueueHandle_t ) xQueueSet, &xReturn, xTicksToWait ); /*lint !e961 Casting from one typedef to another is not redundant. */

 		return xReturn;

 	}

 

@@ -2556,12 +2887,14 @@ BaseType_t xReturn;
 

 		if( pxQueueSetContainer->uxMessagesWaiting < pxQueueSetContainer->uxLength )

 		{

+			const int8_t cTxLock = pxQueueSetContainer->cTxLock;

+

 			traceQUEUE_SEND( pxQueueSetContainer );

 

 			/* The data copied is the handle of the queue that contains data. */

 			xReturn = prvCopyDataToQueue( pxQueueSetContainer, &pxQueue, xCopyPosition );

 

-			if( pxQueueSetContainer->xTxLock == queueUNLOCKED )

+			if( cTxLock == queueUNLOCKED )

 			{

 				if( listLIST_IS_EMPTY( &( pxQueueSetContainer->xTasksWaitingToReceive ) ) == pdFALSE )

 				{

@@ -2582,7 +2915,7 @@ BaseType_t xReturn;
 			}

 			else

 			{

-				( pxQueueSetContainer->xTxLock )++;

+				pxQueueSetContainer->cTxLock = ( int8_t ) ( cTxLock + 1 );

 			}

 		}

 		else

diff --git a/src/FreeRTOS/Source/stream_buffer.c b/src/FreeRTOS/Source/stream_buffer.c
new file mode 100644
index 0000000..6f5c29e
--- /dev/null
+++ b/src/FreeRTOS/Source/stream_buffer.c
@@ -0,0 +1,1263 @@
+/*

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

+

+/* Standard includes. */

+#include <stdint.h>

+#include <string.h>

+

+/* Defining MPU_WRAPPERS_INCLUDED_FROM_API_FILE prevents task.h from redefining

+all the API functions to use the MPU wrappers.  That should only be done when

+task.h is included from an application file. */

+#define MPU_WRAPPERS_INCLUDED_FROM_API_FILE

+

+/* FreeRTOS includes. */

+#include "FreeRTOS.h"

+#include "task.h"

+#include "stream_buffer.h"

+

+#if( configUSE_TASK_NOTIFICATIONS != 1 )

+	#error configUSE_TASK_NOTIFICATIONS must be set to 1 to build stream_buffer.c

+#endif

+

+/* Lint e961, e9021 and e750 are suppressed as a MISRA exception justified

+because the MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined

+for the header files above, but not in this file, in order to generate the

+correct privileged Vs unprivileged linkage and placement. */

+#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750 !e9021. */

+

+/* If the user has not provided application specific Rx notification macros,

+or #defined the notification macros away, them provide default implementations

+that uses task notifications. */

+/*lint -save -e9026 Function like macros allowed and needed here so they can be overidden. */

+#ifndef sbRECEIVE_COMPLETED

+	#define sbRECEIVE_COMPLETED( pxStreamBuffer )										\

+		vTaskSuspendAll();																\

+		{																				\

+			if( ( pxStreamBuffer )->xTaskWaitingToSend != NULL )						\

+			{																			\

+				( void ) xTaskNotify( ( pxStreamBuffer )->xTaskWaitingToSend,			\

+									  ( uint32_t ) 0,									\

+									  eNoAction );										\

+				( pxStreamBuffer )->xTaskWaitingToSend = NULL;							\

+			}																			\

+		}																				\

+		( void ) xTaskResumeAll();

+#endif /* sbRECEIVE_COMPLETED */

+

+#ifndef sbRECEIVE_COMPLETED_FROM_ISR

+	#define sbRECEIVE_COMPLETED_FROM_ISR( pxStreamBuffer,								\

+										  pxHigherPriorityTaskWoken )					\

+	{																					\

+	UBaseType_t uxSavedInterruptStatus;													\

+																						\

+		uxSavedInterruptStatus = ( UBaseType_t ) portSET_INTERRUPT_MASK_FROM_ISR();		\

+		{																				\

+			if( ( pxStreamBuffer )->xTaskWaitingToSend != NULL )						\

+			{																			\

+				( void ) xTaskNotifyFromISR( ( pxStreamBuffer )->xTaskWaitingToSend,	\

+											 ( uint32_t ) 0,							\

+											 eNoAction,									\

+											 pxHigherPriorityTaskWoken );				\

+				( pxStreamBuffer )->xTaskWaitingToSend = NULL;							\

+			}																			\

+		}																				\

+		portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );					\

+	}

+#endif /* sbRECEIVE_COMPLETED_FROM_ISR */

+

+/* If the user has not provided an application specific Tx notification macro,

+or #defined the notification macro away, them provide a default implementation

+that uses task notifications. */

+#ifndef sbSEND_COMPLETED

+	#define sbSEND_COMPLETED( pxStreamBuffer )											\

+		vTaskSuspendAll();																\

+		{																				\

+			if( ( pxStreamBuffer )->xTaskWaitingToReceive != NULL )						\

+			{																			\

+				( void ) xTaskNotify( ( pxStreamBuffer )->xTaskWaitingToReceive,		\

+									  ( uint32_t ) 0,									\

+									  eNoAction );										\

+				( pxStreamBuffer )->xTaskWaitingToReceive = NULL;						\

+			}																			\

+		}																				\

+		( void ) xTaskResumeAll();

+#endif /* sbSEND_COMPLETED */

+

+#ifndef sbSEND_COMPLETE_FROM_ISR

+	#define sbSEND_COMPLETE_FROM_ISR( pxStreamBuffer, pxHigherPriorityTaskWoken )		\

+	{																					\

+	UBaseType_t uxSavedInterruptStatus;													\

+																						\

+		uxSavedInterruptStatus = ( UBaseType_t ) portSET_INTERRUPT_MASK_FROM_ISR();		\

+		{																				\

+			if( ( pxStreamBuffer )->xTaskWaitingToReceive != NULL )						\

+			{																			\

+				( void ) xTaskNotifyFromISR( ( pxStreamBuffer )->xTaskWaitingToReceive,	\

+											 ( uint32_t ) 0,							\

+											 eNoAction,									\

+											 pxHigherPriorityTaskWoken );				\

+				( pxStreamBuffer )->xTaskWaitingToReceive = NULL;						\

+			}																			\

+		}																				\

+		portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );					\

+	}

+#endif /* sbSEND_COMPLETE_FROM_ISR */

+/*lint -restore (9026) */

+

+/* The number of bytes used to hold the length of a message in the buffer. */

+#define sbBYTES_TO_STORE_MESSAGE_LENGTH ( sizeof( configMESSAGE_BUFFER_LENGTH_TYPE ) )

+

+/* Bits stored in the ucFlags field of the stream buffer. */

+#define sbFLAGS_IS_MESSAGE_BUFFER		( ( uint8_t ) 1 ) /* Set if the stream buffer was created as a message buffer, in which case it holds discrete messages rather than a stream. */

+#define sbFLAGS_IS_STATICALLY_ALLOCATED ( ( uint8_t ) 2 ) /* Set if the stream buffer was created using statically allocated memory. */

+

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

+

+/* Structure that hold state information on the buffer. */

+typedef struct StreamBufferDef_t /*lint !e9058 Style convention uses tag. */

+{

+	volatile size_t xTail;				/* Index to the next item to read within the buffer. */

+	volatile size_t xHead;				/* Index to the next item to write within the buffer. */

+	size_t xLength;						/* The length of the buffer pointed to by pucBuffer. */

+	size_t xTriggerLevelBytes;			/* The number of bytes that must be in the stream buffer before a task that is waiting for data is unblocked. */

+	volatile TaskHandle_t xTaskWaitingToReceive; /* Holds the handle of a task waiting for data, or NULL if no tasks are waiting. */

+	volatile TaskHandle_t xTaskWaitingToSend;	/* Holds the handle of a task waiting to send data to a message buffer that is full. */

+	uint8_t *pucBuffer;					/* Points to the buffer itself - that is - the RAM that stores the data passed through the buffer. */

+	uint8_t ucFlags;

+

+	#if ( configUSE_TRACE_FACILITY == 1 )

+		UBaseType_t uxStreamBufferNumber;		/* Used for tracing purposes. */

+	#endif

+} StreamBuffer_t;

+

+/*

+ * The number of bytes available to be read from the buffer.

+ */

+static size_t prvBytesInBuffer( const StreamBuffer_t * const pxStreamBuffer ) PRIVILEGED_FUNCTION;

+

+/*

+ * Add xCount bytes from pucData into the pxStreamBuffer message buffer.

+ * Returns the number of bytes written, which will either equal xCount in the

+ * success case, or 0 if there was not enough space in the buffer (in which case

+ * no data is written into the buffer).

+ */

+static size_t prvWriteBytesToBuffer( StreamBuffer_t * const pxStreamBuffer, const uint8_t *pucData, size_t xCount ) PRIVILEGED_FUNCTION;

+

+/*

+ * If the stream buffer is being used as a message buffer, then reads an entire

+ * message out of the buffer.  If the stream buffer is being used as a stream

+ * buffer then read as many bytes as possible from the buffer.

+ * prvReadBytesFromBuffer() is called to actually extract the bytes from the

+ * buffer's data storage area.

+ */

+static size_t prvReadMessageFromBuffer( StreamBuffer_t *pxStreamBuffer,

+										void *pvRxData,

+										size_t xBufferLengthBytes,

+										size_t xBytesAvailable,

+										size_t xBytesToStoreMessageLength ) PRIVILEGED_FUNCTION;

+

+/*

+ * If the stream buffer is being used as a message buffer, then writes an entire

+ * message to the buffer.  If the stream buffer is being used as a stream

+ * buffer then write as many bytes as possible to the buffer.

+ * prvWriteBytestoBuffer() is called to actually send the bytes to the buffer's

+ * data storage area.

+ */

+static size_t prvWriteMessageToBuffer(  StreamBuffer_t * const pxStreamBuffer,

+										const void * pvTxData,

+										size_t xDataLengthBytes,

+										size_t xSpace,

+										size_t xRequiredSpace ) PRIVILEGED_FUNCTION;

+

+/*

+ * Read xMaxCount bytes from the pxStreamBuffer message buffer and write them

+ * to pucData.

+ */

+static size_t prvReadBytesFromBuffer( StreamBuffer_t *pxStreamBuffer,

+									  uint8_t *pucData,

+									  size_t xMaxCount,

+									  size_t xBytesAvailable ) PRIVILEGED_FUNCTION;

+

+/*

+ * Called by both pxStreamBufferCreate() and pxStreamBufferCreateStatic() to

+ * initialise the members of the newly created stream buffer structure.

+ */

+static void prvInitialiseNewStreamBuffer( StreamBuffer_t * const pxStreamBuffer,

+										  uint8_t * const pucBuffer,

+										  size_t xBufferSizeBytes,

+										  size_t xTriggerLevelBytes,

+										  uint8_t ucFlags ) PRIVILEGED_FUNCTION;

+

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

+

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

+

+	StreamBufferHandle_t xStreamBufferGenericCreate( size_t xBufferSizeBytes, size_t xTriggerLevelBytes, BaseType_t xIsMessageBuffer )

+	{

+	uint8_t *pucAllocatedMemory;

+	uint8_t ucFlags;

+

+		/* In case the stream buffer is going to be used as a message buffer

+		(that is, it will hold discrete messages with a little meta data that

+		says how big the next message is) check the buffer will be large enough

+		to hold at least one message. */

+		if( xIsMessageBuffer == pdTRUE )

+		{

+			/* Is a message buffer but not statically allocated. */

+			ucFlags = sbFLAGS_IS_MESSAGE_BUFFER;

+			configASSERT( xBufferSizeBytes > sbBYTES_TO_STORE_MESSAGE_LENGTH );

+		}

+		else

+		{

+			/* Not a message buffer and not statically allocated. */

+			ucFlags = 0;

+			configASSERT( xBufferSizeBytes > 0 );

+		}

+		configASSERT( xTriggerLevelBytes <= xBufferSizeBytes );

+

+		/* A trigger level of 0 would cause a waiting task to unblock even when

+		the buffer was empty. */

+		if( xTriggerLevelBytes == ( size_t ) 0 )

+		{

+			xTriggerLevelBytes = ( size_t ) 1;

+		}

+

+		/* A stream buffer requires a StreamBuffer_t structure and a buffer.

+		Both are allocated in a single call to pvPortMalloc().  The

+		StreamBuffer_t structure is placed at the start of the allocated memory

+		and the buffer follows immediately after.  The requested size is

+		incremented so the free space is returned as the user would expect -

+		this is a quirk of the implementation that means otherwise the free

+		space would be reported as one byte smaller than would be logically

+		expected. */

+		xBufferSizeBytes++;

+		pucAllocatedMemory = ( uint8_t * ) pvPortMalloc( xBufferSizeBytes + sizeof( StreamBuffer_t ) ); /*lint !e9079 malloc() only returns void*. */

+

+		if( pucAllocatedMemory != NULL )

+		{

+			prvInitialiseNewStreamBuffer( ( StreamBuffer_t * ) pucAllocatedMemory, /* Structure at the start of the allocated memory. */ /*lint !e9087 Safe cast as allocated memory is aligned. */ /*lint !e826 Area is not too small and alignment is guaranteed provided malloc() behaves as expected and returns aligned buffer. */

+										   pucAllocatedMemory + sizeof( StreamBuffer_t ),  /* Storage area follows. */ /*lint !e9016 Indexing past structure valid for uint8_t pointer, also storage area has no alignment requirement. */

+										   xBufferSizeBytes,

+										   xTriggerLevelBytes,

+										   ucFlags );

+

+			traceSTREAM_BUFFER_CREATE( ( ( StreamBuffer_t * ) pucAllocatedMemory ), xIsMessageBuffer );

+		}

+		else

+		{

+			traceSTREAM_BUFFER_CREATE_FAILED( xIsMessageBuffer );

+		}

+

+		return ( StreamBufferHandle_t ) pucAllocatedMemory; /*lint !e9087 !e826 Safe cast as allocated memory is aligned. */

+	}

+

+#endif /* configSUPPORT_DYNAMIC_ALLOCATION */

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

+

+#if( configSUPPORT_STATIC_ALLOCATION == 1 )

+

+	StreamBufferHandle_t xStreamBufferGenericCreateStatic( size_t xBufferSizeBytes,

+														   size_t xTriggerLevelBytes,

+														   BaseType_t xIsMessageBuffer,

+														   uint8_t * const pucStreamBufferStorageArea,

+														   StaticStreamBuffer_t * const pxStaticStreamBuffer )

+	{

+	StreamBuffer_t * const pxStreamBuffer = ( StreamBuffer_t * ) pxStaticStreamBuffer; /*lint !e740 !e9087 Safe cast as StaticStreamBuffer_t is opaque Streambuffer_t. */

+	StreamBufferHandle_t xReturn;

+	uint8_t ucFlags;

+

+		configASSERT( pucStreamBufferStorageArea );

+		configASSERT( pxStaticStreamBuffer );

+		configASSERT( xTriggerLevelBytes <= xBufferSizeBytes );

+

+		/* A trigger level of 0 would cause a waiting task to unblock even when

+		the buffer was empty. */

+		if( xTriggerLevelBytes == ( size_t ) 0 )

+		{

+			xTriggerLevelBytes = ( size_t ) 1;

+		}

+

+		if( xIsMessageBuffer != pdFALSE )

+		{

+			/* Statically allocated message buffer. */

+			ucFlags = sbFLAGS_IS_MESSAGE_BUFFER | sbFLAGS_IS_STATICALLY_ALLOCATED;

+		}

+		else

+		{

+			/* Statically allocated stream buffer. */

+			ucFlags = sbFLAGS_IS_STATICALLY_ALLOCATED;

+		}

+

+		/* In case the stream buffer is going to be used as a message buffer

+		(that is, it will hold discrete messages with a little meta data that

+		says how big the next message is) check the buffer will be large enough

+		to hold at least one message. */

+		configASSERT( xBufferSizeBytes > sbBYTES_TO_STORE_MESSAGE_LENGTH );

+

+		#if( configASSERT_DEFINED == 1 )

+		{

+			/* Sanity check that the size of the structure used to declare a

+			variable of type StaticStreamBuffer_t equals the size of the real

+			message buffer structure. */

+			volatile size_t xSize = sizeof( StaticStreamBuffer_t );

+			configASSERT( xSize == sizeof( StreamBuffer_t ) );

+		} /*lint !e529 xSize is referenced is configASSERT() is defined. */

+		#endif /* configASSERT_DEFINED */

+

+		if( ( pucStreamBufferStorageArea != NULL ) && ( pxStaticStreamBuffer != NULL ) )

+		{

+			prvInitialiseNewStreamBuffer( pxStreamBuffer,

+										  pucStreamBufferStorageArea,

+										  xBufferSizeBytes,

+										  xTriggerLevelBytes,

+										  ucFlags );

+

+			/* Remember this was statically allocated in case it is ever deleted

+			again. */

+			pxStreamBuffer->ucFlags |= sbFLAGS_IS_STATICALLY_ALLOCATED;

+

+			traceSTREAM_BUFFER_CREATE( pxStreamBuffer, xIsMessageBuffer );

+

+			xReturn = ( StreamBufferHandle_t ) pxStaticStreamBuffer; /*lint !e9087 Data hiding requires cast to opaque type. */

+		}

+		else

+		{

+			xReturn = NULL;

+			traceSTREAM_BUFFER_CREATE_STATIC_FAILED( xReturn, xIsMessageBuffer );

+		}

+

+		return xReturn;

+	}

+

+#endif /* ( configSUPPORT_STATIC_ALLOCATION == 1 ) */

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

+

+void vStreamBufferDelete( StreamBufferHandle_t xStreamBuffer )

+{

+StreamBuffer_t * pxStreamBuffer = xStreamBuffer;

+

+	configASSERT( pxStreamBuffer );

+

+	traceSTREAM_BUFFER_DELETE( xStreamBuffer );

+

+	if( ( pxStreamBuffer->ucFlags & sbFLAGS_IS_STATICALLY_ALLOCATED ) == ( uint8_t ) pdFALSE )

+	{

+		#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

+		{

+			/* Both the structure and the buffer were allocated using a single call

+			to pvPortMalloc(), hence only one call to vPortFree() is required. */

+			vPortFree( ( void * ) pxStreamBuffer ); /*lint !e9087 Standard free() semantics require void *, plus pxStreamBuffer was allocated by pvPortMalloc(). */

+		}

+		#else

+		{

+			/* Should not be possible to get here, ucFlags must be corrupt.

+			Force an assert. */

+			configASSERT( xStreamBuffer == ( StreamBufferHandle_t ) ~0 );

+		}

+		#endif

+	}

+	else

+	{

+		/* The structure and buffer were not allocated dynamically and cannot be

+		freed - just scrub the structure so future use will assert. */

+		( void ) memset( pxStreamBuffer, 0x00, sizeof( StreamBuffer_t ) );

+	}

+}

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

+

+BaseType_t xStreamBufferReset( StreamBufferHandle_t xStreamBuffer )

+{

+StreamBuffer_t * const pxStreamBuffer = xStreamBuffer;

+BaseType_t xReturn = pdFAIL;

+

+#if( configUSE_TRACE_FACILITY == 1 )

+	UBaseType_t uxStreamBufferNumber;

+#endif

+

+	configASSERT( pxStreamBuffer );

+

+	#if( configUSE_TRACE_FACILITY == 1 )

+	{

+		/* Store the stream buffer number so it can be restored after the

+		reset. */

+		uxStreamBufferNumber = pxStreamBuffer->uxStreamBufferNumber;

+	}

+	#endif

+

+	/* Can only reset a message buffer if there are no tasks blocked on it. */

+	taskENTER_CRITICAL();

+	{

+		if( pxStreamBuffer->xTaskWaitingToReceive == NULL )

+		{

+			if( pxStreamBuffer->xTaskWaitingToSend == NULL )

+			{

+				prvInitialiseNewStreamBuffer( pxStreamBuffer,

+											  pxStreamBuffer->pucBuffer,

+											  pxStreamBuffer->xLength,

+											  pxStreamBuffer->xTriggerLevelBytes,

+											  pxStreamBuffer->ucFlags );

+				xReturn = pdPASS;

+

+				#if( configUSE_TRACE_FACILITY == 1 )

+				{

+					pxStreamBuffer->uxStreamBufferNumber = uxStreamBufferNumber;

+				}

+				#endif

+

+				traceSTREAM_BUFFER_RESET( xStreamBuffer );

+			}

+		}

+	}

+	taskEXIT_CRITICAL();

+

+	return xReturn;

+}

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

+

+BaseType_t xStreamBufferSetTriggerLevel( StreamBufferHandle_t xStreamBuffer, size_t xTriggerLevel )

+{

+StreamBuffer_t * const pxStreamBuffer = xStreamBuffer;

+BaseType_t xReturn;

+

+	configASSERT( pxStreamBuffer );

+

+	/* It is not valid for the trigger level to be 0. */

+	if( xTriggerLevel == ( size_t ) 0 )

+	{

+		xTriggerLevel = ( size_t ) 1;

+	}

+

+	/* The trigger level is the number of bytes that must be in the stream

+	buffer before a task that is waiting for data is unblocked. */

+	if( xTriggerLevel <= pxStreamBuffer->xLength )

+	{

+		pxStreamBuffer->xTriggerLevelBytes = xTriggerLevel;

+		xReturn = pdPASS;

+	}

+	else

+	{

+		xReturn = pdFALSE;

+	}

+

+	return xReturn;

+}

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

+

+size_t xStreamBufferSpacesAvailable( StreamBufferHandle_t xStreamBuffer )

+{

+const StreamBuffer_t * const pxStreamBuffer = xStreamBuffer;

+size_t xSpace;

+

+	configASSERT( pxStreamBuffer );

+

+	xSpace = pxStreamBuffer->xLength + pxStreamBuffer->xTail;

+	xSpace -= pxStreamBuffer->xHead;

+	xSpace -= ( size_t ) 1;

+

+	if( xSpace >= pxStreamBuffer->xLength )

+	{

+		xSpace -= pxStreamBuffer->xLength;

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

+

+	return xSpace;

+}

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

+

+size_t xStreamBufferBytesAvailable( StreamBufferHandle_t xStreamBuffer )

+{

+const StreamBuffer_t * const pxStreamBuffer = xStreamBuffer;

+size_t xReturn;

+

+	configASSERT( pxStreamBuffer );

+

+	xReturn = prvBytesInBuffer( pxStreamBuffer );

+	return xReturn;

+}

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

+

+size_t xStreamBufferSend( StreamBufferHandle_t xStreamBuffer,

+						  const void *pvTxData,

+						  size_t xDataLengthBytes,

+						  TickType_t xTicksToWait )

+{

+StreamBuffer_t * const pxStreamBuffer = xStreamBuffer;

+size_t xReturn, xSpace = 0;

+size_t xRequiredSpace = xDataLengthBytes;

+TimeOut_t xTimeOut;

+

+	configASSERT( pvTxData );

+	configASSERT( pxStreamBuffer );

+

+	/* This send function is used to write to both message buffers and stream

+	buffers.  If this is a message buffer then the space needed must be

+	increased by the amount of bytes needed to store the length of the

+	message. */

+	if( ( pxStreamBuffer->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER ) != ( uint8_t ) 0 )

+	{

+		xRequiredSpace += sbBYTES_TO_STORE_MESSAGE_LENGTH;

+

+		/* Overflow? */

+		configASSERT( xRequiredSpace > xDataLengthBytes );

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

+

+	if( xTicksToWait != ( TickType_t ) 0 )

+	{

+		vTaskSetTimeOutState( &xTimeOut );

+

+		do

+		{

+			/* Wait until the required number of bytes are free in the message

+			buffer. */

+			taskENTER_CRITICAL();

+			{

+				xSpace = xStreamBufferSpacesAvailable( pxStreamBuffer );

+

+				if( xSpace < xRequiredSpace )

+				{

+					/* Clear notification state as going to wait for space. */

+					( void ) xTaskNotifyStateClear( NULL );

+

+					/* Should only be one writer. */

+					configASSERT( pxStreamBuffer->xTaskWaitingToSend == NULL );

+					pxStreamBuffer->xTaskWaitingToSend = xTaskGetCurrentTaskHandle();

+				}

+				else

+				{

+					taskEXIT_CRITICAL();

+					break;

+				}

+			}

+			taskEXIT_CRITICAL();

+

+			traceBLOCKING_ON_STREAM_BUFFER_SEND( xStreamBuffer );

+			( void ) xTaskNotifyWait( ( uint32_t ) 0, ( uint32_t ) 0, NULL, xTicksToWait );

+			pxStreamBuffer->xTaskWaitingToSend = NULL;

+

+		} while( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) == pdFALSE );

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

+

+	if( xSpace == ( size_t ) 0 )

+	{

+		xSpace = xStreamBufferSpacesAvailable( pxStreamBuffer );

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

+

+	xReturn = prvWriteMessageToBuffer( pxStreamBuffer, pvTxData, xDataLengthBytes, xSpace, xRequiredSpace );

+

+	if( xReturn > ( size_t ) 0 )

+	{

+		traceSTREAM_BUFFER_SEND( xStreamBuffer, xReturn );

+

+		/* Was a task waiting for the data? */

+		if( prvBytesInBuffer( pxStreamBuffer ) >= pxStreamBuffer->xTriggerLevelBytes )

+		{

+			sbSEND_COMPLETED( pxStreamBuffer );

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+		traceSTREAM_BUFFER_SEND_FAILED( xStreamBuffer );

+	}

+

+	return xReturn;

+}

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

+

+size_t xStreamBufferSendFromISR( StreamBufferHandle_t xStreamBuffer,

+								 const void *pvTxData,

+								 size_t xDataLengthBytes,

+								 BaseType_t * const pxHigherPriorityTaskWoken )

+{

+StreamBuffer_t * const pxStreamBuffer = xStreamBuffer;

+size_t xReturn, xSpace;

+size_t xRequiredSpace = xDataLengthBytes;

+

+	configASSERT( pvTxData );

+	configASSERT( pxStreamBuffer );

+

+	/* This send function is used to write to both message buffers and stream

+	buffers.  If this is a message buffer then the space needed must be

+	increased by the amount of bytes needed to store the length of the

+	message. */

+	if( ( pxStreamBuffer->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER ) != ( uint8_t ) 0 )

+	{

+		xRequiredSpace += sbBYTES_TO_STORE_MESSAGE_LENGTH;

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

+

+	xSpace = xStreamBufferSpacesAvailable( pxStreamBuffer );

+	xReturn = prvWriteMessageToBuffer( pxStreamBuffer, pvTxData, xDataLengthBytes, xSpace, xRequiredSpace );

+

+	if( xReturn > ( size_t ) 0 )

+	{

+		/* Was a task waiting for the data? */

+		if( prvBytesInBuffer( pxStreamBuffer ) >= pxStreamBuffer->xTriggerLevelBytes )

+		{

+			sbSEND_COMPLETE_FROM_ISR( pxStreamBuffer, pxHigherPriorityTaskWoken );

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

+

+	traceSTREAM_BUFFER_SEND_FROM_ISR( xStreamBuffer, xReturn );

+

+	return xReturn;

+}

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

+

+static size_t prvWriteMessageToBuffer( StreamBuffer_t * const pxStreamBuffer,

+									   const void * pvTxData,

+									   size_t xDataLengthBytes,

+									   size_t xSpace,

+									   size_t xRequiredSpace )

+{

+	BaseType_t xShouldWrite;

+	size_t xReturn;

+

+	if( xSpace == ( size_t ) 0 )

+	{

+		/* Doesn't matter if this is a stream buffer or a message buffer, there

+		is no space to write. */

+		xShouldWrite = pdFALSE;

+	}

+	else if( ( pxStreamBuffer->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER ) == ( uint8_t ) 0 )

+	{

+		/* This is a stream buffer, as opposed to a message buffer, so writing a

+		stream of bytes rather than discrete messages.  Write as many bytes as

+		possible. */

+		xShouldWrite = pdTRUE;

+		xDataLengthBytes = configMIN( xDataLengthBytes, xSpace );

+	}

+	else if( xSpace >= xRequiredSpace )

+	{

+		/* This is a message buffer, as opposed to a stream buffer, and there

+		is enough space to write both the message length and the message itself

+		into the buffer.  Start by writing the length of the data, the data

+		itself will be written later in this function. */

+		xShouldWrite = pdTRUE;

+		( void ) prvWriteBytesToBuffer( pxStreamBuffer, ( const uint8_t * ) &( xDataLengthBytes ), sbBYTES_TO_STORE_MESSAGE_LENGTH );

+	}

+	else

+	{

+		/* There is space available, but not enough space. */

+		xShouldWrite = pdFALSE;

+	}

+

+	if( xShouldWrite != pdFALSE )

+	{

+		/* Writes the data itself. */

+		xReturn = prvWriteBytesToBuffer( pxStreamBuffer, ( const uint8_t * ) pvTxData, xDataLengthBytes ); /*lint !e9079 Storage buffer is implemented as uint8_t for ease of sizing, alighment and access. */

+	}

+	else

+	{

+		xReturn = 0;

+	}

+

+	return xReturn;

+}

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

+

+size_t xStreamBufferReceive( StreamBufferHandle_t xStreamBuffer,

+							 void *pvRxData,

+							 size_t xBufferLengthBytes,

+							 TickType_t xTicksToWait )

+{

+StreamBuffer_t * const pxStreamBuffer = xStreamBuffer;

+size_t xReceivedLength = 0, xBytesAvailable, xBytesToStoreMessageLength;

+

+	configASSERT( pvRxData );

+	configASSERT( pxStreamBuffer );

+

+	/* This receive function is used by both message buffers, which store

+	discrete messages, and stream buffers, which store a continuous stream of

+	bytes.  Discrete messages include an additional

+	sbBYTES_TO_STORE_MESSAGE_LENGTH bytes that hold the length of the

+	message. */

+	if( ( pxStreamBuffer->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER ) != ( uint8_t ) 0 )

+	{

+		xBytesToStoreMessageLength = sbBYTES_TO_STORE_MESSAGE_LENGTH;

+	}

+	else

+	{

+		xBytesToStoreMessageLength = 0;

+	}

+

+	if( xTicksToWait != ( TickType_t ) 0 )

+	{

+		/* Checking if there is data and clearing the notification state must be

+		performed atomically. */

+		taskENTER_CRITICAL();

+		{

+			xBytesAvailable = prvBytesInBuffer( pxStreamBuffer );

+

+			/* If this function was invoked by a message buffer read then

+			xBytesToStoreMessageLength holds the number of bytes used to hold

+			the length of the next discrete message.  If this function was

+			invoked by a stream buffer read then xBytesToStoreMessageLength will

+			be 0. */

+			if( xBytesAvailable <= xBytesToStoreMessageLength )

+			{

+				/* Clear notification state as going to wait for data. */

+				( void ) xTaskNotifyStateClear( NULL );

+

+				/* Should only be one reader. */

+				configASSERT( pxStreamBuffer->xTaskWaitingToReceive == NULL );

+				pxStreamBuffer->xTaskWaitingToReceive = xTaskGetCurrentTaskHandle();

+			}

+			else

+			{

+				mtCOVERAGE_TEST_MARKER();

+			}

+		}

+		taskEXIT_CRITICAL();

+

+		if( xBytesAvailable <= xBytesToStoreMessageLength )

+		{

+			/* Wait for data to be available. */

+			traceBLOCKING_ON_STREAM_BUFFER_RECEIVE( xStreamBuffer );

+			( void ) xTaskNotifyWait( ( uint32_t ) 0, ( uint32_t ) 0, NULL, xTicksToWait );

+			pxStreamBuffer->xTaskWaitingToReceive = NULL;

+

+			/* Recheck the data available after blocking. */

+			xBytesAvailable = prvBytesInBuffer( pxStreamBuffer );

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+	}

+	else

+	{

+		xBytesAvailable = prvBytesInBuffer( pxStreamBuffer );

+	}

+

+	/* Whether receiving a discrete message (where xBytesToStoreMessageLength

+	holds the number of bytes used to store the message length) or a stream of

+	bytes (where xBytesToStoreMessageLength is zero), the number of bytes

+	available must be greater than xBytesToStoreMessageLength to be able to

+	read bytes from the buffer. */

+	if( xBytesAvailable > xBytesToStoreMessageLength )

+	{

+		xReceivedLength = prvReadMessageFromBuffer( pxStreamBuffer, pvRxData, xBufferLengthBytes, xBytesAvailable, xBytesToStoreMessageLength );

+

+		/* Was a task waiting for space in the buffer? */

+		if( xReceivedLength != ( size_t ) 0 )

+		{

+			traceSTREAM_BUFFER_RECEIVE( xStreamBuffer, xReceivedLength );

+			sbRECEIVE_COMPLETED( pxStreamBuffer );

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+	}

+	else

+	{

+		traceSTREAM_BUFFER_RECEIVE_FAILED( xStreamBuffer );

+		mtCOVERAGE_TEST_MARKER();

+	}

+

+	return xReceivedLength;

+}

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

+

+size_t xStreamBufferNextMessageLengthBytes( StreamBufferHandle_t xStreamBuffer )

+{

+StreamBuffer_t * const pxStreamBuffer = xStreamBuffer;

+size_t xReturn, xBytesAvailable, xOriginalTail;

+configMESSAGE_BUFFER_LENGTH_TYPE xTempReturn;

+

+	configASSERT( pxStreamBuffer );

+

+	/* Ensure the stream buffer is being used as a message buffer. */

+	if( ( pxStreamBuffer->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER ) != ( uint8_t ) 0 )

+	{

+		xBytesAvailable = prvBytesInBuffer( pxStreamBuffer );

+		if( xBytesAvailable > sbBYTES_TO_STORE_MESSAGE_LENGTH )

+		{

+			/* The number of bytes available is greater than the number of bytes

+			required to hold the length of the next message, so another message

+			is available.  Return its length without removing the length bytes

+			from the buffer.  A copy of the tail is stored so the buffer can be

+			returned to its prior state as the message is not actually being

+			removed from the buffer. */

+			xOriginalTail = pxStreamBuffer->xTail;

+			( void ) prvReadBytesFromBuffer( pxStreamBuffer, ( uint8_t * ) &xTempReturn, sbBYTES_TO_STORE_MESSAGE_LENGTH, xBytesAvailable );

+			xReturn = ( size_t ) xTempReturn;

+			pxStreamBuffer->xTail = xOriginalTail;

+		}

+		else

+		{

+			/* The minimum amount of bytes in a message buffer is

+			( sbBYTES_TO_STORE_MESSAGE_LENGTH + 1 ), so if xBytesAvailable is

+			less than sbBYTES_TO_STORE_MESSAGE_LENGTH the only other valid

+			value is 0. */

+			configASSERT( xBytesAvailable == 0 );

+			xReturn = 0;

+		}

+	}

+	else

+	{

+		xReturn = 0;

+	}

+

+	return xReturn;

+}

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

+

+size_t xStreamBufferReceiveFromISR( StreamBufferHandle_t xStreamBuffer,

+									void *pvRxData,

+									size_t xBufferLengthBytes,

+									BaseType_t * const pxHigherPriorityTaskWoken )

+{

+StreamBuffer_t * const pxStreamBuffer = xStreamBuffer;

+size_t xReceivedLength = 0, xBytesAvailable, xBytesToStoreMessageLength;

+

+	configASSERT( pvRxData );

+	configASSERT( pxStreamBuffer );

+

+	/* This receive function is used by both message buffers, which store

+	discrete messages, and stream buffers, which store a continuous stream of

+	bytes.  Discrete messages include an additional

+	sbBYTES_TO_STORE_MESSAGE_LENGTH bytes that hold the length of the

+	message. */

+	if( ( pxStreamBuffer->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER ) != ( uint8_t ) 0 )

+	{

+		xBytesToStoreMessageLength = sbBYTES_TO_STORE_MESSAGE_LENGTH;

+	}

+	else

+	{

+		xBytesToStoreMessageLength = 0;

+	}

+

+	xBytesAvailable = prvBytesInBuffer( pxStreamBuffer );

+

+	/* Whether receiving a discrete message (where xBytesToStoreMessageLength

+	holds the number of bytes used to store the message length) or a stream of

+	bytes (where xBytesToStoreMessageLength is zero), the number of bytes

+	available must be greater than xBytesToStoreMessageLength to be able to

+	read bytes from the buffer. */

+	if( xBytesAvailable > xBytesToStoreMessageLength )

+	{

+		xReceivedLength = prvReadMessageFromBuffer( pxStreamBuffer, pvRxData, xBufferLengthBytes, xBytesAvailable, xBytesToStoreMessageLength );

+

+		/* Was a task waiting for space in the buffer? */

+		if( xReceivedLength != ( size_t ) 0 )

+		{

+			sbRECEIVE_COMPLETED_FROM_ISR( pxStreamBuffer, pxHigherPriorityTaskWoken );

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

+

+	traceSTREAM_BUFFER_RECEIVE_FROM_ISR( xStreamBuffer, xReceivedLength );

+

+	return xReceivedLength;

+}

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

+

+static size_t prvReadMessageFromBuffer( StreamBuffer_t *pxStreamBuffer,

+										void *pvRxData,

+										size_t xBufferLengthBytes,

+										size_t xBytesAvailable,

+										size_t xBytesToStoreMessageLength )

+{

+size_t xOriginalTail, xReceivedLength, xNextMessageLength;

+configMESSAGE_BUFFER_LENGTH_TYPE xTempNextMessageLength;

+

+	if( xBytesToStoreMessageLength != ( size_t ) 0 )

+	{

+		/* A discrete message is being received.  First receive the length

+		of the message.  A copy of the tail is stored so the buffer can be

+		returned to its prior state if the length of the message is too

+		large for the provided buffer. */

+		xOriginalTail = pxStreamBuffer->xTail;

+		( void ) prvReadBytesFromBuffer( pxStreamBuffer, ( uint8_t * ) &xTempNextMessageLength, xBytesToStoreMessageLength, xBytesAvailable );

+		xNextMessageLength = ( size_t ) xTempNextMessageLength;

+

+		/* Reduce the number of bytes available by the number of bytes just

+		read out. */

+		xBytesAvailable -= xBytesToStoreMessageLength;

+

+		/* Check there is enough space in the buffer provided by the

+		user. */

+		if( xNextMessageLength > xBufferLengthBytes )

+		{

+			/* The user has provided insufficient space to read the message

+			so return the buffer to its previous state (so the length of

+			the message is in the buffer again). */

+			pxStreamBuffer->xTail = xOriginalTail;

+			xNextMessageLength = 0;

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+	}

+	else

+	{

+		/* A stream of bytes is being received (as opposed to a discrete

+		message), so read as many bytes as possible. */

+		xNextMessageLength = xBufferLengthBytes;

+	}

+

+	/* Read the actual data. */

+	xReceivedLength = prvReadBytesFromBuffer( pxStreamBuffer, ( uint8_t * ) pvRxData, xNextMessageLength, xBytesAvailable ); /*lint !e9079 Data storage area is implemented as uint8_t array for ease of sizing, indexing and alignment. */

+

+	return xReceivedLength;

+}

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

+

+BaseType_t xStreamBufferIsEmpty( StreamBufferHandle_t xStreamBuffer )

+{

+const StreamBuffer_t * const pxStreamBuffer = xStreamBuffer;

+BaseType_t xReturn;

+size_t xTail;

+

+	configASSERT( pxStreamBuffer );

+

+	/* True if no bytes are available. */

+	xTail = pxStreamBuffer->xTail;

+	if( pxStreamBuffer->xHead == xTail )

+	{

+		xReturn = pdTRUE;

+	}

+	else

+	{

+		xReturn = pdFALSE;

+	}

+

+	return xReturn;

+}

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

+

+BaseType_t xStreamBufferIsFull( StreamBufferHandle_t xStreamBuffer )

+{

+BaseType_t xReturn;

+size_t xBytesToStoreMessageLength;

+const StreamBuffer_t * const pxStreamBuffer = xStreamBuffer;

+

+	configASSERT( pxStreamBuffer );

+

+	/* This generic version of the receive function is used by both message

+	buffers, which store discrete messages, and stream buffers, which store a

+	continuous stream of bytes.  Discrete messages include an additional

+	sbBYTES_TO_STORE_MESSAGE_LENGTH bytes that hold the length of the message. */

+	if( ( pxStreamBuffer->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER ) != ( uint8_t ) 0 )

+	{

+		xBytesToStoreMessageLength = sbBYTES_TO_STORE_MESSAGE_LENGTH;

+	}

+	else

+	{

+		xBytesToStoreMessageLength = 0;

+	}

+

+	/* True if the available space equals zero. */

+	if( xStreamBufferSpacesAvailable( xStreamBuffer ) <= xBytesToStoreMessageLength )

+	{

+		xReturn = pdTRUE;

+	}

+	else

+	{

+		xReturn = pdFALSE;

+	}

+

+	return xReturn;

+}

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

+

+BaseType_t xStreamBufferSendCompletedFromISR( StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken )

+{

+StreamBuffer_t * const pxStreamBuffer = xStreamBuffer;

+BaseType_t xReturn;

+UBaseType_t uxSavedInterruptStatus;

+

+	configASSERT( pxStreamBuffer );

+

+	uxSavedInterruptStatus = ( UBaseType_t ) portSET_INTERRUPT_MASK_FROM_ISR();

+	{

+		if( ( pxStreamBuffer )->xTaskWaitingToReceive != NULL )

+		{

+			( void ) xTaskNotifyFromISR( ( pxStreamBuffer )->xTaskWaitingToReceive,

+										 ( uint32_t ) 0,

+										 eNoAction,

+										 pxHigherPriorityTaskWoken );

+			( pxStreamBuffer )->xTaskWaitingToReceive = NULL;

+			xReturn = pdTRUE;

+		}

+		else

+		{

+			xReturn = pdFALSE;

+		}

+	}

+	portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );

+

+	return xReturn;

+}

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

+

+BaseType_t xStreamBufferReceiveCompletedFromISR( StreamBufferHandle_t xStreamBuffer, BaseType_t *pxHigherPriorityTaskWoken )

+{

+StreamBuffer_t * const pxStreamBuffer = xStreamBuffer;

+BaseType_t xReturn;

+UBaseType_t uxSavedInterruptStatus;

+

+	configASSERT( pxStreamBuffer );

+

+	uxSavedInterruptStatus = ( UBaseType_t ) portSET_INTERRUPT_MASK_FROM_ISR();

+	{

+		if( ( pxStreamBuffer )->xTaskWaitingToSend != NULL )

+		{

+			( void ) xTaskNotifyFromISR( ( pxStreamBuffer )->xTaskWaitingToSend,

+										 ( uint32_t ) 0,

+										 eNoAction,

+										 pxHigherPriorityTaskWoken );

+			( pxStreamBuffer )->xTaskWaitingToSend = NULL;

+			xReturn = pdTRUE;

+		}

+		else

+		{

+			xReturn = pdFALSE;

+		}

+	}

+	portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );

+

+	return xReturn;

+}

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

+

+static size_t prvWriteBytesToBuffer( StreamBuffer_t * const pxStreamBuffer, const uint8_t *pucData, size_t xCount )

+{

+size_t xNextHead, xFirstLength;

+

+	configASSERT( xCount > ( size_t ) 0 );

+

+	xNextHead = pxStreamBuffer->xHead;

+

+	/* Calculate the number of bytes that can be added in the first write -

+	which may be less than the total number of bytes that need to be added if

+	the buffer will wrap back to the beginning. */

+	xFirstLength = configMIN( pxStreamBuffer->xLength - xNextHead, xCount );

+

+	/* Write as many bytes as can be written in the first write. */

+	configASSERT( ( xNextHead + xFirstLength ) <= pxStreamBuffer->xLength );

+	( void ) memcpy( ( void* ) ( &( pxStreamBuffer->pucBuffer[ xNextHead ] ) ), ( const void * ) pucData, xFirstLength ); /*lint !e9087 memcpy() requires void *. */

+

+	/* If the number of bytes written was less than the number that could be

+	written in the first write... */

+	if( xCount > xFirstLength )

+	{

+		/* ...then write the remaining bytes to the start of the buffer. */

+		configASSERT( ( xCount - xFirstLength ) <= pxStreamBuffer->xLength );

+		( void ) memcpy( ( void * ) pxStreamBuffer->pucBuffer, ( const void * ) &( pucData[ xFirstLength ] ), xCount - xFirstLength ); /*lint !e9087 memcpy() requires void *. */

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

+

+	xNextHead += xCount;

+	if( xNextHead >= pxStreamBuffer->xLength )

+	{

+		xNextHead -= pxStreamBuffer->xLength;

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

+

+	pxStreamBuffer->xHead = xNextHead;

+

+	return xCount;

+}

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

+

+static size_t prvReadBytesFromBuffer( StreamBuffer_t *pxStreamBuffer, uint8_t *pucData, size_t xMaxCount, size_t xBytesAvailable )

+{

+size_t xCount, xFirstLength, xNextTail;

+

+	/* Use the minimum of the wanted bytes and the available bytes. */

+	xCount = configMIN( xBytesAvailable, xMaxCount );

+

+	if( xCount > ( size_t ) 0 )

+	{

+		xNextTail = pxStreamBuffer->xTail;

+

+		/* Calculate the number of bytes that can be read - which may be

+		less than the number wanted if the data wraps around to the start of

+		the buffer. */

+		xFirstLength = configMIN( pxStreamBuffer->xLength - xNextTail, xCount );

+

+		/* Obtain the number of bytes it is possible to obtain in the first

+		read.  Asserts check bounds of read and write. */

+		configASSERT( xFirstLength <= xMaxCount );

+		configASSERT( ( xNextTail + xFirstLength ) <= pxStreamBuffer->xLength );

+		( void ) memcpy( ( void * ) pucData, ( const void * ) &( pxStreamBuffer->pucBuffer[ xNextTail ] ), xFirstLength ); /*lint !e9087 memcpy() requires void *. */

+

+		/* If the total number of wanted bytes is greater than the number

+		that could be read in the first read... */

+		if( xCount > xFirstLength )

+		{

+			/*...then read the remaining bytes from the start of the buffer. */

+			configASSERT( xCount <= xMaxCount );

+			( void ) memcpy( ( void * ) &( pucData[ xFirstLength ] ), ( void * ) ( pxStreamBuffer->pucBuffer ), xCount - xFirstLength ); /*lint !e9087 memcpy() requires void *. */

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+

+		/* Move the tail pointer to effectively remove the data read from

+		the buffer. */

+		xNextTail += xCount;

+

+		if( xNextTail >= pxStreamBuffer->xLength )

+		{

+			xNextTail -= pxStreamBuffer->xLength;

+		}

+

+		pxStreamBuffer->xTail = xNextTail;

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

+

+	return xCount;

+}

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

+

+static size_t prvBytesInBuffer( const StreamBuffer_t * const pxStreamBuffer )

+{

+/* Returns the distance between xTail and xHead. */

+size_t xCount;

+

+	xCount = pxStreamBuffer->xLength + pxStreamBuffer->xHead;

+	xCount -= pxStreamBuffer->xTail;

+	if ( xCount >= pxStreamBuffer->xLength )

+	{

+		xCount -= pxStreamBuffer->xLength;

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

+

+	return xCount;

+}

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

+

+static void prvInitialiseNewStreamBuffer( StreamBuffer_t * const pxStreamBuffer,

+										  uint8_t * const pucBuffer,

+										  size_t xBufferSizeBytes,

+										  size_t xTriggerLevelBytes,

+										  uint8_t ucFlags )

+{

+	/* Assert here is deliberately writing to the entire buffer to ensure it can

+	be written to without generating exceptions, and is setting the buffer to a

+	known value to assist in development/debugging. */

+	#if( configASSERT_DEFINED == 1 )

+	{

+		/* The value written just has to be identifiable when looking at the

+		memory.  Don't use 0xA5 as that is the stack fill value and could

+		result in confusion as to what is actually being observed. */

+		const BaseType_t xWriteValue = 0x55;

+		configASSERT( memset( pucBuffer, ( int ) xWriteValue, xBufferSizeBytes ) == pucBuffer );

+	} /*lint !e529 !e438 xWriteValue is only used if configASSERT() is defined. */

+	#endif

+

+	( void ) memset( ( void * ) pxStreamBuffer, 0x00, sizeof( StreamBuffer_t ) ); /*lint !e9087 memset() requires void *. */

+	pxStreamBuffer->pucBuffer = pucBuffer;

+	pxStreamBuffer->xLength = xBufferSizeBytes;

+	pxStreamBuffer->xTriggerLevelBytes = xTriggerLevelBytes;

+	pxStreamBuffer->ucFlags = ucFlags;

+}

+

+#if ( configUSE_TRACE_FACILITY == 1 )

+

+	UBaseType_t uxStreamBufferGetStreamBufferNumber( StreamBufferHandle_t xStreamBuffer )

+	{

+		return xStreamBuffer->uxStreamBufferNumber;

+	}

+

+#endif /* configUSE_TRACE_FACILITY */

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

+

+#if ( configUSE_TRACE_FACILITY == 1 )

+

+	void vStreamBufferSetStreamBufferNumber( StreamBufferHandle_t xStreamBuffer, UBaseType_t uxStreamBufferNumber )

+	{

+		xStreamBuffer->uxStreamBufferNumber = uxStreamBufferNumber;

+	}

+

+#endif /* configUSE_TRACE_FACILITY */

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

+

+#if ( configUSE_TRACE_FACILITY == 1 )

+

+	uint8_t ucStreamBufferGetStreamBufferType( StreamBufferHandle_t xStreamBuffer )

+	{

+		return ( xStreamBuffer->ucFlags & sbFLAGS_IS_MESSAGE_BUFFER );

+	}

+

+#endif /* configUSE_TRACE_FACILITY */

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

diff --git a/src/FreeRTOS/Source/tasks.c b/src/FreeRTOS/Source/tasks.c
index 11ca0e9..492bf87 100644
--- a/src/FreeRTOS/Source/tasks.c
+++ b/src/FreeRTOS/Source/tasks.c
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 /* Standard includes. */

 #include <stdlib.h>

@@ -80,13 +38,13 @@ task.h is included from an application file. */
 #include "FreeRTOS.h"

 #include "task.h"

 #include "timers.h"

-#include "StackMacros.h"

+#include "stack_macros.h"

 

-/* Lint e961 and e750 are suppressed as a MISRA exception justified because the

-MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined for the

-header files above, but not in this file, in order to generate the correct

-privileged Vs unprivileged linkage and placement. */

-#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750. */

+/* Lint e9021, e961 and e750 are suppressed as a MISRA exception justified

+because the MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined

+for the header files above, but not in this file, in order to generate the

+correct privileged Vs unprivileged linkage and placement. */

+#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750 !e9021. */

 

 /* Set configUSE_STATS_FORMATTING_FUNCTIONS to 2 to include the stats formatting

 functions but without including stdio.h here. */

@@ -98,18 +56,6 @@ functions but without including stdio.h here. */
 	#include <stdio.h>

 #endif /* configUSE_STATS_FORMATTING_FUNCTIONS == 1 ) */

 

-/* Sanity check the configuration. */

-#if( configUSE_TICKLESS_IDLE != 0 )

-	#if( INCLUDE_vTaskSuspend != 1 )

-		#error INCLUDE_vTaskSuspend must be set to 1 if configUSE_TICKLESS_IDLE is not set to 0

-	#endif /* INCLUDE_vTaskSuspend */

-#endif /* configUSE_TICKLESS_IDLE */

-

-/*

- * Defines the size, in words, of the stack allocated to the idle task.

- */

-#define tskIDLE_STACK_SIZE	configMINIMAL_STACK_SIZE

-

 #if( configUSE_PREEMPTION == 0 )

 	/* If the cooperative scheduler is being used then a yield should not be

 	performed just because a higher priority task has been woken. */

@@ -118,157 +64,10 @@ functions but without including stdio.h here. */
 	#define taskYIELD_IF_USING_PREEMPTION() portYIELD_WITHIN_API()

 #endif

 

-/* Value that can be assigned to the eNotifyState member of the TCB. */

-typedef enum

-{

-	eNotWaitingNotification = 0,

-	eWaitingNotification,

-	eNotified

-} eNotifyValue;

-

-/*

- * Task control block.  A task control block (TCB) is allocated for each task,

- * and stores task state information, including a pointer to the task's context

- * (the task's run time environment, including register values)

- */

-typedef struct tskTaskControlBlock

-{

-	volatile StackType_t	*pxTopOfStack;	/*< Points to the location of the last item placed on the tasks stack.  THIS MUST BE THE FIRST MEMBER OF THE TCB STRUCT. */

-

-	#if ( portUSING_MPU_WRAPPERS == 1 )

-		xMPU_SETTINGS	xMPUSettings;		/*< The MPU settings are defined as part of the port layer.  THIS MUST BE THE SECOND MEMBER OF THE TCB STRUCT. */

-		BaseType_t		xUsingStaticallyAllocatedStack; /* Set to pdTRUE if the stack is a statically allocated array, and pdFALSE if the stack is dynamically allocated. */

-	#endif

-

-	ListItem_t			xGenericListItem;	/*< The list that the state list item of a task is reference from denotes the state of that task (Ready, Blocked, Suspended ). */

-	ListItem_t			xEventListItem;		/*< Used to reference a task from an event list. */

-	UBaseType_t			uxPriority;			/*< The priority of the task.  0 is the lowest priority. */

-	StackType_t			*pxStack;			/*< Points to the start of the stack. */

-	char				pcTaskName[ configMAX_TASK_NAME_LEN ];/*< Descriptive name given to the task when created.  Facilitates debugging only. */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

-

-	#if ( portSTACK_GROWTH > 0 )

-		StackType_t		*pxEndOfStack;		/*< Points to the end of the stack on architectures where the stack grows up from low memory. */

-	#endif

-

-	#if ( portCRITICAL_NESTING_IN_TCB == 1 )

-		UBaseType_t 	uxCriticalNesting; 	/*< Holds the critical section nesting depth for ports that do not maintain their own count in the port layer. */

-	#endif

-

-	#if ( configUSE_TRACE_FACILITY == 1 )

-		UBaseType_t		uxTCBNumber;		/*< Stores a number that increments each time a TCB is created.  It allows debuggers to determine when a task has been deleted and then recreated. */

-		UBaseType_t  	uxTaskNumber;		/*< Stores a number specifically for use by third party trace code. */

-	#endif

-

-	#if ( configUSE_MUTEXES == 1 )

-		UBaseType_t 	uxBasePriority;		/*< The priority last assigned to the task - used by the priority inheritance mechanism. */

-		UBaseType_t 	uxMutexesHeld;

-	#endif

-

-	#if ( configUSE_APPLICATION_TASK_TAG == 1 )

-		TaskHookFunction_t pxTaskTag;

-	#endif

-

-	#if( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )

-		void *pvThreadLocalStoragePointers[ configNUM_THREAD_LOCAL_STORAGE_POINTERS ];

-	#endif

-

-	#if ( configGENERATE_RUN_TIME_STATS == 1 )

-		uint32_t		ulRunTimeCounter;	/*< Stores the amount of time the task has spent in the Running state. */

-	#endif

-

-	#if ( configUSE_NEWLIB_REENTRANT == 1 )

-		/* Allocate a Newlib reent structure that is specific to this task.

-		Note Newlib support has been included by popular demand, but is not

-		used by the FreeRTOS maintainers themselves.  FreeRTOS is not

-		responsible for resulting newlib operation.  User must be familiar with

-		newlib and must provide system-wide implementations of the necessary

-		stubs. Be warned that (at the time of writing) the current newlib design

-		implements a system-wide malloc() that must be provided with locks. */

-		struct 	_reent xNewLib_reent;

-	#endif

-

-	#if ( configUSE_TASK_NOTIFICATIONS == 1 )

-		volatile uint32_t ulNotifiedValue;

-		volatile eNotifyValue eNotifyState;

-	#endif

-

-} tskTCB;

-

-/* The old tskTCB name is maintained above then typedefed to the new TCB_t name

-below to enable the use of older kernel aware debuggers. */

-typedef tskTCB TCB_t;

-

-/*

- * Some kernel aware debuggers require the data the debugger needs access to to

- * be global, rather than file scope.

- */

-#ifdef portREMOVE_STATIC_QUALIFIER

-	#define static

-#endif

-

-/*lint -e956 A manual analysis and inspection has been used to determine which

-static variables must be declared volatile. */

-

-PRIVILEGED_DATA TCB_t * volatile pxCurrentTCB = NULL;

-

-/* Lists for ready and blocked tasks. --------------------*/

-PRIVILEGED_DATA static List_t pxReadyTasksLists[ configMAX_PRIORITIES ];/*< Prioritised ready tasks. */

-PRIVILEGED_DATA static List_t xDelayedTaskList1;						/*< Delayed tasks. */

-PRIVILEGED_DATA static List_t xDelayedTaskList2;						/*< Delayed tasks (two lists are used - one for delays that have overflowed the current tick count. */

-PRIVILEGED_DATA static List_t * volatile pxDelayedTaskList;				/*< Points to the delayed task list currently being used. */

-PRIVILEGED_DATA static List_t * volatile pxOverflowDelayedTaskList;		/*< Points to the delayed task list currently being used to hold tasks that have overflowed the current tick count. */

-PRIVILEGED_DATA static List_t xPendingReadyList;						/*< Tasks that have been readied while the scheduler was suspended.  They will be moved to the ready list when the scheduler is resumed. */

-

-#if ( INCLUDE_vTaskDelete == 1 )

-

-	PRIVILEGED_DATA static List_t xTasksWaitingTermination;				/*< Tasks that have been deleted - but their memory not yet freed. */

-	PRIVILEGED_DATA static volatile UBaseType_t uxTasksDeleted = ( UBaseType_t ) 0U;

-

-#endif

-

-#if ( INCLUDE_vTaskSuspend == 1 )

-

-	PRIVILEGED_DATA static List_t xSuspendedTaskList;					/*< Tasks that are currently suspended. */

-

-#endif

-

-#if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )

-

-	PRIVILEGED_DATA static TaskHandle_t xIdleTaskHandle = NULL;			/*< Holds the handle of the idle task.  The idle task is created automatically when the scheduler is started. */

-

-#endif

-

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

-PRIVILEGED_DATA static volatile UBaseType_t uxCurrentNumberOfTasks 	= ( UBaseType_t ) 0U;

-PRIVILEGED_DATA static volatile TickType_t xTickCount 				= ( TickType_t ) 0U;

-PRIVILEGED_DATA static volatile UBaseType_t uxTopReadyPriority 		= tskIDLE_PRIORITY;

-PRIVILEGED_DATA static volatile BaseType_t xSchedulerRunning 		= pdFALSE;

-PRIVILEGED_DATA static volatile UBaseType_t uxPendedTicks 			= ( UBaseType_t ) 0U;

-PRIVILEGED_DATA static volatile BaseType_t xYieldPending 			= pdFALSE;

-PRIVILEGED_DATA static volatile BaseType_t xNumOfOverflows 			= ( BaseType_t ) 0;

-PRIVILEGED_DATA static UBaseType_t uxTaskNumber 					= ( UBaseType_t ) 0U;

-PRIVILEGED_DATA static volatile TickType_t xNextTaskUnblockTime		= ( TickType_t ) 0U; /* Initialised to portMAX_DELAY before the scheduler starts. */

-

-/* Context switches are held pending while the scheduler is suspended.  Also,

-interrupts must not manipulate the xGenericListItem of a TCB, or any of the

-lists the xGenericListItem can be referenced from, if the scheduler is suspended.

-If an interrupt needs to unblock a task while the scheduler is suspended then it

-moves the task's event list item into the xPendingReadyList, ready for the

-kernel to move the task from the pending ready list into the real ready list

-when the scheduler is unsuspended.  The pending ready list itself can only be

-accessed from a critical section. */

-PRIVILEGED_DATA static volatile UBaseType_t uxSchedulerSuspended	= ( UBaseType_t ) pdFALSE;

-

-#if ( configGENERATE_RUN_TIME_STATS == 1 )

-

-	PRIVILEGED_DATA static uint32_t ulTaskSwitchedInTime = 0UL;	/*< Holds the value of a timer/counter the last time a task was switched in. */

-	PRIVILEGED_DATA static uint32_t ulTotalRunTime = 0UL;		/*< Holds the total amount of execution time as defined by the run time counter clock. */

-

-#endif

-

-/*lint +e956 */

-

-/* Debugging and trace facilities private variables and macros. ------------*/

+/* Values that can be assigned to the ucNotifyState member of the TCB. */

+#define taskNOT_WAITING_NOTIFICATION	( ( uint8_t ) 0 )

+#define taskWAITING_NOTIFICATION		( ( uint8_t ) 1 )

+#define taskNOTIFICATION_RECEIVED		( ( uint8_t ) 2 )

 

 /*

  * The value used to fill the stack of a task when the task is created.  This

@@ -276,15 +75,42 @@ PRIVILEGED_DATA static volatile UBaseType_t uxSchedulerSuspended	= ( UBaseType_t
  */

 #define tskSTACK_FILL_BYTE	( 0xa5U )

 

+/* Bits used to recored how a task's stack and TCB were allocated. */

+#define tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB 		( ( uint8_t ) 0 )

+#define tskSTATICALLY_ALLOCATED_STACK_ONLY 			( ( uint8_t ) 1 )

+#define tskSTATICALLY_ALLOCATED_STACK_AND_TCB		( ( uint8_t ) 2 )

+

+/* If any of the following are set then task stacks are filled with a known

+value so the high water mark can be determined.  If none of the following are

+set then don't fill the stack so there is no unnecessary dependency on memset. */

+#if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) || ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) )

+	#define tskSET_NEW_STACKS_TO_KNOWN_VALUE	1

+#else

+	#define tskSET_NEW_STACKS_TO_KNOWN_VALUE	0

+#endif

+

 /*

  * Macros used by vListTask to indicate which state a task is in.

  */

+#define tskRUNNING_CHAR		( 'X' )

 #define tskBLOCKED_CHAR		( 'B' )

 #define tskREADY_CHAR		( 'R' )

 #define tskDELETED_CHAR		( 'D' )

 #define tskSUSPENDED_CHAR	( 'S' )

 

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

+/*

+ * Some kernel aware debuggers require the data the debugger needs access to be

+ * global, rather than file scope.

+ */

+#ifdef portREMOVE_STATIC_QUALIFIER

+	#define static

+#endif

+

+/* The name allocated to the Idle task.  This can be overridden by defining

+configIDLE_TASK_NAME in FreeRTOSConfig.h. */

+#ifndef configIDLE_TASK_NAME

+	#define configIDLE_TASK_NAME "IDLE"

+#endif

 

 #if ( configUSE_PORT_OPTIMISED_TASK_SELECTION == 0 )

 

@@ -306,16 +132,19 @@ PRIVILEGED_DATA static volatile UBaseType_t uxSchedulerSuspended	= ( UBaseType_t
 

 	#define taskSELECT_HIGHEST_PRIORITY_TASK()															\

 	{																									\

+	UBaseType_t uxTopPriority = uxTopReadyPriority;														\

+																										\

 		/* Find the highest priority queue that contains ready tasks. */								\

-		while( listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxTopReadyPriority ] ) ) )						\

+		while( listLIST_IS_EMPTY( &( pxReadyTasksLists[ uxTopPriority ] ) ) )							\

 		{																								\

-			configASSERT( uxTopReadyPriority );															\

-			--uxTopReadyPriority;																		\

+			configASSERT( uxTopPriority );																\

+			--uxTopPriority;																			\

 		}																								\

 																										\

 		/* listGET_OWNER_OF_NEXT_ENTRY indexes through the list, so the tasks of						\

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

-		listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopReadyPriority ] ) );		\

+		listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopPriority ] ) );			\

+		uxTopReadyPriority = uxTopPriority;																\

 	} /* taskSELECT_HIGHEST_PRIORITY_TASK */

 

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

@@ -341,7 +170,7 @@ PRIVILEGED_DATA static volatile UBaseType_t uxSchedulerSuspended	= ( UBaseType_t
 	{																								\

 	UBaseType_t uxTopPriority;																		\

 																									\

-		/* Find the highest priority queue that contains ready tasks. */							\

+		/* Find the highest priority list that contains ready tasks. */								\

 		portGET_HIGHEST_PRIORITY( uxTopPriority, uxTopReadyPriority );								\

 		configASSERT( listCURRENT_LIST_LENGTH( &( pxReadyTasksLists[ uxTopPriority ] ) ) > 0 );		\

 		listGET_OWNER_OF_NEXT_ENTRY( pxCurrentTCB, &( pxReadyTasksLists[ uxTopPriority ] ) );		\

@@ -389,7 +218,8 @@ count overflows. */
 #define prvAddTaskToReadyList( pxTCB )																\

 	traceMOVED_TASK_TO_READY_STATE( pxTCB );														\

 	taskRECORD_READY_PRIORITY( ( pxTCB )->uxPriority );												\

-	vListInsertEnd( &( pxReadyTasksLists[ ( pxTCB )->uxPriority ] ), &( ( pxTCB )->xGenericListItem ) )

+	vListInsertEnd( &( pxReadyTasksLists[ ( pxTCB )->uxPriority ] ), &( ( pxTCB )->xStateListItem ) ); \

+	tracePOST_MOVED_TASK_TO_READY_STATE( pxTCB )

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

 

 /*

@@ -398,7 +228,7 @@ count overflows. */
  * task should be used in place of the parameter.  This macro simply checks to

  * see if the parameter is NULL and returns a pointer to the appropriate TCB.

  */

-#define prvGetTCBFromHandle( pxHandle ) ( ( ( pxHandle ) == NULL ) ? ( TCB_t * ) pxCurrentTCB : ( TCB_t * ) ( pxHandle ) )

+#define prvGetTCBFromHandle( pxHandle ) ( ( ( pxHandle ) == NULL ) ? pxCurrentTCB : ( pxHandle ) )

 

 /* The item value of the event list item is normally used to hold the priority

 of the task to which it belongs (coded to allow it to be held in reverse

@@ -408,36 +238,196 @@ being used for another purpose.  The following bit definition is used to inform
 the scheduler that the value should not be changed - in which case it is the

 responsibility of whichever module is using the value to ensure it gets set back

 to its original value when it is released. */

-#if configUSE_16_BIT_TICKS == 1

+#if( configUSE_16_BIT_TICKS == 1 )

 	#define taskEVENT_LIST_ITEM_VALUE_IN_USE	0x8000U

 #else

 	#define taskEVENT_LIST_ITEM_VALUE_IN_USE	0x80000000UL

 #endif

 

+/*

+ * Task control block.  A task control block (TCB) is allocated for each task,

+ * and stores task state information, including a pointer to the task's context

+ * (the task's run time environment, including register values)

+ */

+typedef struct tskTaskControlBlock 			/* The old naming convention is used to prevent breaking kernel aware debuggers. */

+{

+	volatile StackType_t	*pxTopOfStack;	/*< Points to the location of the last item placed on the tasks stack.  THIS MUST BE THE FIRST MEMBER OF THE TCB STRUCT. */

+

+	#if ( portUSING_MPU_WRAPPERS == 1 )

+		xMPU_SETTINGS	xMPUSettings;		/*< The MPU settings are defined as part of the port layer.  THIS MUST BE THE SECOND MEMBER OF THE TCB STRUCT. */

+	#endif

+

+	ListItem_t			xStateListItem;	/*< The list that the state list item of a task is reference from denotes the state of that task (Ready, Blocked, Suspended ). */

+	ListItem_t			xEventListItem;		/*< Used to reference a task from an event list. */

+	UBaseType_t			uxPriority;			/*< The priority of the task.  0 is the lowest priority. */

+	StackType_t			*pxStack;			/*< Points to the start of the stack. */

+	char				pcTaskName[ configMAX_TASK_NAME_LEN ];/*< Descriptive name given to the task when created.  Facilitates debugging only. */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+

+	#if ( ( portSTACK_GROWTH > 0 ) || ( configRECORD_STACK_HIGH_ADDRESS == 1 ) )

+		StackType_t		*pxEndOfStack;		/*< Points to the highest valid address for the stack. */

+	#endif

+

+	#if ( portCRITICAL_NESTING_IN_TCB == 1 )

+		UBaseType_t		uxCriticalNesting;	/*< Holds the critical section nesting depth for ports that do not maintain their own count in the port layer. */

+	#endif

+

+	#if ( configUSE_TRACE_FACILITY == 1 )

+		UBaseType_t		uxTCBNumber;		/*< Stores a number that increments each time a TCB is created.  It allows debuggers to determine when a task has been deleted and then recreated. */

+		UBaseType_t		uxTaskNumber;		/*< Stores a number specifically for use by third party trace code. */

+	#endif

+

+	#if ( configUSE_MUTEXES == 1 )

+		UBaseType_t		uxBasePriority;		/*< The priority last assigned to the task - used by the priority inheritance mechanism. */

+		UBaseType_t		uxMutexesHeld;

+	#endif

+

+	#if ( configUSE_APPLICATION_TASK_TAG == 1 )

+		TaskHookFunction_t pxTaskTag;

+	#endif

+

+	#if( configNUM_THREAD_LOCAL_STORAGE_POINTERS > 0 )

+		void			*pvThreadLocalStoragePointers[ configNUM_THREAD_LOCAL_STORAGE_POINTERS ];

+	#endif

+

+	#if( configGENERATE_RUN_TIME_STATS == 1 )

+		uint32_t		ulRunTimeCounter;	/*< Stores the amount of time the task has spent in the Running state. */

+	#endif

+

+	#if ( configUSE_NEWLIB_REENTRANT == 1 )

+		/* Allocate a Newlib reent structure that is specific to this task.

+		Note Newlib support has been included by popular demand, but is not

+		used by the FreeRTOS maintainers themselves.  FreeRTOS is not

+		responsible for resulting newlib operation.  User must be familiar with

+		newlib and must provide system-wide implementations of the necessary

+		stubs. Be warned that (at the time of writing) the current newlib design

+		implements a system-wide malloc() that must be provided with locks. */

+		struct	_reent xNewLib_reent;

+	#endif

+

+	#if( configUSE_TASK_NOTIFICATIONS == 1 )

+		volatile uint32_t ulNotifiedValue;

+		volatile uint8_t ucNotifyState;

+	#endif

+

+	/* See the comments in FreeRTOS.h with the definition of

+	tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE. */

+	#if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 !e9029 Macro has been consolidated for readability reasons. */

+		uint8_t	ucStaticallyAllocated; 		/*< Set to pdTRUE if the task is a statically allocated to ensure no attempt is made to free the memory. */

+	#endif

+

+	#if( INCLUDE_xTaskAbortDelay == 1 )

+		uint8_t ucDelayAborted;

+	#endif

+

+	#if( configUSE_POSIX_ERRNO == 1 )

+		int iTaskErrno;

+	#endif

+

+} tskTCB;

+

+/* The old tskTCB name is maintained above then typedefed to the new TCB_t name

+below to enable the use of older kernel aware debuggers. */

+typedef tskTCB TCB_t;

+

+/*lint -save -e956 A manual analysis and inspection has been used to determine

+which static variables must be declared volatile. */

+PRIVILEGED_DATA TCB_t * volatile pxCurrentTCB = NULL;

+

+/* Lists for ready and blocked tasks. --------------------

+xDelayedTaskList1 and xDelayedTaskList2 could be move to function scople but

+doing so breaks some kernel aware debuggers and debuggers that rely on removing

+the static qualifier. */

+PRIVILEGED_DATA static List_t pxReadyTasksLists[ configMAX_PRIORITIES ];/*< Prioritised ready tasks. */

+PRIVILEGED_DATA static List_t xDelayedTaskList1;						/*< Delayed tasks. */

+PRIVILEGED_DATA static List_t xDelayedTaskList2;						/*< Delayed tasks (two lists are used - one for delays that have overflowed the current tick count. */

+PRIVILEGED_DATA static List_t * volatile pxDelayedTaskList;				/*< Points to the delayed task list currently being used. */

+PRIVILEGED_DATA static List_t * volatile pxOverflowDelayedTaskList;		/*< Points to the delayed task list currently being used to hold tasks that have overflowed the current tick count. */

+PRIVILEGED_DATA static List_t xPendingReadyList;						/*< Tasks that have been readied while the scheduler was suspended.  They will be moved to the ready list when the scheduler is resumed. */

+

+#if( INCLUDE_vTaskDelete == 1 )

+

+	PRIVILEGED_DATA static List_t xTasksWaitingTermination;				/*< Tasks that have been deleted - but their memory not yet freed. */

+	PRIVILEGED_DATA static volatile UBaseType_t uxDeletedTasksWaitingCleanUp = ( UBaseType_t ) 0U;

+

+#endif

+

+#if ( INCLUDE_vTaskSuspend == 1 )

+

+	PRIVILEGED_DATA static List_t xSuspendedTaskList;					/*< Tasks that are currently suspended. */

+

+#endif

+

+/* Global POSIX errno. Its value is changed upon context switching to match

+the errno of the currently running task. */

+#if ( configUSE_POSIX_ERRNO == 1 )

+	int FreeRTOS_errno = 0;

+#endif

+

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

+PRIVILEGED_DATA static volatile UBaseType_t uxCurrentNumberOfTasks 	= ( UBaseType_t ) 0U;

+PRIVILEGED_DATA static volatile TickType_t xTickCount 				= ( TickType_t ) configINITIAL_TICK_COUNT;

+PRIVILEGED_DATA static volatile UBaseType_t uxTopReadyPriority 		= tskIDLE_PRIORITY;

+PRIVILEGED_DATA static volatile BaseType_t xSchedulerRunning 		= pdFALSE;

+PRIVILEGED_DATA static volatile UBaseType_t uxPendedTicks 			= ( UBaseType_t ) 0U;

+PRIVILEGED_DATA static volatile BaseType_t xYieldPending 			= pdFALSE;

+PRIVILEGED_DATA static volatile BaseType_t xNumOfOverflows 			= ( BaseType_t ) 0;

+PRIVILEGED_DATA static UBaseType_t uxTaskNumber 					= ( UBaseType_t ) 0U;

+PRIVILEGED_DATA static volatile TickType_t xNextTaskUnblockTime		= ( TickType_t ) 0U; /* Initialised to portMAX_DELAY before the scheduler starts. */

+PRIVILEGED_DATA static TaskHandle_t xIdleTaskHandle					= NULL;			/*< Holds the handle of the idle task.  The idle task is created automatically when the scheduler is started. */

+

+/* Context switches are held pending while the scheduler is suspended.  Also,

+interrupts must not manipulate the xStateListItem of a TCB, or any of the

+lists the xStateListItem can be referenced from, if the scheduler is suspended.

+If an interrupt needs to unblock a task while the scheduler is suspended then it

+moves the task's event list item into the xPendingReadyList, ready for the

+kernel to move the task from the pending ready list into the real ready list

+when the scheduler is unsuspended.  The pending ready list itself can only be

+accessed from a critical section. */

+PRIVILEGED_DATA static volatile UBaseType_t uxSchedulerSuspended	= ( UBaseType_t ) pdFALSE;

+

+#if ( configGENERATE_RUN_TIME_STATS == 1 )

+

+	/* Do not move these variables to function scope as doing so prevents the

+	code working with debuggers that need to remove the static qualifier. */

+	PRIVILEGED_DATA static uint32_t ulTaskSwitchedInTime = 0UL;	/*< Holds the value of a timer/counter the last time a task was switched in. */

+	PRIVILEGED_DATA static uint32_t ulTotalRunTime = 0UL;		/*< Holds the total amount of execution time as defined by the run time counter clock. */

+

+#endif

+

+/*lint -restore */

+

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

+

 /* Callback function prototypes. --------------------------*/

-#if configCHECK_FOR_STACK_OVERFLOW > 0

+#if(  configCHECK_FOR_STACK_OVERFLOW > 0 )

+

 	extern void vApplicationStackOverflowHook( TaskHandle_t xTask, char *pcTaskName );

+

+#endif

+

+#if( configUSE_TICK_HOOK > 0 )

+

+	extern void vApplicationTickHook( void ); /*lint !e526 Symbol not defined as it is an application callback. */

+

 #endif

 

-#if configUSE_TICK_HOOK > 0

-	extern void vApplicationTickHook( void );

+#if( configSUPPORT_STATIC_ALLOCATION == 1 )

+

+	extern void vApplicationGetIdleTaskMemory( StaticTask_t **ppxIdleTaskTCBBuffer, StackType_t **ppxIdleTaskStackBuffer, uint32_t *pulIdleTaskStackSize ); /*lint !e526 Symbol not defined as it is an application callback. */

+

 #endif

 

 /* File private functions. --------------------------------*/

 

-/*

- * Utility to ready a TCB for a given task.  Mainly just copies the parameters

- * into the TCB structure.

- */

-static void prvInitialiseTCBVariables( TCB_t * const pxTCB, const char * const pcName, UBaseType_t uxPriority, const MemoryRegion_t * const xRegions, const uint16_t usStackDepth ) PRIVILEGED_FUNCTION; /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

-

 /**

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

  */

 #if ( INCLUDE_vTaskSuspend == 1 )

+

 	static BaseType_t prvTaskIsTaskSuspended( const TaskHandle_t xTask ) PRIVILEGED_FUNCTION;

+

 #endif /* INCLUDE_vTaskSuspend */

 

 /*

@@ -483,13 +473,7 @@ static void prvCheckTasksWaitingTermination( void ) PRIVILEGED_FUNCTION;
  * The currently executing task is entering the Blocked state.  Add the task to

  * either the current or the overflow delayed task list.

  */

-static void prvAddCurrentTaskToDelayedList( const TickType_t xTimeToWake ) PRIVILEGED_FUNCTION;

-

-/*

- * Allocates memory from the heap for a TCB and associated stack.  Checks the

- * allocation was successful.

- */

-static TCB_t *prvAllocateTCBAndStack( const uint16_t usStackDepth, StackType_t * const puxStackBuffer ) PRIVILEGED_FUNCTION;

+static void prvAddCurrentTaskToDelayedList( TickType_t xTicksToWait, const BaseType_t xCanBlockIndefinitely ) PRIVILEGED_FUNCTION;

 

 /*

  * Fills an TaskStatus_t structure with information on each task that is

@@ -501,7 +485,17 @@ static TCB_t *prvAllocateTCBAndStack( const uint16_t usStackDepth, StackType_t *
  */

 #if ( configUSE_TRACE_FACILITY == 1 )

 

-	static UBaseType_t prvListTaskWithinSingleList( TaskStatus_t *pxTaskStatusArray, List_t *pxList, eTaskState eState ) PRIVILEGED_FUNCTION;

+	static UBaseType_t prvListTasksWithinSingleList( TaskStatus_t *pxTaskStatusArray, List_t *pxList, eTaskState eState ) PRIVILEGED_FUNCTION;

+

+#endif

+

+/*

+ * Searches pxList for a task with name pcNameToQuery - returning a handle to

+ * the task if it is found, or NULL if the task is not found.

+ */

+#if ( INCLUDE_xTaskGetHandle == 1 )

+

+	static TCB_t *prvSearchForNameWithinSingleList( List_t *pxList, const char pcNameToQuery[] ) PRIVILEGED_FUNCTION;

 

 #endif

 

@@ -510,9 +504,9 @@ static TCB_t *prvAllocateTCBAndStack( const uint16_t usStackDepth, StackType_t *
  * This function determines the 'high water mark' of the task stack by

  * determining how much of the stack remains at the original preset value.

  */

-#if ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) )

+#if ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) )

 

-	static uint16_t prvTaskCheckFreeStackSpace( const uint8_t * pucStackByte ) PRIVILEGED_FUNCTION;

+	static configSTACK_DEPTH_TYPE prvTaskCheckFreeStackSpace( const uint8_t * pucStackByte ) PRIVILEGED_FUNCTION;

 

 #endif

 

@@ -543,186 +537,557 @@ static void prvResetNextTaskUnblockTime( void );
 	 * Helper function used to pad task names with spaces when printing out

 	 * human readable tables of task information.

 	 */

-	static char *prvWriteNameToBuffer( char *pcBuffer, const char *pcTaskName );

+	static char *prvWriteNameToBuffer( char *pcBuffer, const char *pcTaskName ) PRIVILEGED_FUNCTION;

 

 #endif

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

 

-BaseType_t xTaskGenericCreate( TaskFunction_t pxTaskCode, const char * const pcName, const uint16_t usStackDepth, void * const pvParameters, UBaseType_t uxPriority, TaskHandle_t * const pxCreatedTask, StackType_t * const puxStackBuffer, const MemoryRegion_t * const xRegions ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

-{

-BaseType_t xReturn;

-TCB_t * pxNewTCB;

-StackType_t *pxTopOfStack;

+/*

+ * Called after a Task_t structure has been allocated either statically or

+ * dynamically to fill in the structure's members.

+ */

+static void prvInitialiseNewTask( 	TaskFunction_t pxTaskCode,

+									const char * const pcName, 		/*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+									const uint32_t ulStackDepth,

+									void * const pvParameters,

+									UBaseType_t uxPriority,

+									TaskHandle_t * const pxCreatedTask,

+									TCB_t *pxNewTCB,

+									const MemoryRegion_t * const xRegions ) PRIVILEGED_FUNCTION;

+

+/*

+ * Called after a new task has been created and initialised to place the task

+ * under the control of the scheduler.

+ */

+static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB ) PRIVILEGED_FUNCTION;

+

+/*

+ * freertos_tasks_c_additions_init() should only be called if the user definable

+ * macro FREERTOS_TASKS_C_ADDITIONS_INIT() is defined, as that is the only macro

+ * called by the function.

+ */

+#ifdef FREERTOS_TASKS_C_ADDITIONS_INIT

+

+	static void freertos_tasks_c_additions_init( void ) PRIVILEGED_FUNCTION;

+

+#endif

 

-	configASSERT( pxTaskCode );

-	configASSERT( ( ( uxPriority & ( UBaseType_t ) ( ~portPRIVILEGE_BIT ) ) < ( UBaseType_t ) configMAX_PRIORITIES ) );

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

 

-	/* Allocate the memory required by the TCB and stack for the new task,

-	checking that the allocation was successful. */

-	pxNewTCB = prvAllocateTCBAndStack( usStackDepth, puxStackBuffer );

+#if( configSUPPORT_STATIC_ALLOCATION == 1 )

 

-	if( pxNewTCB != NULL )

+	TaskHandle_t xTaskCreateStatic(	TaskFunction_t pxTaskCode,

+									const char * const pcName,		/*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+									const uint32_t ulStackDepth,

+									void * const pvParameters,

+									UBaseType_t uxPriority,

+									StackType_t * const puxStackBuffer,

+									StaticTask_t * const pxTaskBuffer )

 	{

-		#if( portUSING_MPU_WRAPPERS == 1 )

-			/* Should the task be created in privileged mode? */

-			BaseType_t xRunPrivileged;

-			if( ( uxPriority & portPRIVILEGE_BIT ) != 0U )

-			{

-				xRunPrivileged = pdTRUE;

-			}

-			else

+	TCB_t *pxNewTCB;

+	TaskHandle_t xReturn;

+

+		configASSERT( puxStackBuffer != NULL );

+		configASSERT( pxTaskBuffer != NULL );

+

+		#if( configASSERT_DEFINED == 1 )

+		{

+			/* Sanity check that the size of the structure used to declare a

+			variable of type StaticTask_t equals the size of the real task

+			structure. */

+			volatile size_t xSize = sizeof( StaticTask_t );

+			configASSERT( xSize == sizeof( TCB_t ) );

+			( void ) xSize; /* Prevent lint warning when configASSERT() is not used. */

+		}

+		#endif /* configASSERT_DEFINED */

+

+

+		if( ( pxTaskBuffer != NULL ) && ( puxStackBuffer != NULL ) )

+		{

+			/* The memory used for the task's TCB and stack are passed into this

+			function - use them. */

+			pxNewTCB = ( TCB_t * ) pxTaskBuffer; /*lint !e740 !e9087 Unusual cast is ok as the structures are designed to have the same alignment, and the size is checked by an assert. */

+			pxNewTCB->pxStack = ( StackType_t * ) puxStackBuffer;

+

+			#if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 !e9029 Macro has been consolidated for readability reasons. */

 			{

-				xRunPrivileged = pdFALSE;

+				/* Tasks can be created statically or dynamically, so note this

+				task was created statically in case the task is later deleted. */

+				pxNewTCB->ucStaticallyAllocated = tskSTATICALLY_ALLOCATED_STACK_AND_TCB;

 			}

-			uxPriority &= ~portPRIVILEGE_BIT;

+			#endif /* tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE */

+

+			prvInitialiseNewTask( pxTaskCode, pcName, ulStackDepth, pvParameters, uxPriority, &xReturn, pxNewTCB, NULL );

+			prvAddNewTaskToReadyList( pxNewTCB );

+		}

+		else

+		{

+			xReturn = NULL;

+		}

+

+		return xReturn;

+	}

+

+#endif /* SUPPORT_STATIC_ALLOCATION */

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

+

+#if( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) )

+

+	BaseType_t xTaskCreateRestrictedStatic( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask )

+	{

+	TCB_t *pxNewTCB;

+	BaseType_t xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;

 

-			if( puxStackBuffer != NULL )

+		configASSERT( pxTaskDefinition->puxStackBuffer != NULL );

+		configASSERT( pxTaskDefinition->pxTaskBuffer != NULL );

+

+		if( ( pxTaskDefinition->puxStackBuffer != NULL ) && ( pxTaskDefinition->pxTaskBuffer != NULL ) )

+		{

+			/* Allocate space for the TCB.  Where the memory comes from depends

+			on the implementation of the port malloc function and whether or

+			not static allocation is being used. */

+			pxNewTCB = ( TCB_t * ) pxTaskDefinition->pxTaskBuffer;

+

+			/* Store the stack location in the TCB. */

+			pxNewTCB->pxStack = pxTaskDefinition->puxStackBuffer;

+

+			#if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 )

 			{

-				/* The application provided its own stack.  Note this so no

-				attempt is made to delete the stack should that task be

-				deleted. */

-				pxNewTCB->xUsingStaticallyAllocatedStack = pdTRUE;

+				/* Tasks can be created statically or dynamically, so note this

+				task was created statically in case the task is later deleted. */

+				pxNewTCB->ucStaticallyAllocated = tskSTATICALLY_ALLOCATED_STACK_AND_TCB;

 			}

-			else

+			#endif /* tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE */

+

+			prvInitialiseNewTask(	pxTaskDefinition->pvTaskCode,

+									pxTaskDefinition->pcName,

+									( uint32_t ) pxTaskDefinition->usStackDepth,

+									pxTaskDefinition->pvParameters,

+									pxTaskDefinition->uxPriority,

+									pxCreatedTask, pxNewTCB,

+									pxTaskDefinition->xRegions );

+

+			prvAddNewTaskToReadyList( pxNewTCB );

+			xReturn = pdPASS;

+		}

+

+		return xReturn;

+	}

+

+#endif /* ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) */

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

+

+#if( ( portUSING_MPU_WRAPPERS == 1 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )

+

+	BaseType_t xTaskCreateRestricted( const TaskParameters_t * const pxTaskDefinition, TaskHandle_t *pxCreatedTask )

+	{

+	TCB_t *pxNewTCB;

+	BaseType_t xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;

+

+		configASSERT( pxTaskDefinition->puxStackBuffer );

+

+		if( pxTaskDefinition->puxStackBuffer != NULL )

+		{

+			/* Allocate space for the TCB.  Where the memory comes from depends

+			on the implementation of the port malloc function and whether or

+			not static allocation is being used. */

+			pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) );

+

+			if( pxNewTCB != NULL )

 			{

-				/* The stack was allocated dynamically.  Note this so it can be

-				deleted again if the task is deleted. */

-				pxNewTCB->xUsingStaticallyAllocatedStack = pdFALSE;

+				/* Store the stack location in the TCB. */

+				pxNewTCB->pxStack = pxTaskDefinition->puxStackBuffer;

+

+				#if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 )

+				{

+					/* Tasks can be created statically or dynamically, so note

+					this task had a statically allocated stack in case it is

+					later deleted.  The TCB was allocated dynamically. */

+					pxNewTCB->ucStaticallyAllocated = tskSTATICALLY_ALLOCATED_STACK_ONLY;

+				}

+				#endif /* tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE */

+

+				prvInitialiseNewTask(	pxTaskDefinition->pvTaskCode,

+										pxTaskDefinition->pcName,

+										( uint32_t ) pxTaskDefinition->usStackDepth,

+										pxTaskDefinition->pvParameters,

+										pxTaskDefinition->uxPriority,

+										pxCreatedTask, pxNewTCB,

+										pxTaskDefinition->xRegions );

+

+				prvAddNewTaskToReadyList( pxNewTCB );

+				xReturn = pdPASS;

 			}

-		#endif /* portUSING_MPU_WRAPPERS == 1 */

+		}

+

+		return xReturn;

+	}

 

-		/* Calculate the top of stack address.  This depends on whether the

-		stack grows from high memory to low (as per the 80x86) or vice versa.

-		portSTACK_GROWTH is used to make the result positive or negative as

-		required by the port. */

-		#if( portSTACK_GROWTH < 0 )

+#endif /* portUSING_MPU_WRAPPERS */

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

+

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

+

+	BaseType_t xTaskCreate(	TaskFunction_t pxTaskCode,

+							const char * const pcName,		/*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+							const configSTACK_DEPTH_TYPE usStackDepth,

+							void * const pvParameters,

+							UBaseType_t uxPriority,

+							TaskHandle_t * const pxCreatedTask )

+	{

+	TCB_t *pxNewTCB;

+	BaseType_t xReturn;

+

+		/* If the stack grows down then allocate the stack then the TCB so the stack

+		does not grow into the TCB.  Likewise if the stack grows up then allocate

+		the TCB then the stack. */

+		#if( portSTACK_GROWTH > 0 )

 		{

-			pxTopOfStack = pxNewTCB->pxStack + ( usStackDepth - ( uint16_t ) 1 );

-			pxTopOfStack = ( StackType_t * ) ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) ); /*lint !e923 MISRA exception.  Avoiding casts between pointers and integers is not practical.  Size differences accounted for using portPOINTER_SIZE_TYPE type. */

+			/* Allocate space for the TCB.  Where the memory comes from depends on

+			the implementation of the port malloc function and whether or not static

+			allocation is being used. */

+			pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) );

+

+			if( pxNewTCB != NULL )

+			{

+				/* Allocate space for the stack used by the task being created.

+				The base of the stack memory stored in the TCB so the task can

+				be deleted later if required. */

+				pxNewTCB->pxStack = ( StackType_t * ) pvPortMalloc( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */

 

-			/* Check the alignment of the calculated top of stack is correct. */

-			configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );

+				if( pxNewTCB->pxStack == NULL )

+				{

+					/* Could not allocate the stack.  Delete the allocated TCB. */

+					vPortFree( pxNewTCB );

+					pxNewTCB = NULL;

+				}

+			}

 		}

 		#else /* portSTACK_GROWTH */

 		{

-			pxTopOfStack = pxNewTCB->pxStack;

+		StackType_t *pxStack;

+

+			/* Allocate space for the stack used by the task being created. */

+			pxStack = pvPortMalloc( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ) ); /*lint !e9079 All values returned by pvPortMalloc() have at least the alignment required by the MCU's stack and this allocation is the stack. */

 

-			/* Check the alignment of the stack buffer is correct. */

-			configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxNewTCB->pxStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );

+			if( pxStack != NULL )

+			{

+				/* Allocate space for the TCB. */

+				pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) ); /*lint !e9087 !e9079 All values returned by pvPortMalloc() have at least the alignment required by the MCU's stack, and the first member of TCB_t is always a pointer to the task's stack. */

 

-			/* If we want to use stack checking on architectures that use

-			a positive stack growth direction then we also need to store the

-			other extreme of the stack space. */

-			pxNewTCB->pxEndOfStack = pxNewTCB->pxStack + ( usStackDepth - 1 );

+				if( pxNewTCB != NULL )

+				{

+					/* Store the stack location in the TCB. */

+					pxNewTCB->pxStack = pxStack;

+				}

+				else

+				{

+					/* The stack cannot be used as the TCB was not created.  Free

+					it again. */

+					vPortFree( pxStack );

+				}

+			}

+			else

+			{

+				pxNewTCB = NULL;

+			}

 		}

 		#endif /* portSTACK_GROWTH */

 

-		/* Setup the newly allocated TCB with the initial state of the task. */

-		prvInitialiseTCBVariables( pxNewTCB, pcName, uxPriority, xRegions, usStackDepth );

-

-		/* Initialize the TCB stack to look as if the task was already running,

-		but had been interrupted by the scheduler.  The return address is set

-		to the start of the task function. Once the stack has been initialised

-		the	top of stack variable is updated. */

-		#if( portUSING_MPU_WRAPPERS == 1 )

+		if( pxNewTCB != NULL )

 		{

-			pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters, xRunPrivileged );

+			#if( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e9029 !e731 Macro has been consolidated for readability reasons. */

+			{

+				/* Tasks can be created statically or dynamically, so note this

+				task was created dynamically in case it is later deleted. */

+				pxNewTCB->ucStaticallyAllocated = tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB;

+			}

+			#endif /* tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE */

+

+			prvInitialiseNewTask( pxTaskCode, pcName, ( uint32_t ) usStackDepth, pvParameters, uxPriority, pxCreatedTask, pxNewTCB, NULL );

+			prvAddNewTaskToReadyList( pxNewTCB );

+			xReturn = pdPASS;

 		}

-		#else /* portUSING_MPU_WRAPPERS */

+		else

 		{

-			pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters );

+			xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;

 		}

-		#endif /* portUSING_MPU_WRAPPERS */

 

-		if( ( void * ) pxCreatedTask != NULL )

+		return xReturn;

+	}

+

+#endif /* configSUPPORT_DYNAMIC_ALLOCATION */

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

+

+static void prvInitialiseNewTask( 	TaskFunction_t pxTaskCode,

+									const char * const pcName,		/*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+									const uint32_t ulStackDepth,

+									void * const pvParameters,

+									UBaseType_t uxPriority,

+									TaskHandle_t * const pxCreatedTask,

+									TCB_t *pxNewTCB,

+									const MemoryRegion_t * const xRegions )

+{

+StackType_t *pxTopOfStack;

+UBaseType_t x;

+

+	#if( portUSING_MPU_WRAPPERS == 1 )

+		/* Should the task be created in privileged mode? */

+		BaseType_t xRunPrivileged;

+		if( ( uxPriority & portPRIVILEGE_BIT ) != 0U )

 		{

-			/* Pass the TCB out - in an anonymous way.  The calling function/

-			task can use this as a handle to delete the task later if

-			required.*/

-			*pxCreatedTask = ( TaskHandle_t ) pxNewTCB;

+			xRunPrivileged = pdTRUE;

 		}

 		else

 		{

-			mtCOVERAGE_TEST_MARKER();

+			xRunPrivileged = pdFALSE;

 		}

+		uxPriority &= ~portPRIVILEGE_BIT;

+	#endif /* portUSING_MPU_WRAPPERS == 1 */

 

-		/* Ensure interrupts don't access the task lists while they are being

-		updated. */

-		taskENTER_CRITICAL();

+	/* Avoid dependency on memset() if it is not required. */

+	#if( tskSET_NEW_STACKS_TO_KNOWN_VALUE == 1 )

+	{

+		/* Fill the stack with a known value to assist debugging. */

+		( void ) memset( pxNewTCB->pxStack, ( int ) tskSTACK_FILL_BYTE, ( size_t ) ulStackDepth * sizeof( StackType_t ) );

+	}

+	#endif /* tskSET_NEW_STACKS_TO_KNOWN_VALUE */

+

+	/* Calculate the top of stack address.  This depends on whether the stack

+	grows from high memory to low (as per the 80x86) or vice versa.

+	portSTACK_GROWTH is used to make the result positive or negative as required

+	by the port. */

+	#if( portSTACK_GROWTH < 0 )

+	{

+		pxTopOfStack = &( pxNewTCB->pxStack[ ulStackDepth - ( uint32_t ) 1 ] );

+		pxTopOfStack = ( StackType_t * ) ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) ); /*lint !e923 !e9033 !e9078 MISRA exception.  Avoiding casts between pointers and integers is not practical.  Size differences accounted for using portPOINTER_SIZE_TYPE type.  Checked by assert(). */

+

+		/* Check the alignment of the calculated top of stack is correct. */

+		configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxTopOfStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );

+

+		#if( configRECORD_STACK_HIGH_ADDRESS == 1 )

 		{

-			uxCurrentNumberOfTasks++;

-			if( pxCurrentTCB == NULL )

-			{

-				/* There are no other tasks, or all the other tasks are in

-				the suspended state - make this the current task. */

-				pxCurrentTCB =  pxNewTCB;

+			/* Also record the stack's high address, which may assist

+			debugging. */

+			pxNewTCB->pxEndOfStack = pxTopOfStack;

+		}

+		#endif /* configRECORD_STACK_HIGH_ADDRESS */

+	}

+	#else /* portSTACK_GROWTH */

+	{

+		pxTopOfStack = pxNewTCB->pxStack;

 

-				if( uxCurrentNumberOfTasks == ( UBaseType_t ) 1 )

-				{

-					/* This is the first task to be created so do the preliminary

-					initialisation required.  We will not recover if this call

-					fails, but we will report the failure. */

-					prvInitialiseTaskLists();

-				}

-				else

-				{

-					mtCOVERAGE_TEST_MARKER();

-				}

+		/* Check the alignment of the stack buffer is correct. */

+		configASSERT( ( ( ( portPOINTER_SIZE_TYPE ) pxNewTCB->pxStack & ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) == 0UL ) );

+

+		/* The other extreme of the stack space is required if stack checking is

+		performed. */

+		pxNewTCB->pxEndOfStack = pxNewTCB->pxStack + ( ulStackDepth - ( uint32_t ) 1 );

+	}

+	#endif /* portSTACK_GROWTH */

+

+	/* Store the task name in the TCB. */

+	if( pcName != NULL )

+	{

+		for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )

+		{

+			pxNewTCB->pcTaskName[ x ] = pcName[ x ];

+

+			/* Don't copy all configMAX_TASK_NAME_LEN if the string is shorter than

+			configMAX_TASK_NAME_LEN characters just in case the memory after the

+			string is not accessible (extremely unlikely). */

+			if( pcName[ x ] == ( char ) 0x00 )

+			{

+				break;

 			}

 			else

 			{

-				/* If the scheduler is not already running, make this task the

-				current task if it is the highest priority task to be created

-				so far. */

-				if( xSchedulerRunning == pdFALSE )

-				{

-					if( pxCurrentTCB->uxPriority <= uxPriority )

-					{

-						pxCurrentTCB = pxNewTCB;

-					}

-					else

-					{

-						mtCOVERAGE_TEST_MARKER();

-					}

-				}

-				else

-				{

-					mtCOVERAGE_TEST_MARKER();

-				}

+				mtCOVERAGE_TEST_MARKER();

 			}

+		}

 

-			uxTaskNumber++;

+		/* Ensure the name string is terminated in the case that the string length

+		was greater or equal to configMAX_TASK_NAME_LEN. */

+		pxNewTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1 ] = '\0';

+	}

+	else

+	{

+		/* The task has not been given a name, so just ensure there is a NULL

+		terminator when it is read out. */

+		pxNewTCB->pcTaskName[ 0 ] = 0x00;

+	}

 

-			#if ( configUSE_TRACE_FACILITY == 1 )

-			{

-				/* Add a counter into the TCB for tracing only. */

-				pxNewTCB->uxTCBNumber = uxTaskNumber;

-			}

-			#endif /* configUSE_TRACE_FACILITY */

-			traceTASK_CREATE( pxNewTCB );

+	/* This is used as an array index so must ensure it's not too large.  First

+	remove the privilege bit if one is present. */

+	if( uxPriority >= ( UBaseType_t ) configMAX_PRIORITIES )

+	{

+		uxPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U;

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

+

+	pxNewTCB->uxPriority = uxPriority;

+	#if ( configUSE_MUTEXES == 1 )

+	{

+		pxNewTCB->uxBasePriority = uxPriority;

+		pxNewTCB->uxMutexesHeld = 0;

+	}

+	#endif /* configUSE_MUTEXES */

 

-			prvAddTaskToReadyList( pxNewTCB );

+	vListInitialiseItem( &( pxNewTCB->xStateListItem ) );

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

 

-			xReturn = pdPASS;

-			portSETUP_TCB( pxNewTCB );

+	/* Set the pxNewTCB as a link back from the ListItem_t.  This is so we can get

+	back to	the containing TCB from a generic item in a list. */

+	listSET_LIST_ITEM_OWNER( &( pxNewTCB->xStateListItem ), pxNewTCB );

+

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

+	listSET_LIST_ITEM_VALUE( &( pxNewTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) uxPriority ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */

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

+

+	#if ( portCRITICAL_NESTING_IN_TCB == 1 )

+	{

+		pxNewTCB->uxCriticalNesting = ( UBaseType_t ) 0U;

+	}

+	#endif /* portCRITICAL_NESTING_IN_TCB */

+

+	#if ( configUSE_APPLICATION_TASK_TAG == 1 )

+	{

+		pxNewTCB->pxTaskTag = NULL;

+	}

+	#endif /* configUSE_APPLICATION_TASK_TAG */

+

+	#if ( configGENERATE_RUN_TIME_STATS == 1 )

+	{

+		pxNewTCB->ulRunTimeCounter = 0UL;

+	}

+	#endif /* configGENERATE_RUN_TIME_STATS */

+

+	#if ( portUSING_MPU_WRAPPERS == 1 )

+	{

+		vPortStoreTaskMPUSettings( &( pxNewTCB->xMPUSettings ), xRegions, pxNewTCB->pxStack, ulStackDepth );

+	}

+	#else

+	{

+		/* Avoid compiler warning about unreferenced parameter. */

+		( void ) xRegions;

+	}

+	#endif

+

+	#if( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )

+	{

+		for( x = 0; x < ( UBaseType_t ) configNUM_THREAD_LOCAL_STORAGE_POINTERS; x++ )

+		{

+			pxNewTCB->pvThreadLocalStoragePointers[ x ] = NULL;

 		}

-		taskEXIT_CRITICAL();

+	}

+	#endif

+

+	#if ( configUSE_TASK_NOTIFICATIONS == 1 )

+	{

+		pxNewTCB->ulNotifiedValue = 0;

+		pxNewTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;

+	}

+	#endif

+

+	#if ( configUSE_NEWLIB_REENTRANT == 1 )

+	{

+		/* Initialise this task's Newlib reent structure. */

+		_REENT_INIT_PTR( ( &( pxNewTCB->xNewLib_reent ) ) );

+	}

+	#endif

+

+	#if( INCLUDE_xTaskAbortDelay == 1 )

+	{

+		pxNewTCB->ucDelayAborted = pdFALSE;

+	}

+	#endif

+

+	/* Initialize the TCB stack to look as if the task was already running,

+	but had been interrupted by the scheduler.  The return address is set

+	to the start of the task function. Once the stack has been initialised

+	the top of stack variable is updated. */

+	#if( portUSING_MPU_WRAPPERS == 1 )

+	{

+		/* If the port has capability to detect stack overflow,

+		pass the stack end address to the stack initialization

+		function as well. */

+		#if( portHAS_STACK_OVERFLOW_CHECKING == 1 )

+		{

+			#if( portSTACK_GROWTH < 0 )

+			{

+				pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxNewTCB->pxStack, pxTaskCode, pvParameters, xRunPrivileged );

+			}

+			#else /* portSTACK_GROWTH */

+			{

+				pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxNewTCB->pxEndOfStack, pxTaskCode, pvParameters, xRunPrivileged );

+			}

+			#endif /* portSTACK_GROWTH */

+		}

+		#else /* portHAS_STACK_OVERFLOW_CHECKING */

+		{

+			pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters, xRunPrivileged );

+		}

+		#endif /* portHAS_STACK_OVERFLOW_CHECKING */

+	}

+	#else /* portUSING_MPU_WRAPPERS */

+	{

+		/* If the port has capability to detect stack overflow,

+		pass the stack end address to the stack initialization

+		function as well. */

+		#if( portHAS_STACK_OVERFLOW_CHECKING == 1 )

+		{

+			#if( portSTACK_GROWTH < 0 )

+			{

+				pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxNewTCB->pxStack, pxTaskCode, pvParameters );

+			}

+			#else /* portSTACK_GROWTH */

+			{

+				pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxNewTCB->pxEndOfStack, pxTaskCode, pvParameters );

+			}

+			#endif /* portSTACK_GROWTH */

+		}

+		#else /* portHAS_STACK_OVERFLOW_CHECKING */

+		{

+			pxNewTCB->pxTopOfStack = pxPortInitialiseStack( pxTopOfStack, pxTaskCode, pvParameters );

+		}

+		#endif /* portHAS_STACK_OVERFLOW_CHECKING */

+	}

+	#endif /* portUSING_MPU_WRAPPERS */

+

+	if( pxCreatedTask != NULL )

+	{

+		/* Pass the handle out in an anonymous way.  The handle can be used to

+		change the created task's priority, delete the created task, etc.*/

+		*pxCreatedTask = ( TaskHandle_t ) pxNewTCB;

 	}

 	else

 	{

-		xReturn = errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY;

-		traceTASK_CREATE_FAILED();

+		mtCOVERAGE_TEST_MARKER();

 	}

+}

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

 

-	if( xReturn == pdPASS )

+static void prvAddNewTaskToReadyList( TCB_t *pxNewTCB )

+{

+	/* Ensure interrupts don't access the task lists while the lists are being

+	updated. */

+	taskENTER_CRITICAL();

 	{

-		if( xSchedulerRunning != pdFALSE )

+		uxCurrentNumberOfTasks++;

+		if( pxCurrentTCB == NULL )

 		{

-			/* If the created task is of a higher priority than the current task

-			then it should run now. */

-			if( pxCurrentTCB->uxPriority < uxPriority )

+			/* There are no other tasks, or all the other tasks are in

+			the suspended state - make this the current task. */

+			pxCurrentTCB = pxNewTCB;

+

+			if( uxCurrentNumberOfTasks == ( UBaseType_t ) 1 )

 			{

-				taskYIELD_IF_USING_PREEMPTION();

+				/* This is the first task to be created so do the preliminary

+				initialisation required.  We will not recover if this call

+				fails, but we will report the failure. */

+				prvInitialiseTaskLists();

 			}

 			else

 			{

@@ -731,11 +1096,59 @@ StackType_t *pxTopOfStack;
 		}

 		else

 		{

-			mtCOVERAGE_TEST_MARKER();

+			/* If the scheduler is not already running, make this task the

+			current task if it is the highest priority task to be created

+			so far. */

+			if( xSchedulerRunning == pdFALSE )

+			{

+				if( pxCurrentTCB->uxPriority <= pxNewTCB->uxPriority )

+				{

+					pxCurrentTCB = pxNewTCB;

+				}

+				else

+				{

+					mtCOVERAGE_TEST_MARKER();

+				}

+			}

+			else

+			{

+				mtCOVERAGE_TEST_MARKER();

+			}

+		}

+

+		uxTaskNumber++;

+

+		#if ( configUSE_TRACE_FACILITY == 1 )

+		{

+			/* Add a counter into the TCB for tracing only. */

+			pxNewTCB->uxTCBNumber = uxTaskNumber;

 		}

+		#endif /* configUSE_TRACE_FACILITY */

+		traceTASK_CREATE( pxNewTCB );

+

+		prvAddTaskToReadyList( pxNewTCB );

+

+		portSETUP_TCB( pxNewTCB );

 	}

+	taskEXIT_CRITICAL();

 

-	return xReturn;

+	if( xSchedulerRunning != pdFALSE )

+	{

+		/* If the created task is of a higher priority than the current task

+		then it should run now. */

+		if( pxCurrentTCB->uxPriority < pxNewTCB->uxPriority )

+		{

+			taskYIELD_IF_USING_PREEMPTION();

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

 }

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

 

@@ -751,11 +1164,8 @@ StackType_t *pxTopOfStack;
 			being deleted. */

 			pxTCB = prvGetTCBFromHandle( xTaskToDelete );

 

-			/* Remove task from the ready list and place in the	termination list.

-			This will stop the task from be scheduled.  The idle task will check

-			the termination list and free up any memory allocated by the

-			scheduler for the TCB and stack. */

-			if( uxListRemove( &( pxTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )

+			/* Remove task from the ready list. */

+			if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )

 			{

 				taskRESET_READY_PRIORITY( pxTCB->uxPriority );

 			}

@@ -774,16 +1184,42 @@ StackType_t *pxTopOfStack;
 				mtCOVERAGE_TEST_MARKER();

 			}

 

-			vListInsertEnd( &xTasksWaitingTermination, &( pxTCB->xGenericListItem ) );

+			/* Increment the uxTaskNumber also so kernel aware debuggers can

+			detect that the task lists need re-generating.  This is done before

+			portPRE_TASK_DELETE_HOOK() as in the Windows port that macro will

+			not return. */

+			uxTaskNumber++;

 

-			/* Increment the ucTasksDeleted variable so the idle task knows

-			there is a task that has been deleted and that it should therefore

-			check the xTasksWaitingTermination list. */

-			++uxTasksDeleted;

+			if( pxTCB == pxCurrentTCB )

+			{

+				/* A task is deleting itself.  This cannot complete within the

+				task itself, as a context switch to another task is required.

+				Place the task in the termination list.  The idle task will

+				check the termination list and free up any memory allocated by

+				the scheduler for the TCB and stack of the deleted task. */

+				vListInsertEnd( &xTasksWaitingTermination, &( pxTCB->xStateListItem ) );

+

+				/* Increment the ucTasksDeleted variable so the idle task knows

+				there is a task that has been deleted and that it should therefore

+				check the xTasksWaitingTermination list. */

+				++uxDeletedTasksWaitingCleanUp;

 

-			/* Increment the uxTaskNumberVariable also so kernel aware debuggers

-			can detect that the task lists need re-generating. */

-			uxTaskNumber++;

+				/* The pre-delete hook is primarily for the Windows simulator,

+				in which Windows specific clean up operations are performed,

+				after which it is not possible to yield away from this task -

+				hence xYieldPending is used to latch that a context switch is

+				required. */

+				portPRE_TASK_DELETE_HOOK( pxTCB, &xYieldPending );

+			}

+			else

+			{

+				--uxCurrentNumberOfTasks;

+				prvDeleteTCB( pxTCB );

+

+				/* Reset the next expected unblock time in case it referred to

+				the task that has just been deleted. */

+				prvResetNextTaskUnblockTime();

+			}

 

 			traceTASK_DELETE( pxTCB );

 		}

@@ -796,24 +1232,11 @@ StackType_t *pxTopOfStack;
 			if( pxTCB == pxCurrentTCB )

 			{

 				configASSERT( uxSchedulerSuspended == 0 );

-

-				/* The pre-delete hook is primarily for the Windows simulator,

-				in which Windows specific clean up operations are performed,

-				after which it is not possible to yield away from this task -

-				hence xYieldPending is used to latch that a context switch is

-				required. */

-				portPRE_TASK_DELETE_HOOK( pxTCB, &xYieldPending );

 				portYIELD_WITHIN_API();

 			}

 			else

 			{

-				/* Reset the next expected unblock time in case it referred to

-				the task that has just been deleted. */

-				taskENTER_CRITICAL();

-				{

-					prvResetNextTaskUnblockTime();

-				}

-				taskEXIT_CRITICAL();

+				mtCOVERAGE_TEST_MARKER();

 			}

 		}

 	}

@@ -877,23 +1300,11 @@ StackType_t *pxTopOfStack;
 

 			if( xShouldDelay != pdFALSE )

 			{

-				traceTASK_DELAY_UNTIL();

-

-				/* Remove the task from the ready list before adding it to the

-				blocked list as the same list item is used for both lists. */

-				if( uxListRemove( &( pxCurrentTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )

-				{

-					/* The current task must be in a ready list, so there is

-					no need to check, and the port reset macro can be called

-					directly. */

-					portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority );

-				}

-				else

-				{

-					mtCOVERAGE_TEST_MARKER();

-				}

+				traceTASK_DELAY_UNTIL( xTimeToWake );

 

-				prvAddCurrentTaskToDelayedList( xTimeToWake );

+				/* prvAddCurrentTaskToDelayedList() needs the block time, not

+				the time to wake, so subtract the current tick count. */

+				prvAddCurrentTaskToDelayedList( xTimeToWake - xConstTickCount, pdFALSE );

 			}

 			else

 			{

@@ -921,10 +1332,8 @@ StackType_t *pxTopOfStack;
 

 	void vTaskDelay( const TickType_t xTicksToDelay )

 	{

-	TickType_t xTimeToWake;

 	BaseType_t xAlreadyYielded = pdFALSE;

 

-

 		/* A delay time of zero just forces a reschedule. */

 		if( xTicksToDelay > ( TickType_t ) 0U )

 		{

@@ -940,26 +1349,7 @@ StackType_t *pxTopOfStack;
 

 				This task cannot be in an event list as it is the currently

 				executing task. */

-

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

-				not a problem. */

-				xTimeToWake = xTickCount + 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. */

-				if( uxListRemove( &( pxCurrentTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )

-				{

-					/* The current task must be in a ready list, so there is

-					no need to check, and the port reset macro can be called

-					directly. */

-					portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority );

-				}

-				else

-				{

-					mtCOVERAGE_TEST_MARKER();

-				}

-				prvAddCurrentTaskToDelayedList( xTimeToWake );

+				prvAddCurrentTaskToDelayedList( xTicksToDelay, pdFALSE );

 			}

 			xAlreadyYielded = xTaskResumeAll();

 		}

@@ -983,13 +1373,13 @@ StackType_t *pxTopOfStack;
 #endif /* INCLUDE_vTaskDelay */

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

 

-#if ( INCLUDE_eTaskGetState == 1 )

+#if( ( INCLUDE_eTaskGetState == 1 ) || ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_xTaskAbortDelay == 1 ) )

 

 	eTaskState eTaskGetState( TaskHandle_t xTask )

 	{

 	eTaskState eReturn;

-	List_t *pxStateList;

-	const TCB_t * const pxTCB = ( TCB_t * ) xTask;

+	List_t const * pxStateList, *pxDelayedList, *pxOverflowedDelayedList;

+	const TCB_t * const pxTCB = xTask;

 

 		configASSERT( pxTCB );

 

@@ -1002,11 +1392,13 @@ StackType_t *pxTopOfStack;
 		{

 			taskENTER_CRITICAL();

 			{

-				pxStateList = ( List_t * ) listLIST_ITEM_CONTAINER( &( pxTCB->xGenericListItem ) );

+				pxStateList = listLIST_ITEM_CONTAINER( &( pxTCB->xStateListItem ) );

+				pxDelayedList = pxDelayedTaskList;

+				pxOverflowedDelayedList = pxOverflowDelayedTaskList;

 			}

 			taskEXIT_CRITICAL();

 

-			if( ( pxStateList == pxDelayedTaskList ) || ( pxStateList == pxOverflowDelayedTaskList ) )

+			if( ( pxStateList == pxDelayedList ) || ( pxStateList == pxOverflowedDelayedList ) )

 			{

 				/* The task being queried is referenced from one of the Blocked

 				lists. */

@@ -1017,11 +1409,30 @@ StackType_t *pxTopOfStack;
 				else if( pxStateList == &xSuspendedTaskList )

 				{

 					/* The task being queried is referenced from the suspended

-					list.  Is it genuinely suspended or is it block

+					list.  Is it genuinely suspended or is it blocked

 					indefinitely? */

 					if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL )

 					{

-						eReturn = eSuspended;

+						#if( configUSE_TASK_NOTIFICATIONS == 1 )

+						{

+							/* The task does not appear on the event list item of

+							and of the RTOS objects, but could still be in the

+							blocked state if it is waiting on its notification

+							rather than waiting on an object. */

+							if( pxTCB->ucNotifyState == taskWAITING_NOTIFICATION )

+							{

+								eReturn = eBlocked;

+							}

+							else

+							{

+								eReturn = eSuspended;

+							}

+						}

+						#else

+						{

+							eReturn = eSuspended;

+						}

+						#endif

 					}

 					else

 					{

@@ -1031,10 +1442,11 @@ StackType_t *pxTopOfStack;
 			#endif

 

 			#if ( INCLUDE_vTaskDelete == 1 )

-				else if( pxStateList == &xTasksWaitingTermination )

+				else if( ( pxStateList == &xTasksWaitingTermination ) || ( pxStateList == NULL ) )

 				{

 					/* The task being queried is referenced from the deleted

-					tasks list. */

+					tasks list, or it is not referenced from any lists at

+					all. */

 					eReturn = eDeleted;

 				}

 			#endif

@@ -1055,15 +1467,15 @@ StackType_t *pxTopOfStack;
 

 #if ( INCLUDE_uxTaskPriorityGet == 1 )

 

-	UBaseType_t uxTaskPriorityGet( TaskHandle_t xTask )

+	UBaseType_t uxTaskPriorityGet( const TaskHandle_t xTask )

 	{

-	TCB_t *pxTCB;

+	TCB_t const *pxTCB;

 	UBaseType_t uxReturn;

 

 		taskENTER_CRITICAL();

 		{

-			/* If null is passed in here then it is the priority of the that

-			called uxTaskPriorityGet() that is being queried. */

+			/* If null is passed in here then it is the priority of the task

+			that called uxTaskPriorityGet() that is being queried. */

 			pxTCB = prvGetTCBFromHandle( xTask );

 			uxReturn = pxTCB->uxPriority;

 		}

@@ -1077,9 +1489,9 @@ StackType_t *pxTopOfStack;
 

 #if ( INCLUDE_uxTaskPriorityGet == 1 )

 

-	UBaseType_t uxTaskPriorityGetFromISR( TaskHandle_t xTask )

+	UBaseType_t uxTaskPriorityGetFromISR( const TaskHandle_t xTask )

 	{

-	TCB_t *pxTCB;

+	TCB_t const *pxTCB;

 	UBaseType_t uxReturn, uxSavedInterruptState;

 

 		/* RTOS ports that support interrupt nesting have the concept of a

@@ -1097,7 +1509,7 @@ StackType_t *pxTopOfStack;
 		separate interrupt safe API to ensure interrupt entry is as fast and as

 		simple as possible.  More information (albeit Cortex-M specific) is

 		provided on the following link:

-		http://www.freertos.org/RTOS-Cortex-M3-M4.html */

+		https://www.freertos.org/RTOS-Cortex-M3-M4.html */

 		portASSERT_IF_INTERRUPT_PRIORITY_INVALID();

 

 		uxSavedInterruptState = portSET_INTERRUPT_MASK_FROM_ISR();

@@ -1233,15 +1645,15 @@ StackType_t *pxTopOfStack;
 				}

 

 				/* If the task is in the blocked or suspended list we need do

-				nothing more than change it's priority variable. However, if

+				nothing more than change its priority variable. However, if

 				the task is in a ready list it needs to be removed and placed

 				in the list appropriate to its new priority. */

-				if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ uxPriorityUsedOnEntry ] ), &( pxTCB->xGenericListItem ) ) != pdFALSE )

+				if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ uxPriorityUsedOnEntry ] ), &( pxTCB->xStateListItem ) ) != pdFALSE )

 				{

-					/* The task is currently in its ready list - remove before adding

-					it to it's new ready list.  As we are in a critical section we

-					can do this even if the scheduler is suspended. */

-					if( uxListRemove( &( pxTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )

+					/* The task is currently in its ready list - remove before

+					adding it to it's new ready list.  As we are in a critical

+					section we can do this even if the scheduler is suspended. */

+					if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )

 					{

 						/* It is known that the task is in its ready list so

 						there is no need to check again and the port level

@@ -1259,7 +1671,7 @@ StackType_t *pxTopOfStack;
 					mtCOVERAGE_TEST_MARKER();

 				}

 

-				if( xYieldRequired == pdTRUE )

+				if( xYieldRequired != pdFALSE )

 				{

 					taskYIELD_IF_USING_PREEMPTION();

 				}

@@ -1295,7 +1707,7 @@ StackType_t *pxTopOfStack;
 

 			/* Remove task from the ready/delayed list and place in the

 			suspended list. */

-			if( uxListRemove( &( pxTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )

+			if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )

 			{

 				taskRESET_READY_PRIORITY( pxTCB->uxPriority );

 			}

@@ -1314,10 +1726,36 @@ StackType_t *pxTopOfStack;
 				mtCOVERAGE_TEST_MARKER();

 			}

 

-			vListInsertEnd( &xSuspendedTaskList, &( pxTCB->xGenericListItem ) );

+			vListInsertEnd( &xSuspendedTaskList, &( pxTCB->xStateListItem ) );

+

+			#if( configUSE_TASK_NOTIFICATIONS == 1 )

+			{

+				if( pxTCB->ucNotifyState == taskWAITING_NOTIFICATION )

+				{

+					/* The task was blocked to wait for a notification, but is

+					now suspended, so no notification was received. */

+					pxTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;

+				}

+			}

+			#endif

 		}

 		taskEXIT_CRITICAL();

 

+		if( xSchedulerRunning != pdFALSE )

+		{

+			/* Reset the next expected unblock time in case it referred to the

+			task that is now in the Suspended state. */

+			taskENTER_CRITICAL();

+			{

+				prvResetNextTaskUnblockTime();

+			}

+			taskEXIT_CRITICAL();

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+

 		if( pxTCB == pxCurrentTCB )

 		{

 			if( xSchedulerRunning != pdFALSE )

@@ -1331,7 +1769,7 @@ StackType_t *pxTopOfStack;
 				/* The scheduler is not running, but the task that was pointed

 				to by pxCurrentTCB has just been suspended and pxCurrentTCB

 				must be adjusted to point to a different task. */

-				if( listCURRENT_LIST_LENGTH( &xSuspendedTaskList ) == uxCurrentNumberOfTasks )

+				if( listCURRENT_LIST_LENGTH( &xSuspendedTaskList ) == uxCurrentNumberOfTasks ) /*lint !e931 Right has no side effect, just volatile. */

 				{

 					/* No other tasks are ready, so set pxCurrentTCB back to

 					NULL so when the next task is created pxCurrentTCB will

@@ -1347,21 +1785,7 @@ StackType_t *pxTopOfStack;
 		}

 		else

 		{

-			if( xSchedulerRunning != pdFALSE )

-			{

-				/* A task other than the currently running task was suspended,

-				reset the next expected unblock time in case it referred to the

-				task that is now in the Suspended state. */

-				taskENTER_CRITICAL();

-				{

-					prvResetNextTaskUnblockTime();

-				}

-				taskEXIT_CRITICAL();

-			}

-			else

-			{

-				mtCOVERAGE_TEST_MARKER();

-			}

+			mtCOVERAGE_TEST_MARKER();

 		}

 	}

 

@@ -1373,7 +1797,7 @@ StackType_t *pxTopOfStack;
 	static BaseType_t prvTaskIsTaskSuspended( const TaskHandle_t xTask )

 	{

 	BaseType_t xReturn = pdFALSE;

-	const TCB_t * const pxTCB = ( TCB_t * ) xTask;

+	const TCB_t * const pxTCB = xTask;

 

 		/* Accesses xPendingReadyList so must be called from a critical

 		section. */

@@ -1382,14 +1806,14 @@ StackType_t *pxTopOfStack;
 		configASSERT( xTask );

 

 		/* Is the task being resumed actually in the suspended list? */

-		if( listIS_CONTAINED_WITHIN( &xSuspendedTaskList, &( pxTCB->xGenericListItem ) ) != pdFALSE )

+		if( listIS_CONTAINED_WITHIN( &xSuspendedTaskList, &( pxTCB->xStateListItem ) ) != pdFALSE )

 		{

 			/* Has the task already been resumed from within an ISR? */

 			if( listIS_CONTAINED_WITHIN( &xPendingReadyList, &( pxTCB->xEventListItem ) ) == pdFALSE )

 			{

 				/* Is it in the suspended list because it is in the	Suspended

 				state, or because is is blocked with no timeout? */

-				if( listIS_CONTAINED_WITHIN( NULL, &( pxTCB->xEventListItem ) ) != pdFALSE )

+				if( listIS_CONTAINED_WITHIN( NULL, &( pxTCB->xEventListItem ) ) != pdFALSE ) /*lint !e961.  The cast is only redundant when NULL is used. */

 				{

 					xReturn = pdTRUE;

 				}

@@ -1418,27 +1842,27 @@ StackType_t *pxTopOfStack;
 

 	void vTaskResume( TaskHandle_t xTaskToResume )

 	{

-	TCB_t * const pxTCB = ( TCB_t * ) xTaskToResume;

+	TCB_t * const pxTCB = xTaskToResume;

 

 		/* It does not make sense to resume the calling task. */

 		configASSERT( xTaskToResume );

 

 		/* The parameter cannot be NULL as it is impossible to resume the

 		currently executing task. */

-		if( ( pxTCB != NULL ) && ( pxTCB != pxCurrentTCB ) )

+		if( ( pxTCB != pxCurrentTCB ) && ( pxTCB != NULL ) )

 		{

 			taskENTER_CRITICAL();

 			{

-				if( prvTaskIsTaskSuspended( pxTCB ) == pdTRUE )

+				if( prvTaskIsTaskSuspended( pxTCB ) != pdFALSE )

 				{

 					traceTASK_RESUME( pxTCB );

 

-					/* As we are in a critical section we can access the ready

-					lists even if the scheduler is suspended. */

-					( void ) uxListRemove(  &( pxTCB->xGenericListItem ) );

+					/* The ready list can be accessed even if the scheduler is

+					suspended because this is inside a critical section. */

+					( void ) uxListRemove(  &( pxTCB->xStateListItem ) );

 					prvAddTaskToReadyList( pxTCB );

 

-					/* We may have just resumed a higher priority task. */

+					/* A higher priority task may have just been resumed. */

 					if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )

 					{

 						/* This yield may not cause the task just resumed to run,

@@ -1473,7 +1897,7 @@ StackType_t *pxTopOfStack;
 	BaseType_t xTaskResumeFromISR( TaskHandle_t xTaskToResume )

 	{

 	BaseType_t xYieldRequired = pdFALSE;

-	TCB_t * const pxTCB = ( TCB_t * ) xTaskToResume;

+	TCB_t * const pxTCB = xTaskToResume;

 	UBaseType_t uxSavedInterruptStatus;

 

 		configASSERT( xTaskToResume );

@@ -1493,12 +1917,12 @@ StackType_t *pxTopOfStack;
 		separate interrupt safe API to ensure interrupt entry is as fast and as

 		simple as possible.  More information (albeit Cortex-M specific) is

 		provided on the following link:

-		http://www.freertos.org/RTOS-Cortex-M3-M4.html */

+		https://www.freertos.org/RTOS-Cortex-M3-M4.html */

 		portASSERT_IF_INTERRUPT_PRIORITY_INVALID();

 

 		uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();

 		{

-			if( prvTaskIsTaskSuspended( pxTCB ) == pdTRUE )

+			if( prvTaskIsTaskSuspended( pxTCB ) != pdFALSE )

 			{

 				traceTASK_RESUME_FROM_ISR( pxTCB );

 

@@ -1516,7 +1940,7 @@ StackType_t *pxTopOfStack;
 						mtCOVERAGE_TEST_MARKER();

 					}

 

-					( void ) uxListRemove(  &( pxTCB->xGenericListItem ) );

+					( void ) uxListRemove( &( pxTCB->xStateListItem ) );

 					prvAddTaskToReadyList( pxTCB );

 				}

 				else

@@ -1545,18 +1969,43 @@ void vTaskStartScheduler( void )
 BaseType_t xReturn;

 

 	/* Add the idle task at the lowest priority. */

-	#if ( INCLUDE_xTaskGetIdleTaskHandle == 1 )

+	#if( configSUPPORT_STATIC_ALLOCATION == 1 )

 	{

-		/* Create the idle task, storing its handle in xIdleTaskHandle so it can

-		be returned by the xTaskGetIdleTaskHandle() function. */

-		xReturn = xTaskCreate( prvIdleTask, "IDLE", tskIDLE_STACK_SIZE, ( void * ) NULL, ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), &xIdleTaskHandle ); /*lint !e961 MISRA exception, justified as it is not a redundant explicit cast to all supported compilers. */

+		StaticTask_t *pxIdleTaskTCBBuffer = NULL;

+		StackType_t *pxIdleTaskStackBuffer = NULL;

+		uint32_t ulIdleTaskStackSize;

+

+		/* The Idle task is created using user provided RAM - obtain the

+		address of the RAM then create the idle task. */

+		vApplicationGetIdleTaskMemory( &pxIdleTaskTCBBuffer, &pxIdleTaskStackBuffer, &ulIdleTaskStackSize );

+		xIdleTaskHandle = xTaskCreateStatic(	prvIdleTask,

+												configIDLE_TASK_NAME,

+												ulIdleTaskStackSize,

+												( void * ) NULL, /*lint !e961.  The cast is not redundant for all compilers. */

+												portPRIVILEGE_BIT, /* In effect ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), but tskIDLE_PRIORITY is zero. */

+												pxIdleTaskStackBuffer,

+												pxIdleTaskTCBBuffer ); /*lint !e961 MISRA exception, justified as it is not a redundant explicit cast to all supported compilers. */

+

+		if( xIdleTaskHandle != NULL )

+		{

+			xReturn = pdPASS;

+		}

+		else

+		{

+			xReturn = pdFAIL;

+		}

 	}

 	#else

 	{

-		/* Create the idle task without storing its handle. */

-		xReturn = xTaskCreate( prvIdleTask, "IDLE", tskIDLE_STACK_SIZE, ( void * ) NULL, ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), NULL );  /*lint !e961 MISRA exception, justified as it is not a redundant explicit cast to all supported compilers. */

+		/* The Idle task is being created using dynamically allocated RAM. */

+		xReturn = xTaskCreate(	prvIdleTask,

+								configIDLE_TASK_NAME,

+								configMINIMAL_STACK_SIZE,

+								( void * ) NULL,

+								portPRIVILEGE_BIT, /* In effect ( tskIDLE_PRIORITY | portPRIVILEGE_BIT ), but tskIDLE_PRIORITY is zero. */

+								&xIdleTaskHandle ); /*lint !e961 MISRA exception, justified as it is not a redundant explicit cast to all supported compilers. */

 	}

-	#endif /* INCLUDE_xTaskGetIdleTaskHandle */

+	#endif /* configSUPPORT_STATIC_ALLOCATION */

 

 	#if ( configUSE_TIMERS == 1 )

 	{

@@ -1573,6 +2022,15 @@ BaseType_t xReturn;
 

 	if( xReturn == pdPASS )

 	{

+		/* freertos_tasks_c_additions_init() should only be called if the user

+		definable macro FREERTOS_TASKS_C_ADDITIONS_INIT() is defined, as that is

+		the only macro called by the function. */

+		#ifdef FREERTOS_TASKS_C_ADDITIONS_INIT

+		{

+			freertos_tasks_c_additions_init();

+		}

+		#endif

+

 		/* Interrupts are turned off here, to ensure a tick does not occur

 		before or during the call to xPortStartScheduler().  The stacks of

 		the created tasks contain a status word with interrupts switched on

@@ -1590,13 +2048,18 @@ BaseType_t xReturn;
 

 		xNextTaskUnblockTime = portMAX_DELAY;

 		xSchedulerRunning = pdTRUE;

-		xTickCount = ( TickType_t ) 0U;

+		xTickCount = ( TickType_t ) configINITIAL_TICK_COUNT;

 

 		/* If configGENERATE_RUN_TIME_STATS is defined then the following

 		macro must be defined to configure the timer/counter used to generate

-		the run time counter time base. */

+		the run time counter time base.   NOTE:  If configGENERATE_RUN_TIME_STATS

+		is set to 0 and the following line fails to build then ensure you do not

+		have portCONFIGURE_TIMER_FOR_RUN_TIME_STATS() defined in your

+		FreeRTOSConfig.h file. */

 		portCONFIGURE_TIMER_FOR_RUN_TIME_STATS();

 

+		traceTASK_SWITCHED_IN();

+

 		/* Setting up the timer tick is hardware specific and thus in the

 		portable interface. */

 		if( xPortStartScheduler() != pdFALSE )

@@ -1614,8 +2077,12 @@ BaseType_t xReturn;
 		/* This line will only be reached if the kernel could not be started,

 		because there was not enough FreeRTOS heap to create the idle task

 		or the timer task. */

-		configASSERT( xReturn );

+		configASSERT( xReturn != errCOULD_NOT_ALLOCATE_REQUIRED_MEMORY );

 	}

+

+	/* Prevent compiler warnings if INCLUDE_xTaskGetIdleTaskHandle is set to 0,

+	meaning xIdleTaskHandle is not used anywhere else. */

+	( void ) xIdleTaskHandle;

 }

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

 

@@ -1645,6 +2112,34 @@ void vTaskSuspendAll( void )
 	static TickType_t prvGetExpectedIdleTime( void )

 	{

 	TickType_t xReturn;

+	UBaseType_t uxHigherPriorityReadyTasks = pdFALSE;

+

+		/* uxHigherPriorityReadyTasks takes care of the case where

+		configUSE_PREEMPTION is 0, so there may be tasks above the idle priority

+		task that are in the Ready state, even though the idle task is

+		running. */

+		#if( configUSE_PORT_OPTIMISED_TASK_SELECTION == 0 )

+		{

+			if( uxTopReadyPriority > tskIDLE_PRIORITY )

+			{

+				uxHigherPriorityReadyTasks = pdTRUE;

+			}

+		}

+		#else

+		{

+			const UBaseType_t uxLeastSignificantBit = ( UBaseType_t ) 0x01;

+

+			/* When port optimised task selection is used the uxTopReadyPriority

+			variable is used as a bit map.  If bits other than the least

+			significant bit are set then there are tasks that have a priority

+			above the idle priority that are in the Ready state.  This takes

+			care of the case where the co-operative scheduler is in use. */

+			if( uxTopReadyPriority > uxLeastSignificantBit )

+			{

+				uxHigherPriorityReadyTasks = pdTRUE;

+			}

+		}

+		#endif

 

 		if( pxCurrentTCB->uxPriority > tskIDLE_PRIORITY )

 		{

@@ -1657,6 +2152,13 @@ void vTaskSuspendAll( void )
 			processed. */

 			xReturn = 0;

 		}

+		else if( uxHigherPriorityReadyTasks != pdFALSE )

+		{

+			/* There are tasks in the Ready state that have a priority above the

+			idle priority.  This path can only be reached if

+			configUSE_PREEMPTION is 0. */

+			xReturn = 0;

+		}

 		else

 		{

 			xReturn = xNextTaskUnblockTime - xTickCount;

@@ -1670,7 +2172,7 @@ void vTaskSuspendAll( void )
 

 BaseType_t xTaskResumeAll( void )

 {

-TCB_t *pxTCB;

+TCB_t *pxTCB = NULL;

 BaseType_t xAlreadyYielded = pdFALSE;

 

 	/* If uxSchedulerSuspended is zero then this function does not match a

@@ -1694,9 +2196,9 @@ BaseType_t xAlreadyYielded = pdFALSE;
 				appropriate ready list. */

 				while( listLIST_IS_EMPTY( &xPendingReadyList ) == pdFALSE )

 				{

-					pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( ( &xPendingReadyList ) );

+					pxTCB = listGET_OWNER_OF_HEAD_ENTRY( ( &xPendingReadyList ) ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too.  Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */

 					( void ) uxListRemove( &( pxTCB->xEventListItem ) );

-					( void ) uxListRemove( &( pxTCB->xGenericListItem ) );

+					( void ) uxListRemove( &( pxTCB->xStateListItem ) );

 					prvAddTaskToReadyList( pxTCB );

 

 					/* If the moved task has a priority higher than the current

@@ -1711,31 +2213,48 @@ BaseType_t xAlreadyYielded = pdFALSE;
 					}

 				}

 

+				if( pxTCB != NULL )

+				{

+					/* A task was unblocked while the scheduler was suspended,

+					which may have prevented the next unblock time from being

+					re-calculated, in which case re-calculate it now.  Mainly

+					important for low power tickless implementations, where

+					this can prevent an unnecessary exit from low power

+					state. */

+					prvResetNextTaskUnblockTime();

+				}

+

 				/* If any ticks occurred while the scheduler was suspended then

 				they should be processed now.  This ensures the tick count does

 				not	slip, and that any delayed tasks are resumed at the correct

 				time. */

-				if( uxPendedTicks > ( UBaseType_t ) 0U )

 				{

-					while( uxPendedTicks > ( UBaseType_t ) 0U )

+					UBaseType_t uxPendedCounts = uxPendedTicks; /* Non-volatile copy. */

+

+					if( uxPendedCounts > ( UBaseType_t ) 0U )

 					{

-						if( xTaskIncrementTick() != pdFALSE )

+						do

 						{

-							xYieldPending = pdTRUE;

-						}

-						else

-						{

-							mtCOVERAGE_TEST_MARKER();

-						}

-						--uxPendedTicks;

+							if( xTaskIncrementTick() != pdFALSE )

+							{

+								xYieldPending = pdTRUE;

+							}

+							else

+							{

+								mtCOVERAGE_TEST_MARKER();

+							}

+							--uxPendedCounts;

+						} while( uxPendedCounts > ( UBaseType_t ) 0U );

+

+						uxPendedTicks = 0;

+					}

+					else

+					{

+						mtCOVERAGE_TEST_MARKER();

 					}

-				}

-				else

-				{

-					mtCOVERAGE_TEST_MARKER();

 				}

 

-				if( xYieldPending == pdTRUE )

+				if( xYieldPending != pdFALSE )

 				{

 					#if( configUSE_PREEMPTION != 0 )

 					{

@@ -1794,7 +2313,7 @@ UBaseType_t uxSavedInterruptStatus;
 	system call	interrupt priority.  FreeRTOS maintains a separate interrupt

 	safe API to ensure interrupt entry is as fast and as simple as possible.

 	More information (albeit Cortex-M specific) is provided on the following

-	link: http://www.freertos.org/RTOS-Cortex-M3-M4.html */

+	link: https://www.freertos.org/RTOS-Cortex-M3-M4.html */

 	portASSERT_IF_INTERRUPT_PRIORITY_INVALID();

 

 	uxSavedInterruptStatus = portTICK_TYPE_SET_INTERRUPT_MASK_FROM_ISR();

@@ -1815,19 +2334,149 @@ UBaseType_t uxTaskGetNumberOfTasks( void )
 }

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

 

-#if ( INCLUDE_pcTaskGetTaskName == 1 )

+char *pcTaskGetName( TaskHandle_t xTaskToQuery ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+{

+TCB_t *pxTCB;

+

+	/* If null is passed in here then the name of the calling task is being

+	queried. */

+	pxTCB = prvGetTCBFromHandle( xTaskToQuery );

+	configASSERT( pxTCB );

+	return &( pxTCB->pcTaskName[ 0 ] );

+}

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

 

-	char *pcTaskGetTaskName( TaskHandle_t xTaskToQuery ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+#if ( INCLUDE_xTaskGetHandle == 1 )

+

+	static TCB_t *prvSearchForNameWithinSingleList( List_t *pxList, const char pcNameToQuery[] )

 	{

-	TCB_t *pxTCB;

+	TCB_t *pxNextTCB, *pxFirstTCB, *pxReturn = NULL;

+	UBaseType_t x;

+	char cNextChar;

+	BaseType_t xBreakLoop;

 

-		/* If null is passed in here then the name of the calling task is being queried. */

-		pxTCB = prvGetTCBFromHandle( xTaskToQuery );

-		configASSERT( pxTCB );

-		return &( pxTCB->pcTaskName[ 0 ] );

+		/* This function is called with the scheduler suspended. */

+

+		if( listCURRENT_LIST_LENGTH( pxList ) > ( UBaseType_t ) 0 )

+		{

+			listGET_OWNER_OF_NEXT_ENTRY( pxFirstTCB, pxList );  /*lint !e9079 void * is used as this macro is used with timers and co-routines too.  Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */

+

+			do

+			{

+				listGET_OWNER_OF_NEXT_ENTRY( pxNextTCB, pxList ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too.  Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */

+

+				/* Check each character in the name looking for a match or

+				mismatch. */

+				xBreakLoop = pdFALSE;

+				for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )

+				{

+					cNextChar = pxNextTCB->pcTaskName[ x ];

+

+					if( cNextChar != pcNameToQuery[ x ] )

+					{

+						/* Characters didn't match. */

+						xBreakLoop = pdTRUE;

+					}

+					else if( cNextChar == ( char ) 0x00 )

+					{

+						/* Both strings terminated, a match must have been

+						found. */

+						pxReturn = pxNextTCB;

+						xBreakLoop = pdTRUE;

+					}

+					else

+					{

+						mtCOVERAGE_TEST_MARKER();

+					}

+

+					if( xBreakLoop != pdFALSE )

+					{

+						break;

+					}

+				}

+

+				if( pxReturn != NULL )

+				{

+					/* The handle has been found. */

+					break;

+				}

+

+			} while( pxNextTCB != pxFirstTCB );

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+

+		return pxReturn;

+	}

+

+#endif /* INCLUDE_xTaskGetHandle */

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

+

+#if ( INCLUDE_xTaskGetHandle == 1 )

+

+	TaskHandle_t xTaskGetHandle( const char *pcNameToQuery ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+	{

+	UBaseType_t uxQueue = configMAX_PRIORITIES;

+	TCB_t* pxTCB;

+

+		/* Task names will be truncated to configMAX_TASK_NAME_LEN - 1 bytes. */

+		configASSERT( strlen( pcNameToQuery ) < configMAX_TASK_NAME_LEN );

+

+		vTaskSuspendAll();

+		{

+			/* Search the ready lists. */

+			do

+			{

+				uxQueue--;

+				pxTCB = prvSearchForNameWithinSingleList( ( List_t * ) &( pxReadyTasksLists[ uxQueue ] ), pcNameToQuery );

+

+				if( pxTCB != NULL )

+				{

+					/* Found the handle. */

+					break;

+				}

+

+			} while( uxQueue > ( UBaseType_t ) tskIDLE_PRIORITY ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */

+

+			/* Search the delayed lists. */

+			if( pxTCB == NULL )

+			{

+				pxTCB = prvSearchForNameWithinSingleList( ( List_t * ) pxDelayedTaskList, pcNameToQuery );

+			}

+

+			if( pxTCB == NULL )

+			{

+				pxTCB = prvSearchForNameWithinSingleList( ( List_t * ) pxOverflowDelayedTaskList, pcNameToQuery );

+			}

+

+			#if ( INCLUDE_vTaskSuspend == 1 )

+			{

+				if( pxTCB == NULL )

+				{

+					/* Search the suspended list. */

+					pxTCB = prvSearchForNameWithinSingleList( &xSuspendedTaskList, pcNameToQuery );

+				}

+			}

+			#endif

+

+			#if( INCLUDE_vTaskDelete == 1 )

+			{

+				if( pxTCB == NULL )

+				{

+					/* Search the deleted list. */

+					pxTCB = prvSearchForNameWithinSingleList( &xTasksWaitingTermination, pcNameToQuery );

+				}

+			}

+			#endif

+		}

+		( void ) xTaskResumeAll();

+

+		return pxTCB;

 	}

 

-#endif /* INCLUDE_pcTaskGetTaskName */

+#endif /* INCLUDE_xTaskGetHandle */

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

 

 #if ( configUSE_TRACE_FACILITY == 1 )

@@ -1846,20 +2495,20 @@ UBaseType_t uxTaskGetNumberOfTasks( void )
 				do

 				{

 					uxQueue--;

-					uxTask += prvListTaskWithinSingleList( &( pxTaskStatusArray[ uxTask ] ), &( pxReadyTasksLists[ uxQueue ] ), eReady );

+					uxTask += prvListTasksWithinSingleList( &( pxTaskStatusArray[ uxTask ] ), &( pxReadyTasksLists[ uxQueue ] ), eReady );

 

 				} while( uxQueue > ( UBaseType_t ) tskIDLE_PRIORITY ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */

 

 				/* Fill in an TaskStatus_t structure with information on each

 				task in the Blocked state. */

-				uxTask += prvListTaskWithinSingleList( &( pxTaskStatusArray[ uxTask ] ), ( List_t * ) pxDelayedTaskList, eBlocked );

-				uxTask += prvListTaskWithinSingleList( &( pxTaskStatusArray[ uxTask ] ), ( List_t * ) pxOverflowDelayedTaskList, eBlocked );

+				uxTask += prvListTasksWithinSingleList( &( pxTaskStatusArray[ uxTask ] ), ( List_t * ) pxDelayedTaskList, eBlocked );

+				uxTask += prvListTasksWithinSingleList( &( pxTaskStatusArray[ uxTask ] ), ( List_t * ) pxOverflowDelayedTaskList, eBlocked );

 

 				#if( INCLUDE_vTaskDelete == 1 )

 				{

 					/* Fill in an TaskStatus_t structure with information on

 					each task that has been deleted but not yet cleaned up. */

-					uxTask += prvListTaskWithinSingleList( &( pxTaskStatusArray[ uxTask ] ), &xTasksWaitingTermination, eDeleted );

+					uxTask += prvListTasksWithinSingleList( &( pxTaskStatusArray[ uxTask ] ), &xTasksWaitingTermination, eDeleted );

 				}

 				#endif

 

@@ -1867,7 +2516,7 @@ UBaseType_t uxTaskGetNumberOfTasks( void )
 				{

 					/* Fill in an TaskStatus_t structure with information on

 					each task in the Suspended state. */

-					uxTask += prvListTaskWithinSingleList( &( pxTaskStatusArray[ uxTask ] ), &xSuspendedTaskList, eSuspended );

+					uxTask += prvListTasksWithinSingleList( &( pxTaskStatusArray[ uxTask ] ), &xSuspendedTaskList, eSuspended );

 				}

 				#endif

 

@@ -1936,6 +2585,82 @@ implementations require configUSE_TICKLESS_IDLE to be set to a value other than
 #endif /* configUSE_TICKLESS_IDLE */

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

 

+#if ( INCLUDE_xTaskAbortDelay == 1 )

+

+	BaseType_t xTaskAbortDelay( TaskHandle_t xTask )

+	{

+	TCB_t *pxTCB = xTask;

+	BaseType_t xReturn;

+

+		configASSERT( pxTCB );

+

+		vTaskSuspendAll();

+		{

+			/* A task can only be prematurely removed from the Blocked state if

+			it is actually in the Blocked state. */

+			if( eTaskGetState( xTask ) == eBlocked )

+			{

+				xReturn = pdPASS;

+

+				/* Remove the reference to the task from the blocked list.  An

+				interrupt won't touch the xStateListItem because the

+				scheduler is suspended. */

+				( void ) uxListRemove( &( pxTCB->xStateListItem ) );

+

+				/* Is the task waiting on an event also?  If so remove it from

+				the event list too.  Interrupts can touch the event list item,

+				even though the scheduler is suspended, so a critical section

+				is used. */

+				taskENTER_CRITICAL();

+				{

+					if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )

+					{

+						( void ) uxListRemove( &( pxTCB->xEventListItem ) );

+						pxTCB->ucDelayAborted = pdTRUE;

+					}

+					else

+					{

+						mtCOVERAGE_TEST_MARKER();

+					}

+				}

+				taskEXIT_CRITICAL();

+

+				/* Place the unblocked task into the appropriate ready list. */

+				prvAddTaskToReadyList( pxTCB );

+

+				/* A task being unblocked cannot cause an immediate context

+				switch if preemption is turned off. */

+				#if (  configUSE_PREEMPTION == 1 )

+				{

+					/* Preemption is on, but a context switch should only be

+					performed if the unblocked task has a priority that is

+					equal to or higher than the currently executing task. */

+					if( pxTCB->uxPriority > pxCurrentTCB->uxPriority )

+					{

+						/* Pend the yield to be performed when the scheduler

+						is unsuspended. */

+						xYieldPending = pdTRUE;

+					}

+					else

+					{

+						mtCOVERAGE_TEST_MARKER();

+					}

+				}

+				#endif /* configUSE_PREEMPTION */

+			}

+			else

+			{

+				xReturn = pdFAIL;

+			}

+		}

+		( void ) xTaskResumeAll();

+

+		return xReturn;

+	}

+

+#endif /* INCLUDE_xTaskAbortDelay */

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

+

 BaseType_t xTaskIncrementTick( void )

 {

 TCB_t * pxTCB;

@@ -1948,103 +2673,101 @@ BaseType_t xSwitchRequired = pdFALSE;
 	traceTASK_INCREMENT_TICK( xTickCount );

 	if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )

 	{

+		/* Minor optimisation.  The tick count cannot change in this

+		block. */

+		const TickType_t xConstTickCount = xTickCount + ( TickType_t ) 1;

+

 		/* Increment the RTOS tick, switching the delayed and overflowed

 		delayed lists if it wraps to 0. */

-		++xTickCount;

+		xTickCount = xConstTickCount;

 

+		if( xConstTickCount == ( TickType_t ) 0U ) /*lint !e774 'if' does not always evaluate to false as it is looking for an overflow. */

 		{

-			/* Minor optimisation.  The tick count cannot change in this

-			block. */

-			const TickType_t xConstTickCount = xTickCount;

-

-			if( xConstTickCount == ( TickType_t ) 0U )

-			{

-				taskSWITCH_DELAYED_LISTS();

-			}

-			else

-			{

-				mtCOVERAGE_TEST_MARKER();

-			}

+			taskSWITCH_DELAYED_LISTS();

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

 

-			/* See if this tick has made a timeout expire.  Tasks are stored in

-			the	queue in the order of their wake time - meaning once one task

-			has been found whose block time has not expired there is no need to

-			look any further down the list. */

-			if( xConstTickCount >= xNextTaskUnblockTime )

+		/* See if this tick has made a timeout expire.  Tasks are stored in

+		the	queue in the order of their wake time - meaning once one task

+		has been found whose block time has not expired there is no need to

+		look any further down the list. */

+		if( xConstTickCount >= xNextTaskUnblockTime )

+		{

+			for( ;; )

 			{

-				for( ;; )

+				if( listLIST_IS_EMPTY( pxDelayedTaskList ) != pdFALSE )

+				{

+					/* The delayed list is empty.  Set xNextTaskUnblockTime

+					to the maximum possible value so it is extremely

+					unlikely that the

+					if( xTickCount >= xNextTaskUnblockTime ) test will pass

+					next time through. */

+					xNextTaskUnblockTime = portMAX_DELAY; /*lint !e961 MISRA exception as the casts are only redundant for some ports. */

+					break;

+				}

+				else

 				{

-					if( listLIST_IS_EMPTY( pxDelayedTaskList ) != pdFALSE )

+					/* The delayed list is not empty, get the value of the

+					item at the head of the delayed list.  This is the time

+					at which the task at the head of the delayed list must

+					be removed from the Blocked state. */

+					pxTCB = listGET_OWNER_OF_HEAD_ENTRY( pxDelayedTaskList ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too.  Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */

+					xItemValue = listGET_LIST_ITEM_VALUE( &( pxTCB->xStateListItem ) );

+

+					if( xConstTickCount < xItemValue )

 					{

-						/* The delayed list is empty.  Set xNextTaskUnblockTime

-						to the maximum possible value so it is extremely

-						unlikely that the

-						if( xTickCount >= xNextTaskUnblockTime ) test will pass

-						next time through. */

-						xNextTaskUnblockTime = portMAX_DELAY;

-						break;

+						/* It is not time to unblock this item yet, but the

+						item value is the time at which the task at the head

+						of the blocked list must be removed from the Blocked

+						state -	so record the item value in

+						xNextTaskUnblockTime. */

+						xNextTaskUnblockTime = xItemValue;

+						break; /*lint !e9011 Code structure here is deedmed easier to understand with multiple breaks. */

 					}

 					else

 					{

-						/* The delayed list is not empty, get the value of the

-						item at the head of the delayed list.  This is the time

-						at which the task at the head of the delayed list must

-						be removed from the Blocked state. */

-						pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxDelayedTaskList );

-						xItemValue = listGET_LIST_ITEM_VALUE( &( pxTCB->xGenericListItem ) );

-

-						if( xConstTickCount < xItemValue )

-						{

-							/* It is not time to unblock this item yet, but the

-							item value is the time at which the task at the head

-							of the blocked list must be removed from the Blocked

-							state -	so record the item value in

-							xNextTaskUnblockTime. */

-							xNextTaskUnblockTime = xItemValue;

-							break;

-						}

-						else

-						{

-							mtCOVERAGE_TEST_MARKER();

-						}

+						mtCOVERAGE_TEST_MARKER();

+					}

+

+					/* It is time to remove the item from the Blocked state. */

+					( void ) uxListRemove( &( pxTCB->xStateListItem ) );

+

+					/* Is the task waiting on an event also?  If so remove

+					it from the event list. */

+					if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )

+					{

+						( void ) uxListRemove( &( pxTCB->xEventListItem ) );

+					}

+					else

+					{

+						mtCOVERAGE_TEST_MARKER();

+					}

 

-						/* It is time to remove the item from the Blocked state. */

-						( void ) uxListRemove( &( pxTCB->xGenericListItem ) );

+					/* Place the unblocked task into the appropriate ready

+					list. */

+					prvAddTaskToReadyList( pxTCB );

 

-						/* Is the task waiting on an event also?  If so remove

-						it from the event list. */

-						if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )

+					/* A task being unblocked cannot cause an immediate

+					context switch if preemption is turned off. */

+					#if (  configUSE_PREEMPTION == 1 )

+					{

+						/* Preemption is on, but a context switch should

+						only be performed if the unblocked task has a

+						priority that is equal to or higher than the

+						currently executing task. */

+						if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )

 						{

-							( void ) uxListRemove( &( pxTCB->xEventListItem ) );

+							xSwitchRequired = pdTRUE;

 						}

 						else

 						{

 							mtCOVERAGE_TEST_MARKER();

 						}

-

-						/* Place the unblocked task into the appropriate ready

-						list. */

-						prvAddTaskToReadyList( pxTCB );

-

-						/* A task being unblocked cannot cause an immediate

-						context switch if preemption is turned off. */

-						#if (  configUSE_PREEMPTION == 1 )

-						{

-							/* Preemption is on, but a context switch should

-							only be performed if the unblocked task has a

-							priority that is equal to or higher than the

-							currently executing task. */

-							if( pxTCB->uxPriority >= pxCurrentTCB->uxPriority )

-							{

-								xSwitchRequired = pdTRUE;

-							}

-							else

-							{

-								mtCOVERAGE_TEST_MARKER();

-							}

-						}

-						#endif /* configUSE_PREEMPTION */

 					}

+					#endif /* configUSE_PREEMPTION */

 				}

 			}

 		}

@@ -2124,13 +2847,15 @@ BaseType_t xSwitchRequired = pdFALSE;
 		}

 		else

 		{

-			xTCB = ( TCB_t * ) xTask;

+			xTCB = xTask;

 		}

 

 		/* Save the hook function in the TCB.  A critical section is required as

 		the value can be accessed from an interrupt. */

 		taskENTER_CRITICAL();

+		{

 			xTCB->pxTaskTag = pxHookFunction;

+		}

 		taskEXIT_CRITICAL();

 	}

 

@@ -2141,24 +2866,17 @@ BaseType_t xSwitchRequired = pdFALSE;
 

 	TaskHookFunction_t xTaskGetApplicationTaskTag( TaskHandle_t xTask )

 	{

-	TCB_t *xTCB;

+	TCB_t *pxTCB;

 	TaskHookFunction_t xReturn;

 

-		/* If xTask is NULL then we are setting our own task hook. */

-		if( xTask == NULL )

-		{

-			xTCB = ( TCB_t * ) pxCurrentTCB;

-		}

-		else

-		{

-			xTCB = ( TCB_t * ) xTask;

-		}

+		/* If xTask is NULL then set the calling task's hook. */

+		pxTCB = prvGetTCBFromHandle( xTask );

 

 		/* Save the hook function in the TCB.  A critical section is required as

 		the value can be accessed from an interrupt. */

 		taskENTER_CRITICAL();

 		{

-			xReturn = xTCB->pxTaskTag;

+			xReturn = pxTCB->pxTaskTag;

 		}

 		taskEXIT_CRITICAL();

 

@@ -2170,6 +2888,31 @@ BaseType_t xSwitchRequired = pdFALSE;
 

 #if ( configUSE_APPLICATION_TASK_TAG == 1 )

 

+	TaskHookFunction_t xTaskGetApplicationTaskTagFromISR( TaskHandle_t xTask )

+	{

+	TCB_t *pxTCB;

+	TaskHookFunction_t xReturn;

+	UBaseType_t uxSavedInterruptStatus;

+

+		/* If xTask is NULL then set the calling task's hook. */

+		pxTCB = prvGetTCBFromHandle( xTask );

+

+		/* Save the hook function in the TCB.  A critical section is required as

+		the value can be accessed from an interrupt. */

+		uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();

+		{

+			xReturn = pxTCB->pxTaskTag;

+		}

+		portCLEAR_INTERRUPT_MASK_FROM_ISR( uxSavedInterruptStatus );

+

+		return xReturn;

+	}

+

+#endif /* configUSE_APPLICATION_TASK_TAG */

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

+

+#if ( configUSE_APPLICATION_TASK_TAG == 1 )

+

 	BaseType_t xTaskCallApplicationTaskHook( TaskHandle_t xTask, void *pvParameter )

 	{

 	TCB_t *xTCB;

@@ -2178,11 +2921,11 @@ BaseType_t xSwitchRequired = pdFALSE;
 		/* If xTask is NULL then we are calling our own task hook. */

 		if( xTask == NULL )

 		{

-			xTCB = ( TCB_t * ) pxCurrentTCB;

+			xTCB = pxCurrentTCB;

 		}

 		else

 		{

-			xTCB = ( TCB_t * ) xTask;

+			xTCB = xTask;

 		}

 

 		if( xTCB->pxTaskTag != NULL )

@@ -2215,39 +2958,53 @@ void vTaskSwitchContext( void )
 

 		#if ( configGENERATE_RUN_TIME_STATS == 1 )

 		{

-				#ifdef portALT_GET_RUN_TIME_COUNTER_VALUE

-					portALT_GET_RUN_TIME_COUNTER_VALUE( ulTotalRunTime );

-				#else

-					ulTotalRunTime = portGET_RUN_TIME_COUNTER_VALUE();

-				#endif

+			#ifdef portALT_GET_RUN_TIME_COUNTER_VALUE

+				portALT_GET_RUN_TIME_COUNTER_VALUE( ulTotalRunTime );

+			#else

+				ulTotalRunTime = portGET_RUN_TIME_COUNTER_VALUE();

+			#endif

 

-				/* Add the amount of time the task has been running to the

-				accumulated	time so far.  The time the task started running was

-				stored in ulTaskSwitchedInTime.  Note that there is no overflow

-				protection here	so count values are only valid until the timer

-				overflows.  The guard against negative values is to protect

-				against suspect run time stat counter implementations - which

-				are provided by the application, not the kernel. */

-				if( ulTotalRunTime > ulTaskSwitchedInTime )

-				{

-					pxCurrentTCB->ulRunTimeCounter += ( ulTotalRunTime - ulTaskSwitchedInTime );

-				}

-				else

-				{

-					mtCOVERAGE_TEST_MARKER();

-				}

-				ulTaskSwitchedInTime = ulTotalRunTime;

+			/* Add the amount of time the task has been running to the

+			accumulated time so far.  The time the task started running was

+			stored in ulTaskSwitchedInTime.  Note that there is no overflow

+			protection here so count values are only valid until the timer

+			overflows.  The guard against negative values is to protect

+			against suspect run time stat counter implementations - which

+			are provided by the application, not the kernel. */

+			if( ulTotalRunTime > ulTaskSwitchedInTime )

+			{

+				pxCurrentTCB->ulRunTimeCounter += ( ulTotalRunTime - ulTaskSwitchedInTime );

+			}

+			else

+			{

+				mtCOVERAGE_TEST_MARKER();

+			}

+			ulTaskSwitchedInTime = ulTotalRunTime;

 		}

 		#endif /* configGENERATE_RUN_TIME_STATS */

 

 		/* Check for stack overflow, if configured. */

 		taskCHECK_FOR_STACK_OVERFLOW();

 

+		/* Before the currently running task is switched out, save its errno. */

+		#if( configUSE_POSIX_ERRNO == 1 )

+		{

+			pxCurrentTCB->iTaskErrno = FreeRTOS_errno;

+		}

+		#endif

+

 		/* Select a new task to run using either the generic C or port

 		optimised asm code. */

-		taskSELECT_HIGHEST_PRIORITY_TASK();

+		taskSELECT_HIGHEST_PRIORITY_TASK(); /*lint !e9079 void * is used as this macro is used with timers and co-routines too.  Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */

 		traceTASK_SWITCHED_IN();

 

+		/* After the new task is switched in, update the global errno. */

+		#if( configUSE_POSIX_ERRNO == 1 )

+		{

+			FreeRTOS_errno = pxCurrentTCB->iTaskErrno;

+		}

+		#endif

+

 		#if ( configUSE_NEWLIB_REENTRANT == 1 )

 		{

 			/* Switch Newlib's _impure_ptr variable to point to the _reent

@@ -2261,8 +3018,6 @@ void vTaskSwitchContext( void )
 

 void vTaskPlaceOnEventList( List_t * const pxEventList, const TickType_t xTicksToWait )

 {

-TickType_t xTimeToWake;

-

 	configASSERT( pxEventList );

 

 	/* THIS FUNCTION MUST BE CALLED WITH EITHER INTERRUPTS DISABLED OR THE

@@ -2274,54 +3029,12 @@ TickType_t xTimeToWake;
 	list is locked, preventing simultaneous access from interrupts. */

 	vListInsert( pxEventList, &( pxCurrentTCB->xEventListItem ) );

 

-	/* The task must be removed from from the ready list before it is added to

-	the blocked list as the same list item is used for both lists.  Exclusive

-	access to the ready lists guaranteed because the scheduler is locked. */

-	if( uxListRemove( &( pxCurrentTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )

-	{

-		/* The current task must be in a ready list, so there is no need to

-		check, and the port reset macro can be called directly. */

-		portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority );

-	}

-	else

-	{

-		mtCOVERAGE_TEST_MARKER();

-	}

-

-	#if ( INCLUDE_vTaskSuspend == 1 )

-	{

-		if( xTicksToWait == portMAX_DELAY )

-		{

-			/* Add the task to the suspended task list instead of a delayed task

-			list to ensure the task is not woken by a timing event.  It will

-			block indefinitely. */

-			vListInsertEnd( &xSuspendedTaskList, &( pxCurrentTCB->xGenericListItem ) );

-		}

-		else

-		{

-			/* Calculate the time at which the task should be woken if the event

-			does not occur.  This may overflow but this doesn't matter, the

-			scheduler will handle it. */

-			xTimeToWake = xTickCount + xTicksToWait;

-			prvAddCurrentTaskToDelayedList( xTimeToWake );

-		}

-	}

-	#else /* INCLUDE_vTaskSuspend */

-	{

-			/* Calculate the time at which the task should be woken if the event does

-			not occur.  This may overflow but this doesn't matter, the scheduler

-			will handle it. */

-			xTimeToWake = xTickCount + xTicksToWait;

-			prvAddCurrentTaskToDelayedList( xTimeToWake );

-	}

-	#endif /* INCLUDE_vTaskSuspend */

+	prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );

 }

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

 

 void vTaskPlaceOnUnorderedEventList( List_t * pxEventList, const TickType_t xItemValue, const TickType_t xTicksToWait )

 {

-TickType_t xTimeToWake;

-

 	configASSERT( pxEventList );

 

 	/* THIS FUNCTION MUST BE CALLED WITH THE SCHEDULER SUSPENDED.  It is used by

@@ -2340,56 +3053,14 @@ TickType_t xTimeToWake;
 	the task level). */

 	vListInsertEnd( pxEventList, &( pxCurrentTCB->xEventListItem ) );

 

-	/* The task must be removed from the ready list before it is added to the

-	blocked list.  Exclusive access can be assured to the ready list as the

-	scheduler is locked. */

-	if( uxListRemove( &( pxCurrentTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )

-	{

-		/* The current task must be in a ready list, so there is no need to

-		check, and the port reset macro can be called directly. */

-		portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority );

-	}

-	else

-	{

-		mtCOVERAGE_TEST_MARKER();

-	}

-

-	#if ( INCLUDE_vTaskSuspend == 1 )

-	{

-		if( xTicksToWait == portMAX_DELAY )

-		{

-			/* Add the task to the suspended task list instead of a delayed task

-			list to ensure it is not woken by a timing event.  It will block

-			indefinitely. */

-			vListInsertEnd( &xSuspendedTaskList, &( pxCurrentTCB->xGenericListItem ) );

-		}

-		else

-		{

-			/* Calculate the time at which the task should be woken if the event

-			does not occur.  This may overflow but this doesn't matter, the

-			kernel will manage it correctly. */

-			xTimeToWake = xTickCount + xTicksToWait;

-			prvAddCurrentTaskToDelayedList( xTimeToWake );

-		}

-	}

-	#else /* INCLUDE_vTaskSuspend */

-	{

-			/* Calculate the time at which the task should be woken if the event does

-			not occur.  This may overflow but this doesn't matter, the kernel

-			will manage it correctly. */

-			xTimeToWake = xTickCount + xTicksToWait;

-			prvAddCurrentTaskToDelayedList( xTimeToWake );

-	}

-	#endif /* INCLUDE_vTaskSuspend */

+	prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );

 }

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

 

-#if configUSE_TIMERS == 1

+#if( configUSE_TIMERS == 1 )

 

-	void vTaskPlaceOnEventListRestricted( List_t * const pxEventList, const TickType_t xTicksToWait, const BaseType_t xWaitIndefinitely )

+	void vTaskPlaceOnEventListRestricted( List_t * const pxEventList, TickType_t xTicksToWait, const BaseType_t xWaitIndefinitely )

 	{

-	TickType_t xTimeToWake;

-

 		configASSERT( pxEventList );

 

 		/* This function should not be called by application code hence the

@@ -2404,59 +3075,16 @@ TickType_t xTimeToWake;
 		can be used in place of vListInsert. */

 		vListInsertEnd( pxEventList, &( pxCurrentTCB->xEventListItem ) );

 

-		/* We must remove this task from the ready list before adding it to the

-		blocked list as the same list item is used for both lists.  This

-		function is called with the scheduler locked so interrupts will not

-		access the lists at the same time. */

-		if( uxListRemove( &( pxCurrentTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )

-		{

-			/* The current task must be in a ready list, so there is no need to

-			check, and the port reset macro can be called directly. */

-			portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority );

-		}

-		else

-		{

-			mtCOVERAGE_TEST_MARKER();

-		}

-

-		/* If vTaskSuspend() is available then the suspended task list is also

-		available and a task that is blocking indefinitely can enter the

-		suspended state (it is not really suspended as it will re-enter the

-		Ready state when the event it is waiting indefinitely for occurs).

-		Blocking indefinitely is useful when using tickless idle mode as when

-		all tasks are blocked indefinitely all timers can be turned off. */

-		#if( INCLUDE_vTaskSuspend == 1 )

+		/* If the task should block indefinitely then set the block time to a

+		value that will be recognised as an indefinite delay inside the

+		prvAddCurrentTaskToDelayedList() function. */

+		if( xWaitIndefinitely != pdFALSE )

 		{

-			if( xWaitIndefinitely == pdTRUE )

-			{

-				/* Add the task to the suspended task list instead of a delayed

-				task list to ensure the task is not woken by a timing event.  It

-				will block indefinitely. */

-				vListInsertEnd( &xSuspendedTaskList, &( pxCurrentTCB->xGenericListItem ) );

-			}

-			else

-			{

-				/* Calculate the time at which the task should be woken if the

-				event does not occur.  This may overflow but this doesn't

-				matter. */

-				xTimeToWake = xTickCount + xTicksToWait;

-				traceTASK_DELAY_UNTIL();

-				prvAddCurrentTaskToDelayedList( xTimeToWake );

-			}

+			xTicksToWait = portMAX_DELAY;

 		}

-		#else

-		{

-			/* Calculate the time at which the task should be woken if the event

-			does not occur.  This may overflow but this doesn't matter. */

-			xTimeToWake = xTickCount + xTicksToWait;

-			traceTASK_DELAY_UNTIL();

-			prvAddCurrentTaskToDelayedList( xTimeToWake );

 

-			/* Remove compiler warnings when INCLUDE_vTaskSuspend() is not

-			defined. */

-			( void ) xWaitIndefinitely;

-		}

-		#endif

+		traceTASK_DELAY_UNTIL( ( xTickCount + xTicksToWait ) );

+		prvAddCurrentTaskToDelayedList( xTicksToWait, xWaitIndefinitely );

 	}

 

 #endif /* configUSE_TIMERS */

@@ -2480,14 +3108,28 @@ BaseType_t xReturn;
 

 	This function assumes that a check has already been made to ensure that

 	pxEventList is not empty. */

-	pxUnblockedTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxEventList );

+	pxUnblockedTCB = listGET_OWNER_OF_HEAD_ENTRY( pxEventList ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too.  Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */

 	configASSERT( pxUnblockedTCB );

 	( void ) uxListRemove( &( pxUnblockedTCB->xEventListItem ) );

 

 	if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )

 	{

-		( void ) uxListRemove( &( pxUnblockedTCB->xGenericListItem ) );

+		( void ) uxListRemove( &( pxUnblockedTCB->xStateListItem ) );

 		prvAddTaskToReadyList( pxUnblockedTCB );

+

+		#if( configUSE_TICKLESS_IDLE != 0 )

+		{

+			/* If a task is blocked on a kernel object then xNextTaskUnblockTime

+			might be set to the blocked task's time out time.  If the task is

+			unblocked for a reason other than a timeout xNextTaskUnblockTime is

+			normally left unchanged, because it is automatically reset to a new

+			value when the tick count equals xNextTaskUnblockTime.  However if

+			tickless idling is used it might be more important to enter sleep mode

+			at the earliest possible time - so reset xNextTaskUnblockTime here to

+			ensure it is updated at the earliest possible time. */

+			prvResetNextTaskUnblockTime();

+		}

+		#endif

 	}

 	else

 	{

@@ -2512,28 +3154,13 @@ BaseType_t xReturn;
 		xReturn = pdFALSE;

 	}

 

-	#if( configUSE_TICKLESS_IDLE != 0 )

-	{

-		/* If a task is blocked on a kernel object then xNextTaskUnblockTime

-		might be set to the blocked task's time out time.  If the task is

-		unblocked for a reason other than a timeout xNextTaskUnblockTime is

-		normally left unchanged, because it is automatically reset to a new

-		value when the tick count equals xNextTaskUnblockTime.  However if

-		tickless idling is used it might be more important to enter sleep mode

-		at the earliest possible time - so reset xNextTaskUnblockTime here to

-		ensure it is updated at the earliest possible time. */

-		prvResetNextTaskUnblockTime();

-	}

-	#endif

-

 	return xReturn;

 }

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

 

-BaseType_t xTaskRemoveFromUnorderedEventList( ListItem_t * pxEventListItem, const TickType_t xItemValue )

+void vTaskRemoveFromUnorderedEventList( ListItem_t * pxEventListItem, const TickType_t xItemValue )

 {

 TCB_t *pxUnblockedTCB;

-BaseType_t xReturn;

 

 	/* THIS FUNCTION MUST BE CALLED WITH THE SCHEDULER SUSPENDED.  It is used by

 	the event flags implementation. */

@@ -2544,40 +3171,42 @@ BaseType_t xReturn;
 

 	/* Remove the event list form the event flag.  Interrupts do not access

 	event flags. */

-	pxUnblockedTCB = ( TCB_t * ) listGET_LIST_ITEM_OWNER( pxEventListItem );

+	pxUnblockedTCB = listGET_LIST_ITEM_OWNER( pxEventListItem ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too.  Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */

 	configASSERT( pxUnblockedTCB );

 	( void ) uxListRemove( pxEventListItem );

 

 	/* Remove the task from the delayed list and add it to the ready list.  The

 	scheduler is suspended so interrupts will not be accessing the ready

 	lists. */

-	( void ) uxListRemove( &( pxUnblockedTCB->xGenericListItem ) );

+	( void ) uxListRemove( &( pxUnblockedTCB->xStateListItem ) );

 	prvAddTaskToReadyList( pxUnblockedTCB );

 

 	if( pxUnblockedTCB->uxPriority > pxCurrentTCB->uxPriority )

 	{

-		/* Return true if the task removed from the event list has

-		a higher priority than the calling task.  This allows

-		the calling task to know if it should force a context

-		switch now. */

-		xReturn = pdTRUE;

-

-		/* Mark that a yield is pending in case the user is not using the

-		"xHigherPriorityTaskWoken" parameter to an ISR safe FreeRTOS function. */

+		/* The unblocked task has a priority above that of the calling task, so

+		a context switch is required.  This function is called with the

+		scheduler suspended so xYieldPending is set so the context switch

+		occurs immediately that the scheduler is resumed (unsuspended). */

 		xYieldPending = pdTRUE;

 	}

-	else

-	{

-		xReturn = pdFALSE;

-	}

-

-	return xReturn;

 }

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

 

 void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut )

 {

 	configASSERT( pxTimeOut );

+	taskENTER_CRITICAL();

+	{

+		pxTimeOut->xOverflowCount = xNumOfOverflows;

+		pxTimeOut->xTimeOnEntering = xTickCount;

+	}

+	taskEXIT_CRITICAL();

+}

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

+

+void vTaskInternalSetTimeOutState( TimeOut_t * const pxTimeOut )

+{

+	/* For internal use only as it does not use a critical section. */

 	pxTimeOut->xOverflowCount = xNumOfOverflows;

 	pxTimeOut->xTimeOnEntering = xTickCount;

 }

@@ -2594,35 +3223,49 @@ BaseType_t xReturn;
 	{

 		/* Minor optimisation.  The tick count cannot change in this block. */

 		const TickType_t xConstTickCount = xTickCount;

+		const TickType_t xElapsedTime = xConstTickCount - pxTimeOut->xTimeOnEntering;

+

+		#if( INCLUDE_xTaskAbortDelay == 1 )

+			if( pxCurrentTCB->ucDelayAborted != ( uint8_t ) pdFALSE )

+			{

+				/* The delay was aborted, which is not the same as a time out,

+				but has the same result. */

+				pxCurrentTCB->ucDelayAborted = pdFALSE;

+				xReturn = pdTRUE;

+			}

+			else

+		#endif

 

 		#if ( INCLUDE_vTaskSuspend == 1 )

-			/* If INCLUDE_vTaskSuspend is set to 1 and the block time specified is

-			the maximum block time then the task should block indefinitely, and

-			therefore never time out. */

 			if( *pxTicksToWait == portMAX_DELAY )

 			{

+				/* If INCLUDE_vTaskSuspend is set to 1 and the block time

+				specified is the maximum block time then the task should block

+				indefinitely, and therefore never time out. */

 				xReturn = pdFALSE;

 			}

-			else /* We are not blocking indefinitely, perform the checks below. */

+			else

 		#endif

 

 		if( ( xNumOfOverflows != pxTimeOut->xOverflowCount ) && ( xConstTickCount >= pxTimeOut->xTimeOnEntering ) ) /*lint !e525 Indentation preferred as is to make code within pre-processor directives clearer. */

 		{

-			/* The tick count is greater than the time at which vTaskSetTimeout()

-			was called, but has also overflowed since vTaskSetTimeOut() was called.

-			It must have wrapped all the way around and gone past us again. This

-			passed since vTaskSetTimeout() was called. */

+			/* The tick count is greater than the time at which

+			vTaskSetTimeout() was called, but has also overflowed since

+			vTaskSetTimeOut() was called.  It must have wrapped all the way

+			around and gone past again. This passed since vTaskSetTimeout()

+			was called. */

 			xReturn = pdTRUE;

 		}

-		else if( ( xConstTickCount - pxTimeOut->xTimeOnEntering ) < *pxTicksToWait )

+		else if( xElapsedTime < *pxTicksToWait ) /*lint !e961 Explicit casting is only redundant with some compilers, whereas others require it to prevent integer conversion errors. */

 		{

 			/* Not a genuine timeout. Adjust parameters for time remaining. */

-			*pxTicksToWait -= ( xConstTickCount -  pxTimeOut->xTimeOnEntering );

-			vTaskSetTimeOutState( pxTimeOut );

+			*pxTicksToWait -= xElapsedTime;

+			vTaskInternalSetTimeOutState( pxTimeOut );

 			xReturn = pdFALSE;

 		}

 		else

 		{

+			*pxTicksToWait = 0;

 			xReturn = pdTRUE;

 		}

 	}

@@ -2643,11 +3286,11 @@ void vTaskMissedYield( void )
 	UBaseType_t uxTaskGetTaskNumber( TaskHandle_t xTask )

 	{

 	UBaseType_t uxReturn;

-	TCB_t *pxTCB;

+	TCB_t const *pxTCB;

 

 		if( xTask != NULL )

 		{

-			pxTCB = ( TCB_t * ) xTask;

+			pxTCB = xTask;

 			uxReturn = pxTCB->uxTaskNumber;

 		}

 		else

@@ -2665,11 +3308,11 @@ void vTaskMissedYield( void )
 

 	void vTaskSetTaskNumber( TaskHandle_t xTask, const UBaseType_t uxHandle )

 	{

-	TCB_t *pxTCB;

+	TCB_t * pxTCB;

 

 		if( xTask != NULL )

 		{

-			pxTCB = ( TCB_t * ) xTask;

+			pxTCB = xTask;

 			pxTCB->uxTaskNumber = uxHandle;

 		}

 	}

@@ -2692,9 +3335,18 @@ static portTASK_FUNCTION( prvIdleTask, pvParameters )
 	/* Stop warnings. */

 	( void ) pvParameters;

 

+	/** THIS IS THE RTOS IDLE TASK - WHICH IS CREATED AUTOMATICALLY WHEN THE

+	SCHEDULER IS STARTED. **/

+

+	/* In case a task that has a secure context deletes itself, in which case

+	the idle task is responsible for deleting the task's secure context, if

+	any. */

+	portALLOCATE_SECURE_CONTEXT( configMINIMAL_SECURE_STACK_SIZE );

+

 	for( ;; )

 	{

-		/* See if any tasks have been deleted. */

+		/* See if any tasks have deleted themselves - if so then the idle task

+		is responsible for freeing the deleted task's TCB and stack. */

 		prvCheckTasksWaitingTermination();

 

 		#if ( configUSE_PREEMPTION == 0 )

@@ -2767,6 +3419,11 @@ static portTASK_FUNCTION( prvIdleTask, pvParameters )
 					configASSERT( xNextTaskUnblockTime >= xTickCount );

 					xExpectedIdleTime = prvGetExpectedIdleTime();

 

+					/* Define the following macro to set xExpectedIdleTime to 0

+					if the application does not want

+					portSUPPRESS_TICKS_AND_SLEEP() to be called. */

+					configPRE_SUPPRESS_TICKS_AND_SLEEP_PROCESSING( xExpectedIdleTime );

+

 					if( xExpectedIdleTime >= configEXPECTED_IDLE_TIME_BEFORE_SLEEP )

 					{

 						traceLOW_POWER_IDLE_BEGIN();

@@ -2830,116 +3487,6 @@ static portTASK_FUNCTION( prvIdleTask, pvParameters )
 #endif /* configUSE_TICKLESS_IDLE */

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

 

-static void prvInitialiseTCBVariables( TCB_t * const pxTCB, const char * const pcName, UBaseType_t uxPriority, const MemoryRegion_t * const xRegions, const uint16_t usStackDepth ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

-{

-UBaseType_t x;

-

-	/* Store the task name in the TCB. */

-	for( x = ( UBaseType_t ) 0; x < ( UBaseType_t ) configMAX_TASK_NAME_LEN; x++ )

-	{

-		pxTCB->pcTaskName[ x ] = pcName[ x ];

-

-		/* Don't copy all configMAX_TASK_NAME_LEN if the string is shorter than

-		configMAX_TASK_NAME_LEN characters just in case the memory after the

-		string is not accessible (extremely unlikely). */

-		if( pcName[ x ] == 0x00 )

-		{

-			break;

-		}

-		else

-		{

-			mtCOVERAGE_TEST_MARKER();

-		}

-	}

-

-	/* Ensure the name string is terminated in the case that the string length

-	was greater or equal to configMAX_TASK_NAME_LEN. */

-	pxTCB->pcTaskName[ configMAX_TASK_NAME_LEN - 1 ] = '\0';

-

-	/* This is used as an array index so must ensure it's not too large.  First

-	remove the privilege bit if one is present. */

-	if( uxPriority >= ( UBaseType_t ) configMAX_PRIORITIES )

-	{

-		uxPriority = ( UBaseType_t ) configMAX_PRIORITIES - ( UBaseType_t ) 1U;

-	}

-	else

-	{

-		mtCOVERAGE_TEST_MARKER();

-	}

-

-	pxTCB->uxPriority = uxPriority;

-	#if ( configUSE_MUTEXES == 1 )

-	{

-		pxTCB->uxBasePriority = uxPriority;

-		pxTCB->uxMutexesHeld = 0;

-	}

-	#endif /* configUSE_MUTEXES */

-

-	vListInitialiseItem( &( pxTCB->xGenericListItem ) );

-	vListInitialiseItem( &( pxTCB->xEventListItem ) );

-

-	/* Set the pxTCB as a link back from the ListItem_t.  This is so we can get

-	back to	the containing TCB from a generic item in a list. */

-	listSET_LIST_ITEM_OWNER( &( pxTCB->xGenericListItem ), pxTCB );

-

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

-	listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) uxPriority ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */

-	listSET_LIST_ITEM_OWNER( &( pxTCB->xEventListItem ), pxTCB );

-

-	#if ( portCRITICAL_NESTING_IN_TCB == 1 )

-	{

-		pxTCB->uxCriticalNesting = ( UBaseType_t ) 0U;

-	}

-	#endif /* portCRITICAL_NESTING_IN_TCB */

-

-	#if ( configUSE_APPLICATION_TASK_TAG == 1 )

-	{

-		pxTCB->pxTaskTag = NULL;

-	}

-	#endif /* configUSE_APPLICATION_TASK_TAG */

-

-	#if ( configGENERATE_RUN_TIME_STATS == 1 )

-	{

-		pxTCB->ulRunTimeCounter = 0UL;

-	}

-	#endif /* configGENERATE_RUN_TIME_STATS */

-

-	#if ( portUSING_MPU_WRAPPERS == 1 )

-	{

-		vPortStoreTaskMPUSettings( &( pxTCB->xMPUSettings ), xRegions, pxTCB->pxStack, usStackDepth );

-	}

-	#else /* portUSING_MPU_WRAPPERS */

-	{

-		( void ) xRegions;

-		( void ) usStackDepth;

-	}

-	#endif /* portUSING_MPU_WRAPPERS */

-

-	#if( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )

-	{

-		for( x = 0; x < ( UBaseType_t ) configNUM_THREAD_LOCAL_STORAGE_POINTERS; x++ )

-		{

-			pxTCB->pvThreadLocalStoragePointers[ x ] = NULL;

-		}

-	}

-	#endif

-

-	#if ( configUSE_TASK_NOTIFICATIONS == 1 )

-	{

-		pxTCB->ulNotifiedValue = 0;

-		pxTCB->eNotifyState = eNotWaitingNotification;

-	}

-	#endif

-

-	#if ( configUSE_NEWLIB_REENTRANT == 1 )

-	{

-		/* Initialise this task's Newlib reent structure. */

-		_REENT_INIT_PTR( ( &( pxTCB->xNewLib_reent ) ) );

-	}

-	#endif /* configUSE_NEWLIB_REENTRANT */

-}

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

-

 #if ( configNUM_THREAD_LOCAL_STORAGE_POINTERS != 0 )

 

 	void vTaskSetThreadLocalStoragePointer( TaskHandle_t xTaskToSet, BaseType_t xIndex, void *pvValue )

@@ -2989,7 +3536,7 @@ UBaseType_t x;
 		the calling task. */

 		pxTCB = prvGetTCBFromHandle( xTaskToModify );

 

-        vPortStoreTaskMPUSettings( &( pxTCB->xMPUSettings ), xRegions, NULL, 0 );

+		vPortStoreTaskMPUSettings( &( pxTCB->xMPUSettings ), xRegions, NULL, 0 );

 	}

 

 #endif /* portUSING_MPU_WRAPPERS */

@@ -3029,160 +3576,139 @@ UBaseType_t uxPriority;
 

 static void prvCheckTasksWaitingTermination( void )

 {

+

+	/** THIS FUNCTION IS CALLED FROM THE RTOS IDLE TASK **/

+

 	#if ( INCLUDE_vTaskDelete == 1 )

 	{

-		BaseType_t xListIsEmpty;

+		TCB_t *pxTCB;

 

-		/* ucTasksDeleted is used to prevent vTaskSuspendAll() being called

-		too often in the idle task. */

-		while( uxTasksDeleted > ( UBaseType_t ) 0U )

+		/* uxDeletedTasksWaitingCleanUp is used to prevent taskENTER_CRITICAL()

+		being called too often in the idle task. */

+		while( uxDeletedTasksWaitingCleanUp > ( UBaseType_t ) 0U )

 		{

-			vTaskSuspendAll();

+			taskENTER_CRITICAL();

 			{

-				xListIsEmpty = listLIST_IS_EMPTY( &xTasksWaitingTermination );

+				pxTCB = listGET_OWNER_OF_HEAD_ENTRY( ( &xTasksWaitingTermination ) ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too.  Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */

+				( void ) uxListRemove( &( pxTCB->xStateListItem ) );

+				--uxCurrentNumberOfTasks;

+				--uxDeletedTasksWaitingCleanUp;

 			}

-			( void ) xTaskResumeAll();

-

-			if( xListIsEmpty == pdFALSE )

-			{

-				TCB_t *pxTCB;

-

-				taskENTER_CRITICAL();

-				{

-					pxTCB = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( ( &xTasksWaitingTermination ) );

-					( void ) uxListRemove( &( pxTCB->xGenericListItem ) );

-					--uxCurrentNumberOfTasks;

-					--uxTasksDeleted;

-				}

-				taskEXIT_CRITICAL();

+			taskEXIT_CRITICAL();

 

-				prvDeleteTCB( pxTCB );

-			}

-			else

-			{

-				mtCOVERAGE_TEST_MARKER();

-			}

+			prvDeleteTCB( pxTCB );

 		}

 	}

-	#endif /* vTaskDelete */

+	#endif /* INCLUDE_vTaskDelete */

 }

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

 

-static void prvAddCurrentTaskToDelayedList( const TickType_t xTimeToWake )

-{

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

-	listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xGenericListItem ), xTimeToWake );

+#if( configUSE_TRACE_FACILITY == 1 )

 

-	if( xTimeToWake < xTickCount )

-	{

-		/* Wake time has overflowed.  Place this item in the overflow list. */

-		vListInsert( pxOverflowDelayedTaskList, &( pxCurrentTCB->xGenericListItem ) );

-	}

-	else

+	void vTaskGetInfo( TaskHandle_t xTask, TaskStatus_t *pxTaskStatus, BaseType_t xGetFreeStackSpace, eTaskState eState )

 	{

-		/* The wake time has not overflowed, so the current block list is used. */

-		vListInsert( pxDelayedTaskList, &( pxCurrentTCB->xGenericListItem ) );

+	TCB_t *pxTCB;

+

+		/* xTask is NULL then get the state of the calling task. */

+		pxTCB = prvGetTCBFromHandle( xTask );

+

+		pxTaskStatus->xHandle = ( TaskHandle_t ) pxTCB;

+		pxTaskStatus->pcTaskName = ( const char * ) &( pxTCB->pcTaskName [ 0 ] );

+		pxTaskStatus->uxCurrentPriority = pxTCB->uxPriority;

+		pxTaskStatus->pxStackBase = pxTCB->pxStack;

+		pxTaskStatus->xTaskNumber = pxTCB->uxTCBNumber;

 

-		/* If the task entering the blocked state was placed at the head of the

-		list of blocked tasks then xNextTaskUnblockTime needs to be updated

-		too. */

-		if( xTimeToWake < xNextTaskUnblockTime )

+		#if ( configUSE_MUTEXES == 1 )

 		{

-			xNextTaskUnblockTime = xTimeToWake;

+			pxTaskStatus->uxBasePriority = pxTCB->uxBasePriority;

 		}

-		else

+		#else

 		{

-			mtCOVERAGE_TEST_MARKER();

+			pxTaskStatus->uxBasePriority = 0;

 		}

-	}

-}

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

-

-static TCB_t *prvAllocateTCBAndStack( const uint16_t usStackDepth, StackType_t * const puxStackBuffer )

-{

-TCB_t *pxNewTCB;

-

-	/* If the stack grows down then allocate the stack then the TCB so the stack

-	does not grow into the TCB.  Likewise if the stack grows up then allocate

-	the TCB then the stack. */

-	#if( portSTACK_GROWTH > 0 )

-	{

-		/* Allocate space for the TCB.  Where the memory comes from depends on

-		the implementation of the port malloc function. */

-		pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) );

+		#endif

 

-		if( pxNewTCB != NULL )

+		#if ( configGENERATE_RUN_TIME_STATS == 1 )

 		{

-			/* Allocate space for the stack used by the task being created.

-			The base of the stack memory stored in the TCB so the task can

-			be deleted later if required. */

-			pxNewTCB->pxStack = ( StackType_t * ) pvPortMallocAligned( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ), puxStackBuffer ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */

-

-			if( pxNewTCB->pxStack == NULL )

-			{

-				/* Could not allocate the stack.  Delete the allocated TCB. */

-				vPortFree( pxNewTCB );

-				pxNewTCB = NULL;

-			}

+			pxTaskStatus->ulRunTimeCounter = pxTCB->ulRunTimeCounter;

 		}

-	}

-	#else /* portSTACK_GROWTH */

-	{

-	StackType_t *pxStack;

-

-		/* Allocate space for the stack used by the task being created. */

-		pxStack = ( StackType_t * ) pvPortMallocAligned( ( ( ( size_t ) usStackDepth ) * sizeof( StackType_t ) ), puxStackBuffer ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */

-

-		if( pxStack != NULL )

+		#else

 		{

-			/* Allocate space for the TCB.  Where the memory comes from depends

-			on the implementation of the port malloc function. */

-			pxNewTCB = ( TCB_t * ) pvPortMalloc( sizeof( TCB_t ) );

+			pxTaskStatus->ulRunTimeCounter = 0;

+		}

+		#endif

 

-			if( pxNewTCB != NULL )

+		/* Obtaining the task state is a little fiddly, so is only done if the

+		value of eState passed into this function is eInvalid - otherwise the

+		state is just set to whatever is passed in. */

+		if( eState != eInvalid )

+		{

+			if( pxTCB == pxCurrentTCB )

 			{

-				/* Store the stack location in the TCB. */

-				pxNewTCB->pxStack = pxStack;

+				pxTaskStatus->eCurrentState = eRunning;

 			}

 			else

 			{

-				/* The stack cannot be used as the TCB was not created.  Free it

-				again. */

-				vPortFree( pxStack );

+				pxTaskStatus->eCurrentState = eState;

+

+				#if ( INCLUDE_vTaskSuspend == 1 )

+				{

+					/* If the task is in the suspended list then there is a

+					chance it is actually just blocked indefinitely - so really

+					it should be reported as being in the Blocked state. */

+					if( eState == eSuspended )

+					{

+						vTaskSuspendAll();

+						{

+							if( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) != NULL )

+							{

+								pxTaskStatus->eCurrentState = eBlocked;

+							}

+						}

+						( void ) xTaskResumeAll();

+					}

+				}

+				#endif /* INCLUDE_vTaskSuspend */

 			}

 		}

 		else

 		{

-			pxNewTCB = NULL;

+			pxTaskStatus->eCurrentState = eTaskGetState( pxTCB );

 		}

-	}

-	#endif /* portSTACK_GROWTH */

 

-	if( pxNewTCB != NULL )

-	{

-		/* Avoid dependency on memset() if it is not required. */

-		#if( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) || ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) )

+		/* Obtaining the stack space takes some time, so the xGetFreeStackSpace

+		parameter is provided to allow it to be skipped. */

+		if( xGetFreeStackSpace != pdFALSE )

 		{

-			/* Just to help debugging. */

-			( void ) memset( pxNewTCB->pxStack, ( int ) tskSTACK_FILL_BYTE, ( size_t ) usStackDepth * sizeof( StackType_t ) );

+			#if ( portSTACK_GROWTH > 0 )

+			{

+				pxTaskStatus->usStackHighWaterMark = prvTaskCheckFreeStackSpace( ( uint8_t * ) pxTCB->pxEndOfStack );

+			}

+			#else

+			{

+				pxTaskStatus->usStackHighWaterMark = prvTaskCheckFreeStackSpace( ( uint8_t * ) pxTCB->pxStack );

+			}

+			#endif

+		}

+		else

+		{

+			pxTaskStatus->usStackHighWaterMark = 0;

 		}

-		#endif /* ( ( configCHECK_FOR_STACK_OVERFLOW > 1 ) || ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) ) ) */

 	}

 

-	return pxNewTCB;

-}

+#endif /* configUSE_TRACE_FACILITY */

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

 

 #if ( configUSE_TRACE_FACILITY == 1 )

 

-	static UBaseType_t prvListTaskWithinSingleList( TaskStatus_t *pxTaskStatusArray, List_t *pxList, eTaskState eState )

+	static UBaseType_t prvListTasksWithinSingleList( TaskStatus_t *pxTaskStatusArray, List_t *pxList, eTaskState eState )

 	{

-	volatile TCB_t *pxNextTCB, *pxFirstTCB;

+	configLIST_VOLATILE TCB_t *pxNextTCB, *pxFirstTCB;

 	UBaseType_t uxTask = 0;

 

 		if( listCURRENT_LIST_LENGTH( pxList ) > ( UBaseType_t ) 0 )

 		{

-			listGET_OWNER_OF_NEXT_ENTRY( pxFirstTCB, pxList );

+			listGET_OWNER_OF_NEXT_ENTRY( pxFirstTCB, pxList ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too.  Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */

 

 			/* Populate an TaskStatus_t structure within the

 			pxTaskStatusArray array for each task that is referenced from

@@ -3190,61 +3716,9 @@ TCB_t *pxNewTCB;
 			meaning of each TaskStatus_t structure member. */

 			do

 			{

-				listGET_OWNER_OF_NEXT_ENTRY( pxNextTCB, pxList );

-

-				pxTaskStatusArray[ uxTask ].xHandle = ( TaskHandle_t ) pxNextTCB;

-				pxTaskStatusArray[ uxTask ].pcTaskName = ( const char * ) &( pxNextTCB->pcTaskName [ 0 ] );

-				pxTaskStatusArray[ uxTask ].xTaskNumber = pxNextTCB->uxTCBNumber;

-				pxTaskStatusArray[ uxTask ].eCurrentState = eState;

-				pxTaskStatusArray[ uxTask ].uxCurrentPriority = pxNextTCB->uxPriority;

-

-				#if ( INCLUDE_vTaskSuspend == 1 )

-				{

-					/* If the task is in the suspended list then there is a chance

-					it is actually just blocked indefinitely - so really it should

-					be reported as being in the Blocked state. */

-					if( eState == eSuspended )

-					{

-						if( listLIST_ITEM_CONTAINER( &( pxNextTCB->xEventListItem ) ) != NULL )

-						{

-							pxTaskStatusArray[ uxTask ].eCurrentState = eBlocked;

-						}

-					}

-				}

-				#endif /* INCLUDE_vTaskSuspend */

-

-				#if ( configUSE_MUTEXES == 1 )

-				{

-					pxTaskStatusArray[ uxTask ].uxBasePriority = pxNextTCB->uxBasePriority;

-				}

-				#else

-				{

-					pxTaskStatusArray[ uxTask ].uxBasePriority = 0;

-				}

-				#endif

-

-				#if ( configGENERATE_RUN_TIME_STATS == 1 )

-				{

-					pxTaskStatusArray[ uxTask ].ulRunTimeCounter = pxNextTCB->ulRunTimeCounter;

-				}

-				#else

-				{

-					pxTaskStatusArray[ uxTask ].ulRunTimeCounter = 0;

-				}

-				#endif

-

-				#if ( portSTACK_GROWTH > 0 )

-				{

-					pxTaskStatusArray[ uxTask ].usStackHighWaterMark = prvTaskCheckFreeStackSpace( ( uint8_t * ) pxNextTCB->pxEndOfStack );

-				}

-				#else

-				{

-					pxTaskStatusArray[ uxTask ].usStackHighWaterMark = prvTaskCheckFreeStackSpace( ( uint8_t * ) pxNextTCB->pxStack );

-				}

-				#endif

-

+				listGET_OWNER_OF_NEXT_ENTRY( pxNextTCB, pxList ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too.  Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */

+				vTaskGetInfo( ( TaskHandle_t ) pxNextTCB, &( pxTaskStatusArray[ uxTask ] ), pdTRUE, eState );

 				uxTask++;

-

 			} while( pxNextTCB != pxFirstTCB );

 		}

 		else

@@ -3258,9 +3732,9 @@ TCB_t *pxNewTCB;
 #endif /* configUSE_TRACE_FACILITY */

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

 

-#if ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) )

+#if ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) )

 

-	static uint16_t prvTaskCheckFreeStackSpace( const uint8_t * pucStackByte )

+	static configSTACK_DEPTH_TYPE prvTaskCheckFreeStackSpace( const uint8_t * pucStackByte )

 	{

 	uint32_t ulCount = 0U;

 

@@ -3272,10 +3746,50 @@ TCB_t *pxNewTCB;
 

 		ulCount /= ( uint32_t ) sizeof( StackType_t ); /*lint !e961 Casting is not redundant on smaller architectures. */

 

-		return ( uint16_t ) ulCount;

+		return ( configSTACK_DEPTH_TYPE ) ulCount;

 	}

 

-#endif /* ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) ) */

+#endif /* ( ( configUSE_TRACE_FACILITY == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark == 1 ) || ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 ) ) */

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

+

+#if ( INCLUDE_uxTaskGetStackHighWaterMark2 == 1 )

+

+	/* uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are the

+	same except for their return type.  Using configSTACK_DEPTH_TYPE allows the

+	user to determine the return type.  It gets around the problem of the value

+	overflowing on 8-bit types without breaking backward compatibility for

+	applications that expect an 8-bit return type. */

+	configSTACK_DEPTH_TYPE uxTaskGetStackHighWaterMark2( TaskHandle_t xTask )

+	{

+	TCB_t *pxTCB;

+	uint8_t *pucEndOfStack;

+	configSTACK_DEPTH_TYPE uxReturn;

+

+		/* uxTaskGetStackHighWaterMark() and uxTaskGetStackHighWaterMark2() are

+		the same except for their return type.  Using configSTACK_DEPTH_TYPE

+		allows the user to determine the return type.  It gets around the

+		problem of the value overflowing on 8-bit types without breaking

+		backward compatibility for applications that expect an 8-bit return

+		type. */

+

+		pxTCB = prvGetTCBFromHandle( xTask );

+

+		#if portSTACK_GROWTH < 0

+		{

+			pucEndOfStack = ( uint8_t * ) pxTCB->pxStack;

+		}

+		#else

+		{

+			pucEndOfStack = ( uint8_t * ) pxTCB->pxEndOfStack;

+		}

+		#endif

+

+		uxReturn = prvTaskCheckFreeStackSpace( pucEndOfStack );

+

+		return uxReturn;

+	}

+

+#endif /* INCLUDE_uxTaskGetStackHighWaterMark2 */

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

 

 #if ( INCLUDE_uxTaskGetStackHighWaterMark == 1 )

@@ -3323,22 +3837,40 @@ TCB_t *pxNewTCB;
 		}

 		#endif /* configUSE_NEWLIB_REENTRANT */

 

-		#if( portUSING_MPU_WRAPPERS == 1 )

+		#if( ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) && ( configSUPPORT_STATIC_ALLOCATION == 0 ) && ( portUSING_MPU_WRAPPERS == 0 ) )

 		{

-			/* Only free the stack if it was allocated dynamically in the first

-			place. */

-			if( pxTCB->xUsingStaticallyAllocatedStack == pdFALSE )

-			{

-				vPortFreeAligned( pxTCB->pxStack );

-			}

+			/* The task can only have been allocated dynamically - free both

+			the stack and TCB. */

+			vPortFree( pxTCB->pxStack );

+			vPortFree( pxTCB );

 		}

-		#else

+		#elif( tskSTATIC_AND_DYNAMIC_ALLOCATION_POSSIBLE != 0 ) /*lint !e731 !e9029 Macro has been consolidated for readability reasons. */

 		{

-			vPortFreeAligned( pxTCB->pxStack );

+			/* The task could have been allocated statically or dynamically, so

+			check what was statically allocated before trying to free the

+			memory. */

+			if( pxTCB->ucStaticallyAllocated == tskDYNAMICALLY_ALLOCATED_STACK_AND_TCB )

+			{

+				/* Both the stack and TCB were allocated dynamically, so both

+				must be freed. */

+				vPortFree( pxTCB->pxStack );

+				vPortFree( pxTCB );

+			}

+			else if( pxTCB->ucStaticallyAllocated == tskSTATICALLY_ALLOCATED_STACK_ONLY )

+			{

+				/* Only the stack was statically allocated, so the TCB is the

+				only memory that must be freed. */

+				vPortFree( pxTCB );

+			}

+			else

+			{

+				/* Neither the stack nor the TCB were allocated dynamically, so

+				nothing needs to be freed. */

+				configASSERT( pxTCB->ucStaticallyAllocated == tskSTATICALLY_ALLOCATED_STACK_AND_TCB	);

+				mtCOVERAGE_TEST_MARKER();

+			}

 		}

-		#endif

-

-		vPortFree( pxTCB );

+		#endif /* configSUPPORT_DYNAMIC_ALLOCATION */

 	}

 

 #endif /* INCLUDE_vTaskDelete */

@@ -3362,8 +3894,8 @@ TCB_t *pxTCB;
 		the item at the head of the delayed list.  This is the time at

 		which the task at the head of the delayed list should be removed

 		from the Blocked state. */

-		( pxTCB ) = ( TCB_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxDelayedTaskList );

-		xNextTaskUnblockTime = listGET_LIST_ITEM_VALUE( &( ( pxTCB )->xGenericListItem ) );

+		( pxTCB ) = listGET_OWNER_OF_HEAD_ENTRY( pxDelayedTaskList ); /*lint !e9079 void * is used as this macro is used with timers and co-routines too.  Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */

+		xNextTaskUnblockTime = listGET_LIST_ITEM_VALUE( &( ( pxTCB )->xStateListItem ) );

 	}

 }

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

@@ -3415,25 +3947,27 @@ TCB_t *pxTCB;
 

 #if ( configUSE_MUTEXES == 1 )

 

-	void vTaskPriorityInherit( TaskHandle_t const pxMutexHolder )

+	BaseType_t xTaskPriorityInherit( TaskHandle_t const pxMutexHolder )

 	{

-	TCB_t * const pxTCB = ( TCB_t * ) pxMutexHolder;

+	TCB_t * const pxMutexHolderTCB = pxMutexHolder;

+	BaseType_t xReturn = pdFALSE;

 

 		/* If the mutex was given back by an interrupt while the queue was

-		locked then the mutex holder might now be NULL. */

+		locked then the mutex holder might now be NULL.  _RB_ Is this still

+		needed as interrupts can no longer use mutexes? */

 		if( pxMutexHolder != NULL )

 		{

 			/* If the holder of the mutex has a priority below the priority of

 			the task attempting to obtain the mutex then it will temporarily

 			inherit the priority of the task attempting to obtain the mutex. */

-			if( pxTCB->uxPriority < pxCurrentTCB->uxPriority )

+			if( pxMutexHolderTCB->uxPriority < pxCurrentTCB->uxPriority )

 			{

 				/* Adjust the mutex holder state to account for its new

 				priority.  Only reset the event list item value if the value is

-				not	being used for anything else. */

-				if( ( listGET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ) ) & taskEVENT_LIST_ITEM_VALUE_IN_USE ) == 0UL )

+				not being used for anything else. */

+				if( ( listGET_LIST_ITEM_VALUE( &( pxMutexHolderTCB->xEventListItem ) ) & taskEVENT_LIST_ITEM_VALUE_IN_USE ) == 0UL )

 				{

-					listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) pxCurrentTCB->uxPriority ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */

+					listSET_LIST_ITEM_VALUE( &( pxMutexHolderTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) pxCurrentTCB->uxPriority ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */

 				}

 				else

 				{

@@ -3442,11 +3976,11 @@ TCB_t *pxTCB;
 

 				/* If the task being modified is in the ready state it will need

 				to be moved into a new list. */

-				if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ pxTCB->uxPriority ] ), &( pxTCB->xGenericListItem ) ) != pdFALSE )

+				if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ pxMutexHolderTCB->uxPriority ] ), &( pxMutexHolderTCB->xStateListItem ) ) != pdFALSE )

 				{

-					if( uxListRemove( &( pxTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )

+					if( uxListRemove( &( pxMutexHolderTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )

 					{

-						taskRESET_READY_PRIORITY( pxTCB->uxPriority );

+						taskRESET_READY_PRIORITY( pxMutexHolderTCB->uxPriority );

 					}

 					else

 					{

@@ -3454,26 +3988,45 @@ TCB_t *pxTCB;
 					}

 

 					/* Inherit the priority before being moved into the new list. */

-					pxTCB->uxPriority = pxCurrentTCB->uxPriority;

-					prvAddTaskToReadyList( pxTCB );

+					pxMutexHolderTCB->uxPriority = pxCurrentTCB->uxPriority;

+					prvAddTaskToReadyList( pxMutexHolderTCB );

 				}

 				else

 				{

 					/* Just inherit the priority. */

-					pxTCB->uxPriority = pxCurrentTCB->uxPriority;

+					pxMutexHolderTCB->uxPriority = pxCurrentTCB->uxPriority;

 				}

 

-				traceTASK_PRIORITY_INHERIT( pxTCB, pxCurrentTCB->uxPriority );

+				traceTASK_PRIORITY_INHERIT( pxMutexHolderTCB, pxCurrentTCB->uxPriority );

+

+				/* Inheritance occurred. */

+				xReturn = pdTRUE;

 			}

 			else

 			{

-				mtCOVERAGE_TEST_MARKER();

+				if( pxMutexHolderTCB->uxBasePriority < pxCurrentTCB->uxPriority )

+				{

+					/* The base priority of the mutex holder is lower than the

+					priority of the task attempting to take the mutex, but the

+					current priority of the mutex holder is not lower than the

+					priority of the task attempting to take the mutex.

+					Therefore the mutex holder must have already inherited a

+					priority, but inheritance would have occurred if that had

+					not been the case. */

+					xReturn = pdTRUE;

+				}

+				else

+				{

+					mtCOVERAGE_TEST_MARKER();

+				}

 			}

 		}

 		else

 		{

 			mtCOVERAGE_TEST_MARKER();

 		}

+

+		return xReturn;

 	}

 

 #endif /* configUSE_MUTEXES */

@@ -3483,7 +4036,7 @@ TCB_t *pxTCB;
 

 	BaseType_t xTaskPriorityDisinherit( TaskHandle_t const pxMutexHolder )

 	{

-	TCB_t * const pxTCB = ( TCB_t * ) pxMutexHolder;

+	TCB_t * const pxTCB = pxMutexHolder;

 	BaseType_t xReturn = pdFALSE;

 

 		if( pxMutexHolder != NULL )

@@ -3493,7 +4046,6 @@ TCB_t *pxTCB;
 			interrupt, and if a mutex is given by the holding task then it must

 			be the running state task. */

 			configASSERT( pxTCB == pxCurrentTCB );

-

 			configASSERT( pxTCB->uxMutexesHeld );

 			( pxTCB->uxMutexesHeld )--;

 

@@ -3507,9 +4059,9 @@ TCB_t *pxTCB;
 					/* A task can only have an inherited priority if it holds

 					the mutex.  If the mutex is held by a task then it cannot be

 					given from an interrupt, and if a mutex is given by the

-					holding	task then it must be the running state task.  Remove

-					the	holding task from the ready	list. */

-					if( uxListRemove( &( pxTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )

+					holding task then it must be the running state task.  Remove

+					the holding task from the ready list. */

+					if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )

 					{

 						taskRESET_READY_PRIORITY( pxTCB->uxPriority );

 					}

@@ -3560,6 +4112,108 @@ TCB_t *pxTCB;
 #endif /* configUSE_MUTEXES */

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

 

+#if ( configUSE_MUTEXES == 1 )

+

+	void vTaskPriorityDisinheritAfterTimeout( TaskHandle_t const pxMutexHolder, UBaseType_t uxHighestPriorityWaitingTask )

+	{

+	TCB_t * const pxTCB = pxMutexHolder;

+	UBaseType_t uxPriorityUsedOnEntry, uxPriorityToUse;

+	const UBaseType_t uxOnlyOneMutexHeld = ( UBaseType_t ) 1;

+

+		if( pxMutexHolder != NULL )

+		{

+			/* If pxMutexHolder is not NULL then the holder must hold at least

+			one mutex. */

+			configASSERT( pxTCB->uxMutexesHeld );

+

+			/* Determine the priority to which the priority of the task that

+			holds the mutex should be set.  This will be the greater of the

+			holding task's base priority and the priority of the highest

+			priority task that is waiting to obtain the mutex. */

+			if( pxTCB->uxBasePriority < uxHighestPriorityWaitingTask )

+			{

+				uxPriorityToUse = uxHighestPriorityWaitingTask;

+			}

+			else

+			{

+				uxPriorityToUse = pxTCB->uxBasePriority;

+			}

+

+			/* Does the priority need to change? */

+			if( pxTCB->uxPriority != uxPriorityToUse )

+			{

+				/* Only disinherit if no other mutexes are held.  This is a

+				simplification in the priority inheritance implementation.  If

+				the task that holds the mutex is also holding other mutexes then

+				the other mutexes may have caused the priority inheritance. */

+				if( pxTCB->uxMutexesHeld == uxOnlyOneMutexHeld )

+				{

+					/* If a task has timed out because it already holds the

+					mutex it was trying to obtain then it cannot of inherited

+					its own priority. */

+					configASSERT( pxTCB != pxCurrentTCB );

+

+					/* Disinherit the priority, remembering the previous

+					priority to facilitate determining the subject task's

+					state. */

+					traceTASK_PRIORITY_DISINHERIT( pxTCB, pxTCB->uxBasePriority );

+					uxPriorityUsedOnEntry = pxTCB->uxPriority;

+					pxTCB->uxPriority = uxPriorityToUse;

+

+					/* Only reset the event list item value if the value is not

+					being used for anything else. */

+					if( ( listGET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ) ) & taskEVENT_LIST_ITEM_VALUE_IN_USE ) == 0UL )

+					{

+						listSET_LIST_ITEM_VALUE( &( pxTCB->xEventListItem ), ( TickType_t ) configMAX_PRIORITIES - ( TickType_t ) uxPriorityToUse ); /*lint !e961 MISRA exception as the casts are only redundant for some ports. */

+					}

+					else

+					{

+						mtCOVERAGE_TEST_MARKER();

+					}

+

+					/* If the running task is not the task that holds the mutex

+					then the task that holds the mutex could be in either the

+					Ready, Blocked or Suspended states.  Only remove the task

+					from its current state list if it is in the Ready state as

+					the task's priority is going to change and there is one

+					Ready list per priority. */

+					if( listIS_CONTAINED_WITHIN( &( pxReadyTasksLists[ uxPriorityUsedOnEntry ] ), &( pxTCB->xStateListItem ) ) != pdFALSE )

+					{

+						if( uxListRemove( &( pxTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )

+						{

+							taskRESET_READY_PRIORITY( pxTCB->uxPriority );

+						}

+						else

+						{

+							mtCOVERAGE_TEST_MARKER();

+						}

+

+						prvAddTaskToReadyList( pxTCB );

+					}

+					else

+					{

+						mtCOVERAGE_TEST_MARKER();

+					}

+				}

+				else

+				{

+					mtCOVERAGE_TEST_MARKER();

+				}

+			}

+			else

+			{

+				mtCOVERAGE_TEST_MARKER();

+			}

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+	}

+

+#endif /* configUSE_MUTEXES */

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

+

 #if ( portCRITICAL_NESTING_IN_TCB == 1 )

 

 	void vTaskEnterCritical( void )

@@ -3640,7 +4294,7 @@ TCB_t *pxTCB;
 		}

 

 		/* Terminate. */

-		pcBuffer[ x ] = 0x00;

+		pcBuffer[ x ] = ( char ) 0x00;

 

 		/* Return the new end of string. */

 		return &( pcBuffer[ x ] );

@@ -3649,12 +4303,12 @@ TCB_t *pxTCB;
 #endif /* ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) */

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

 

-#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) )

+#if ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )

 

 	void vTaskList( char * pcWriteBuffer )

 	{

 	TaskStatus_t *pxTaskStatusArray;

-	volatile UBaseType_t uxArraySize, x;

+	UBaseType_t uxArraySize, x;

 	char cStatus;

 

 		/*

@@ -3683,14 +4337,16 @@ TCB_t *pxTCB;
 

 

 		/* Make sure the write buffer does not contain a string. */

-		*pcWriteBuffer = 0x00;

+		*pcWriteBuffer = ( char ) 0x00;

 

 		/* Take a snapshot of the number of tasks in case it changes while this

 		function is executing. */

 		uxArraySize = uxCurrentNumberOfTasks;

 

-		/* Allocate an array index for each task. */

-		pxTaskStatusArray = pvPortMalloc( uxCurrentNumberOfTasks * sizeof( TaskStatus_t ) );

+		/* Allocate an array index for each task.  NOTE!  if

+		configSUPPORT_DYNAMIC_ALLOCATION is set to 0 then pvPortMalloc() will

+		equate to NULL. */

+		pxTaskStatusArray = pvPortMalloc( uxCurrentNumberOfTasks * sizeof( TaskStatus_t ) ); /*lint !e9079 All values returned by pvPortMalloc() have at least the alignment required by the MCU's stack and this allocation allocates a struct that has the alignment requirements of a pointer. */

 

 		if( pxTaskStatusArray != NULL )

 		{

@@ -3702,6 +4358,9 @@ TCB_t *pxTCB;
 			{

 				switch( pxTaskStatusArray[ x ].eCurrentState )

 				{

+					case eRunning:		cStatus = tskRUNNING_CHAR;

+										break;

+

 					case eReady:		cStatus = tskREADY_CHAR;

 										break;

 

@@ -3714,9 +4373,10 @@ TCB_t *pxTCB;
 					case eDeleted:		cStatus = tskDELETED_CHAR;

 										break;

 

+					case eInvalid:		/* Fall through. */

 					default:			/* Should not get here, but it is included

 										to prevent static checking errors. */

-										cStatus = 0x00;

+										cStatus = ( char ) 0x00;

 										break;

 				}

 

@@ -3725,11 +4385,12 @@ TCB_t *pxTCB;
 				pcWriteBuffer = prvWriteNameToBuffer( pcWriteBuffer, pxTaskStatusArray[ x ].pcTaskName );

 

 				/* Write the rest of the string. */

-				sprintf( pcWriteBuffer, "\t%c\t%u\t%u\t%u\r\n", cStatus, ( unsigned int ) pxTaskStatusArray[ x ].uxCurrentPriority, ( unsigned int ) pxTaskStatusArray[ x ].usStackHighWaterMark, ( unsigned int ) pxTaskStatusArray[ x ].xTaskNumber );

-				pcWriteBuffer += strlen( pcWriteBuffer );

+				sprintf( pcWriteBuffer, "\t%c\t%u\t%u\t%u\r\n", cStatus, ( unsigned int ) pxTaskStatusArray[ x ].uxCurrentPriority, ( unsigned int ) pxTaskStatusArray[ x ].usStackHighWaterMark, ( unsigned int ) pxTaskStatusArray[ x ].xTaskNumber ); /*lint !e586 sprintf() allowed as this is compiled with many compilers and this is a utility function only - not part of the core kernel implementation. */

+				pcWriteBuffer += strlen( pcWriteBuffer ); /*lint !e9016 Pointer arithmetic ok on char pointers especially as in this case where it best denotes the intent of the code. */

 			}

 

-			/* Free the array again. */

+			/* Free the array again.  NOTE!  If configSUPPORT_DYNAMIC_ALLOCATION

+			is 0 then vPortFree() will be #defined to nothing. */

 			vPortFree( pxTaskStatusArray );

 		}

 		else

@@ -3738,15 +4399,15 @@ TCB_t *pxTCB;
 		}

 	}

 

-#endif /* ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) ) */

+#endif /* ( ( configUSE_TRACE_FACILITY == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) ) */

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

 

-#if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) )

+#if ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_DYNAMIC_ALLOCATION == 1 ) )

 

 	void vTaskGetRunTimeStats( char *pcWriteBuffer )

 	{

 	TaskStatus_t *pxTaskStatusArray;

-	volatile UBaseType_t uxArraySize, x;

+	UBaseType_t uxArraySize, x;

 	uint32_t ulTotalTime, ulStatsAsPercentage;

 

 		#if( configUSE_TRACE_FACILITY != 1 )

@@ -3781,14 +4442,16 @@ TCB_t *pxTCB;
 		 */

 

 		/* Make sure the write buffer does not contain a string. */

-		*pcWriteBuffer = 0x00;

+		*pcWriteBuffer = ( char ) 0x00;

 

 		/* Take a snapshot of the number of tasks in case it changes while this

 		function is executing. */

 		uxArraySize = uxCurrentNumberOfTasks;

 

-		/* Allocate an array index for each task. */

-		pxTaskStatusArray = pvPortMalloc( uxCurrentNumberOfTasks * sizeof( TaskStatus_t ) );

+		/* Allocate an array index for each task.  NOTE!  If

+		configSUPPORT_DYNAMIC_ALLOCATION is set to 0 then pvPortMalloc() will

+		equate to NULL. */

+		pxTaskStatusArray = pvPortMalloc( uxCurrentNumberOfTasks * sizeof( TaskStatus_t ) ); /*lint !e9079 All values returned by pvPortMalloc() have at least the alignment required by the MCU's stack and this allocation allocates a struct that has the alignment requirements of a pointer. */

 

 		if( pxTaskStatusArray != NULL )

 		{

@@ -3799,7 +4462,7 @@ TCB_t *pxTCB;
 			ulTotalTime /= 100UL;

 

 			/* Avoid divide by zero errors. */

-			if( ulTotalTime > 0 )

+			if( ulTotalTime > 0UL )

 			{

 				/* Create a human readable table from the binary data. */

 				for( x = 0; x < uxArraySize; x++ )

@@ -3824,7 +4487,7 @@ TCB_t *pxTCB;
 						{

 							/* sizeof( int ) == sizeof( long ) so a smaller

 							printf() library can be used. */

-							sprintf( pcWriteBuffer, "\t%u\t\t%u%%\r\n", ( unsigned int ) pxTaskStatusArray[ x ].ulRunTimeCounter, ( unsigned int ) ulStatsAsPercentage );

+							sprintf( pcWriteBuffer, "\t%u\t\t%u%%\r\n", ( unsigned int ) pxTaskStatusArray[ x ].ulRunTimeCounter, ( unsigned int ) ulStatsAsPercentage ); /*lint !e586 sprintf() allowed as this is compiled with many compilers and this is a utility function only - not part of the core kernel implementation. */

 						}

 						#endif

 					}

@@ -3840,12 +4503,12 @@ TCB_t *pxTCB;
 						{

 							/* sizeof( int ) == sizeof( long ) so a smaller

 							printf() library can be used. */

-							sprintf( pcWriteBuffer, "\t%u\t\t<1%%\r\n", ( unsigned int ) pxTaskStatusArray[ x ].ulRunTimeCounter );

+							sprintf( pcWriteBuffer, "\t%u\t\t<1%%\r\n", ( unsigned int ) pxTaskStatusArray[ x ].ulRunTimeCounter ); /*lint !e586 sprintf() allowed as this is compiled with many compilers and this is a utility function only - not part of the core kernel implementation. */

 						}

 						#endif

 					}

 

-					pcWriteBuffer += strlen( pcWriteBuffer );

+					pcWriteBuffer += strlen( pcWriteBuffer ); /*lint !e9016 Pointer arithmetic ok on char pointers especially as in this case where it best denotes the intent of the code. */

 				}

 			}

 			else

@@ -3853,7 +4516,8 @@ TCB_t *pxTCB;
 				mtCOVERAGE_TEST_MARKER();

 			}

 

-			/* Free the array again. */

+			/* Free the array again.  NOTE!  If configSUPPORT_DYNAMIC_ALLOCATION

+			is 0 then vPortFree() will be #defined to nothing. */

 			vPortFree( pxTaskStatusArray );

 		}

 		else

@@ -3862,7 +4526,7 @@ TCB_t *pxTCB;
 		}

 	}

 

-#endif /* ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) ) */

+#endif /* ( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( configUSE_STATS_FORMATTING_FUNCTIONS > 0 ) && ( configSUPPORT_STATIC_ALLOCATION == 1 ) ) */

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

 

 TickType_t uxTaskResetEventItemValue( void )

@@ -3881,7 +4545,7 @@ TickType_t uxReturn;
 

 #if ( configUSE_MUTEXES == 1 )

 

-	void *pvTaskIncrementMutexHeldCount( void )

+	TaskHandle_t pvTaskIncrementMutexHeldCount( void )

 	{

 		/* If xSemaphoreCreateMutex() is called before any tasks have been created

 		then pxCurrentTCB will be NULL. */

@@ -3900,7 +4564,6 @@ TickType_t uxReturn;
 

 	uint32_t ulTaskNotifyTake( BaseType_t xClearCountOnExit, TickType_t xTicksToWait )

 	{

-	TickType_t xTimeToWake;

 	uint32_t ulReturn;

 

 		taskENTER_CRITICAL();

@@ -3909,55 +4572,11 @@ TickType_t uxReturn;
 			if( pxCurrentTCB->ulNotifiedValue == 0UL )

 			{

 				/* Mark this task as waiting for a notification. */

-				pxCurrentTCB->eNotifyState = eWaitingNotification;

+				pxCurrentTCB->ucNotifyState = taskWAITING_NOTIFICATION;

 

 				if( xTicksToWait > ( TickType_t ) 0 )

 				{

-					/* The task is going to block.  First it must be removed

-					from the ready list. */

-					if( uxListRemove( &( pxCurrentTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )

-					{

-						/* The current task must be in a ready list, so there is

-						no need to check, and the port reset macro can be called

-						directly. */

-						portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority );

-					}

-					else

-					{

-						mtCOVERAGE_TEST_MARKER();

-					}

-

-					#if ( INCLUDE_vTaskSuspend == 1 )

-					{

-						if( xTicksToWait == portMAX_DELAY )

-						{

-							/* Add the task to the suspended task list instead

-							of a delayed task list to ensure the task is not

-							woken by a timing event.  It will block

-							indefinitely. */

-							vListInsertEnd( &xSuspendedTaskList, &( pxCurrentTCB->xGenericListItem ) );

-						}

-						else

-						{

-							/* Calculate the time at which the task should be

-							woken if no notification events occur.  This may

-							overflow but this doesn't matter, the scheduler will

-							handle it. */

-							xTimeToWake = xTickCount + xTicksToWait;

-							prvAddCurrentTaskToDelayedList( xTimeToWake );

-						}

-					}

-					#else /* INCLUDE_vTaskSuspend */

-					{

-							/* Calculate the time at which the task should be

-							woken if the event does not occur.  This may

-							overflow but this doesn't matter, the scheduler will

-							handle it. */

-							xTimeToWake = xTickCount + xTicksToWait;

-							prvAddCurrentTaskToDelayedList( xTimeToWake );

-					}

-					#endif /* INCLUDE_vTaskSuspend */

-

+					prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );

 					traceTASK_NOTIFY_TAKE_BLOCK();

 

 					/* All ports are written to allow a yield in a critical

@@ -3991,7 +4610,7 @@ TickType_t uxReturn;
 				}

 				else

 				{

-					( pxCurrentTCB->ulNotifiedValue )--;

+					pxCurrentTCB->ulNotifiedValue = ulReturn - ( uint32_t ) 1;

 				}

 			}

 			else

@@ -3999,7 +4618,7 @@ TickType_t uxReturn;
 				mtCOVERAGE_TEST_MARKER();

 			}

 

-			pxCurrentTCB->eNotifyState = eNotWaitingNotification;

+			pxCurrentTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;

 		}

 		taskEXIT_CRITICAL();

 

@@ -4013,13 +4632,12 @@ TickType_t uxReturn;
 

 	BaseType_t xTaskNotifyWait( uint32_t ulBitsToClearOnEntry, uint32_t ulBitsToClearOnExit, uint32_t *pulNotificationValue, TickType_t xTicksToWait )

 	{

-	TickType_t xTimeToWake;

 	BaseType_t xReturn;

 

 		taskENTER_CRITICAL();

 		{

 			/* Only block if a notification is not already pending. */

-			if( pxCurrentTCB->eNotifyState != eNotified )

+			if( pxCurrentTCB->ucNotifyState != taskNOTIFICATION_RECEIVED )

 			{

 				/* Clear bits in the task's notification value as bits may get

 				set	by the notifying task or interrupt.  This can be used to

@@ -4027,55 +4645,11 @@ TickType_t uxReturn;
 				pxCurrentTCB->ulNotifiedValue &= ~ulBitsToClearOnEntry;

 

 				/* Mark this task as waiting for a notification. */

-				pxCurrentTCB->eNotifyState = eWaitingNotification;

+				pxCurrentTCB->ucNotifyState = taskWAITING_NOTIFICATION;

 

 				if( xTicksToWait > ( TickType_t ) 0 )

 				{

-					/* The task is going to block.  First it must be removed

-					from the	ready list. */

-					if( uxListRemove( &( pxCurrentTCB->xGenericListItem ) ) == ( UBaseType_t ) 0 )

-					{

-						/* The current task must be in a ready list, so there is

-						no need to check, and the port reset macro can be called

-						directly. */

-						portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority );

-					}

-					else

-					{

-						mtCOVERAGE_TEST_MARKER();

-					}

-

-					#if ( INCLUDE_vTaskSuspend == 1 )

-					{

-						if( xTicksToWait == portMAX_DELAY )

-						{

-							/* Add the task to the suspended task list instead

-							of a delayed task list to ensure the task is not

-							woken by a timing event.  It will block

-							indefinitely. */

-							vListInsertEnd( &xSuspendedTaskList, &( pxCurrentTCB->xGenericListItem ) );

-						}

-						else

-						{

-							/* Calculate the time at which the task should be

-							woken if no notification events occur.  This may

-							overflow but this doesn't matter, the scheduler will

-							handle it. */

-							xTimeToWake = xTickCount + xTicksToWait;

-							prvAddCurrentTaskToDelayedList( xTimeToWake );

-						}

-					}

-					#else /* INCLUDE_vTaskSuspend */

-					{

-							/* Calculate the time at which the task should be

-							woken if the event does not occur.  This may

-							overflow but this doesn't matter, the scheduler will

-							handle it. */

-							xTimeToWake = xTickCount + xTicksToWait;

-							prvAddCurrentTaskToDelayedList( xTimeToWake );

-					}

-					#endif /* INCLUDE_vTaskSuspend */

-

+					prvAddCurrentTaskToDelayedList( xTicksToWait, pdTRUE );

 					traceTASK_NOTIFY_WAIT_BLOCK();

 

 					/* All ports are written to allow a yield in a critical

@@ -4107,11 +4681,11 @@ TickType_t uxReturn;
 				*pulNotificationValue = pxCurrentTCB->ulNotifiedValue;

 			}

 

-			/* If eNotifyValue is set then either the task never entered the

+			/* If ucNotifyValue is set then either the task never entered the

 			blocked state (because a notification was already pending) or the

 			task unblocked because of a notification.  Otherwise the task

 			unblocked because of a timeout. */

-			if( pxCurrentTCB->eNotifyState == eWaitingNotification )

+			if( pxCurrentTCB->ucNotifyState != taskNOTIFICATION_RECEIVED )

 			{

 				/* A notification was not received. */

 				xReturn = pdFALSE;

@@ -4124,7 +4698,7 @@ TickType_t uxReturn;
 				xReturn = pdTRUE;

 			}

 

-			pxCurrentTCB->eNotifyState = eNotWaitingNotification;

+			pxCurrentTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;

 		}

 		taskEXIT_CRITICAL();

 

@@ -4139,11 +4713,11 @@ TickType_t uxReturn;
 	BaseType_t xTaskGenericNotify( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue )

 	{

 	TCB_t * pxTCB;

-	eNotifyValue eOriginalNotifyState;

 	BaseType_t xReturn = pdPASS;

+	uint8_t ucOriginalNotifyState;

 

 		configASSERT( xTaskToNotify );

-		pxTCB = ( TCB_t * ) xTaskToNotify;

+		pxTCB = xTaskToNotify;

 

 		taskENTER_CRITICAL();

 		{

@@ -4152,9 +4726,9 @@ TickType_t uxReturn;
 				*pulPreviousNotificationValue = pxTCB->ulNotifiedValue;

 			}

 

-			eOriginalNotifyState = pxTCB->eNotifyState;

+			ucOriginalNotifyState = pxTCB->ucNotifyState;

 

-			pxTCB->eNotifyState = eNotified;

+			pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;

 

 			switch( eAction )

 			{

@@ -4171,7 +4745,7 @@ TickType_t uxReturn;
 					break;

 

 				case eSetValueWithoutOverwrite :

-					if( eOriginalNotifyState != eNotified )

+					if( ucOriginalNotifyState != taskNOTIFICATION_RECEIVED )

 					{

 						pxTCB->ulNotifiedValue = ulValue;

 					}

@@ -4186,15 +4760,23 @@ TickType_t uxReturn;
 					/* The task is being notified without its notify value being

 					updated. */

 					break;

+

+				default:

+					/* Should not get here if all enums are handled.

+					Artificially force an assert by testing a value the

+					compiler can't assume is const. */

+					configASSERT( pxTCB->ulNotifiedValue == ~0UL );

+

+					break;

 			}

 

 			traceTASK_NOTIFY();

 

 			/* If the task is in the blocked state specifically to wait for a

 			notification then unblock it now. */

-			if( eOriginalNotifyState == eWaitingNotification )

+			if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )

 			{

-				( void ) uxListRemove( &( pxTCB->xGenericListItem ) );

+				( void ) uxListRemove( &( pxTCB->xStateListItem ) );

 				prvAddTaskToReadyList( pxTCB );

 

 				/* The task should not have been on an event list. */

@@ -4245,7 +4827,7 @@ TickType_t uxReturn;
 	BaseType_t xTaskGenericNotifyFromISR( TaskHandle_t xTaskToNotify, uint32_t ulValue, eNotifyAction eAction, uint32_t *pulPreviousNotificationValue, BaseType_t *pxHigherPriorityTaskWoken )

 	{

 	TCB_t * pxTCB;

-	eNotifyValue eOriginalNotifyState;

+	uint8_t ucOriginalNotifyState;

 	BaseType_t xReturn = pdPASS;

 	UBaseType_t uxSavedInterruptStatus;

 

@@ -4269,7 +4851,7 @@ TickType_t uxReturn;
 		http://www.freertos.org/RTOS-Cortex-M3-M4.html */

 		portASSERT_IF_INTERRUPT_PRIORITY_INVALID();

 

-		pxTCB = ( TCB_t * ) xTaskToNotify;

+		pxTCB = xTaskToNotify;

 

 		uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();

 		{

@@ -4278,8 +4860,8 @@ TickType_t uxReturn;
 				*pulPreviousNotificationValue = pxTCB->ulNotifiedValue;

 			}

 

-			eOriginalNotifyState = pxTCB->eNotifyState;

-			pxTCB->eNotifyState = eNotified;

+			ucOriginalNotifyState = pxTCB->ucNotifyState;

+			pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;

 

 			switch( eAction )

 			{

@@ -4296,7 +4878,7 @@ TickType_t uxReturn;
 					break;

 

 				case eSetValueWithoutOverwrite :

-					if( eOriginalNotifyState != eNotified )

+					if( ucOriginalNotifyState != taskNOTIFICATION_RECEIVED )

 					{

 						pxTCB->ulNotifiedValue = ulValue;

 					}

@@ -4311,20 +4893,27 @@ TickType_t uxReturn;
 					/* The task is being notified without its notify value being

 					updated. */

 					break;

+

+				default:

+					/* Should not get here if all enums are handled.

+					Artificially force an assert by testing a value the

+					compiler can't assume is const. */

+					configASSERT( pxTCB->ulNotifiedValue == ~0UL );

+					break;

 			}

 

 			traceTASK_NOTIFY_FROM_ISR();

 

 			/* If the task is in the blocked state specifically to wait for a

 			notification then unblock it now. */

-			if( eOriginalNotifyState == eWaitingNotification )

+			if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )

 			{

 				/* The task should not have been on an event list. */

 				configASSERT( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL );

 

 				if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )

 				{

-					( void ) uxListRemove( &( pxTCB->xGenericListItem ) );

+					( void ) uxListRemove( &( pxTCB->xStateListItem ) );

 					prvAddTaskToReadyList( pxTCB );

 				}

 				else

@@ -4342,6 +4931,11 @@ TickType_t uxReturn;
 					{

 						*pxHigherPriorityTaskWoken = pdTRUE;

 					}

+

+					/* Mark that a yield is pending in case the user is not

+					using the "xHigherPriorityTaskWoken" parameter to an ISR

+					safe FreeRTOS function. */

+					xYieldPending = pdTRUE;

 				}

 				else

 				{

@@ -4362,7 +4956,7 @@ TickType_t uxReturn;
 	void vTaskNotifyGiveFromISR( TaskHandle_t xTaskToNotify, BaseType_t *pxHigherPriorityTaskWoken )

 	{

 	TCB_t * pxTCB;

-	eNotifyValue eOriginalNotifyState;

+	uint8_t ucOriginalNotifyState;

 	UBaseType_t uxSavedInterruptStatus;

 

 		configASSERT( xTaskToNotify );

@@ -4385,12 +4979,12 @@ TickType_t uxReturn;
 		http://www.freertos.org/RTOS-Cortex-M3-M4.html */

 		portASSERT_IF_INTERRUPT_PRIORITY_INVALID();

 

-		pxTCB = ( TCB_t * ) xTaskToNotify;

+		pxTCB = xTaskToNotify;

 

 		uxSavedInterruptStatus = portSET_INTERRUPT_MASK_FROM_ISR();

 		{

-			eOriginalNotifyState = pxTCB->eNotifyState;

-			pxTCB->eNotifyState = eNotified;

+			ucOriginalNotifyState = pxTCB->ucNotifyState;

+			pxTCB->ucNotifyState = taskNOTIFICATION_RECEIVED;

 

 			/* 'Giving' is equivalent to incrementing a count in a counting

 			semaphore. */

@@ -4400,14 +4994,14 @@ TickType_t uxReturn;
 

 			/* If the task is in the blocked state specifically to wait for a

 			notification then unblock it now. */

-			if( eOriginalNotifyState == eWaitingNotification )

+			if( ucOriginalNotifyState == taskWAITING_NOTIFICATION )

 			{

 				/* The task should not have been on an event list. */

 				configASSERT( listLIST_ITEM_CONTAINER( &( pxTCB->xEventListItem ) ) == NULL );

 

 				if( uxSchedulerSuspended == ( UBaseType_t ) pdFALSE )

 				{

-					( void ) uxListRemove( &( pxTCB->xGenericListItem ) );

+					( void ) uxListRemove( &( pxTCB->xStateListItem ) );

 					prvAddTaskToReadyList( pxTCB );

 				}

 				else

@@ -4425,6 +5019,11 @@ TickType_t uxReturn;
 					{

 						*pxHigherPriorityTaskWoken = pdTRUE;

 					}

+

+					/* Mark that a yield is pending in case the user is not

+					using the "xHigherPriorityTaskWoken" parameter in an ISR

+					safe FreeRTOS function. */

+					xYieldPending = pdTRUE;

 				}

 				else

 				{

@@ -4446,17 +5045,15 @@ TickType_t uxReturn;
 	TCB_t *pxTCB;

 	BaseType_t xReturn;

 

-		pxTCB = ( TCB_t * ) xTask;

-

 		/* If null is passed in here then it is the calling task that is having

 		its notification state cleared. */

-		pxTCB = prvGetTCBFromHandle( pxTCB );

+		pxTCB = prvGetTCBFromHandle( xTask );

 

 		taskENTER_CRITICAL();

 		{

-			if( pxTCB->eNotifyState == eNotified )

+			if( pxTCB->ucNotifyState == taskNOTIFICATION_RECEIVED )

 			{

-				pxTCB->eNotifyState = eNotWaitingNotification;

+				pxTCB->ucNotifyState = taskNOT_WAITING_NOTIFICATION;

 				xReturn = pdPASS;

 			}

 			else

@@ -4470,8 +5067,147 @@ TickType_t uxReturn;
 	}

 

 #endif /* configUSE_TASK_NOTIFICATIONS */

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

+

+#if( ( configGENERATE_RUN_TIME_STATS == 1 ) && ( INCLUDE_xTaskGetIdleTaskHandle == 1 ) )

+	TickType_t xTaskGetIdleRunTimeCounter( void )

+	{

+		return xIdleTaskHandle->ulRunTimeCounter;

+	}

+#endif

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

+

+static void prvAddCurrentTaskToDelayedList( TickType_t xTicksToWait, const BaseType_t xCanBlockIndefinitely )

+{

+TickType_t xTimeToWake;

+const TickType_t xConstTickCount = xTickCount;

+

+	#if( INCLUDE_xTaskAbortDelay == 1 )

+	{

+		/* About to enter a delayed list, so ensure the ucDelayAborted flag is

+		reset to pdFALSE so it can be detected as having been set to pdTRUE

+		when the task leaves the Blocked state. */

+		pxCurrentTCB->ucDelayAborted = pdFALSE;

+	}

+	#endif

+

+	/* Remove the task from the ready list before adding it to the blocked list

+	as the same list item is used for both lists. */

+	if( uxListRemove( &( pxCurrentTCB->xStateListItem ) ) == ( UBaseType_t ) 0 )

+	{

+		/* The current task must be in a ready list, so there is no need to

+		check, and the port reset macro can be called directly. */

+		portRESET_READY_PRIORITY( pxCurrentTCB->uxPriority, uxTopReadyPriority ); /*lint !e931 pxCurrentTCB cannot change as it is the calling task.  pxCurrentTCB->uxPriority and uxTopReadyPriority cannot change as called with scheduler suspended or in a critical section. */

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

+

+	#if ( INCLUDE_vTaskSuspend == 1 )

+	{

+		if( ( xTicksToWait == portMAX_DELAY ) && ( xCanBlockIndefinitely != pdFALSE ) )

+		{

+			/* Add the task to the suspended task list instead of a delayed task

+			list to ensure it is not woken by a timing event.  It will block

+			indefinitely. */

+			vListInsertEnd( &xSuspendedTaskList, &( pxCurrentTCB->xStateListItem ) );

+		}

+		else

+		{

+			/* Calculate the time at which the task should be woken if the event

+			does not occur.  This may overflow but this doesn't matter, the

+			kernel will manage it correctly. */

+			xTimeToWake = xConstTickCount + xTicksToWait;

+

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

+			listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xStateListItem ), xTimeToWake );

+

+			if( xTimeToWake < xConstTickCount )

+			{

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

+				list. */

+				vListInsert( pxOverflowDelayedTaskList, &( pxCurrentTCB->xStateListItem ) );

+			}

+			else

+			{

+				/* The wake time has not overflowed, so the current block list

+				is used. */

+				vListInsert( pxDelayedTaskList, &( pxCurrentTCB->xStateListItem ) );

+

+				/* If the task entering the blocked state was placed at the

+				head of the list of blocked tasks then xNextTaskUnblockTime

+				needs to be updated too. */

+				if( xTimeToWake < xNextTaskUnblockTime )

+				{

+					xNextTaskUnblockTime = xTimeToWake;

+				}

+				else

+				{

+					mtCOVERAGE_TEST_MARKER();

+				}

+			}

+		}

+	}

+	#else /* INCLUDE_vTaskSuspend */

+	{

+		/* Calculate the time at which the task should be woken if the event

+		does not occur.  This may overflow but this doesn't matter, the kernel

+		will manage it correctly. */

+		xTimeToWake = xConstTickCount + xTicksToWait;

+

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

+		listSET_LIST_ITEM_VALUE( &( pxCurrentTCB->xStateListItem ), xTimeToWake );

+

+		if( xTimeToWake < xConstTickCount )

+		{

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

+			vListInsert( pxOverflowDelayedTaskList, &( pxCurrentTCB->xStateListItem ) );

+		}

+		else

+		{

+			/* The wake time has not overflowed, so the current block list is used. */

+			vListInsert( pxDelayedTaskList, &( pxCurrentTCB->xStateListItem ) );

+

+			/* If the task entering the blocked state was placed at the head of the

+			list of blocked tasks then xNextTaskUnblockTime needs to be updated

+			too. */

+			if( xTimeToWake < xNextTaskUnblockTime )

+			{

+				xNextTaskUnblockTime = xTimeToWake;

+			}

+			else

+			{

+				mtCOVERAGE_TEST_MARKER();

+			}

+		}

+

+		/* Avoid compiler warning when INCLUDE_vTaskSuspend is not 1. */

+		( void ) xCanBlockIndefinitely;

+	}

+	#endif /* INCLUDE_vTaskSuspend */

+}

+

+/* Code below here allows additional code to be inserted into this source file,

+especially where access to file scope functions and data is needed (for example

+when performing module tests). */

 

 #ifdef FREERTOS_MODULE_TEST

 	#include "tasks_test_access_functions.h"

 #endif

 

+

+#if( configINCLUDE_FREERTOS_TASK_C_ADDITIONS_H == 1 )

+

+	#include "freertos_tasks_c_additions.h"

+

+	#ifdef FREERTOS_TASKS_C_ADDITIONS_INIT

+		static void freertos_tasks_c_additions_init( void )

+		{

+			FREERTOS_TASKS_C_ADDITIONS_INIT();

+		}

+	#endif

+

+#endif

+

+

diff --git a/src/FreeRTOS/Source/timers.c b/src/FreeRTOS/Source/timers.c
index c7ab902..280cc4d 100644
--- a/src/FreeRTOS/Source/timers.c
+++ b/src/FreeRTOS/Source/timers.c
@@ -1,71 +1,29 @@
 /*

-    FreeRTOS V8.2.3 - Copyright (C) 2015 Real Time Engineers Ltd.

-    All rights reserved

-

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

-

-    This file is part of the FreeRTOS distribution.

-

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

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

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

-

-    ***************************************************************************

-    >>!   NOTE: The modification to the GPL is included to allow you to     !<<

-    >>!   distribute a combined work that includes FreeRTOS without being   !<<

-    >>!   obliged to provide the source code for proprietary components     !<<

-    >>!   outside of the FreeRTOS kernel.                                   !<<

-    ***************************************************************************

-

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

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

-    FOR A PARTICULAR PURPOSE.  Full license text is available on the following

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

-

-    ***************************************************************************

-     *                                                                       *

-     *    FreeRTOS provides completely free yet professionally developed,    *

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

-     *    platform software that is more than just the market leader, it     *

-     *    is the industry's de facto standard.                               *

-     *                                                                       *

-     *    Help yourself get started quickly while simultaneously helping     *

-     *    to support the FreeRTOS project by purchasing a FreeRTOS           *

-     *    tutorial book, reference manual, or both:                          *

-     *    http://www.FreeRTOS.org/Documentation                              *

-     *                                                                       *

-    ***************************************************************************

-

-    http://www.FreeRTOS.org/FAQHelp.html - Having a problem?  Start by reading

-    the FAQ page "My application does not run, what could be wrong?".  Have you

-    defined configASSERT()?

-

-    http://www.FreeRTOS.org/support - In return for receiving this top quality

-    embedded software for free we request you assist our global community by

-    participating in the support forum.

-

-    http://www.FreeRTOS.org/training - Investing in training allows your team to

-    be as productive as possible as early as possible.  Now you can receive

-    FreeRTOS training directly from Richard Barry, CEO of Real Time Engineers

-    Ltd, and the world's leading authority on the world's leading RTOS.

-

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

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

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

-

-    http://www.FreeRTOS.org/labs - Where new FreeRTOS products go to incubate.

-    Come and try FreeRTOS+TCP, our new open source TCP/IP stack for FreeRTOS.

-

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

-    Integrity Systems ltd. to sell under the OpenRTOS brand.  Low cost OpenRTOS

-    licenses offer ticketed support, indemnification and commercial middleware.

-

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

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

-    mission critical applications that require provable dependability.

-

-    1 tab == 4 spaces!

-*/

+ * FreeRTOS Kernel V10.2.0

+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.

+ *

+ * Permission is hereby granted, free of charge, to any person obtaining a copy of

+ * this software and associated documentation files (the "Software"), to deal in

+ * the Software without restriction, including without limitation the rights to

+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of

+ * the Software, and to permit persons to whom the Software is furnished to do so,

+ * subject to the following conditions:

+ *

+ * The above copyright notice and this permission notice shall be included in all

+ * copies or substantial portions of the Software.

+ *

+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS

+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR

+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER

+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN

+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

+ *

+ * http://www.FreeRTOS.org

+ * http://aws.amazon.com/freertos

+ *

+ * 1 tab == 4 spaces!

+ */

 

 /* Standard includes. */

 #include <stdlib.h>

@@ -84,11 +42,11 @@ task.h is included from an application file. */
 	#error configUSE_TIMERS must be set to 1 to make the xTimerPendFunctionCall() function available.

 #endif

 

-/* Lint e961 and e750 are suppressed as a MISRA exception justified because the

-MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined for the

-header files above, but not in this file, in order to generate the correct

-privileged Vs unprivileged linkage and placement. */

-#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e961 !e750. */

+/* Lint e9021, e961 and e750 are suppressed as a MISRA exception justified

+because the MPU ports require MPU_WRAPPERS_INCLUDED_FROM_API_FILE to be defined

+for the header files above, but not in this file, in order to generate the

+correct privileged Vs unprivileged linkage and placement. */

+#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE /*lint !e9021 !e961 !e750. */

 

 

 /* This entire source file will be skipped if the application is not configured

@@ -100,18 +58,29 @@ configUSE_TIMERS is set to 1 in FreeRTOSConfig.h. */
 /* Misc definitions. */

 #define tmrNO_DELAY		( TickType_t ) 0U

 

+/* The name assigned to the timer service task.  This can be overridden by

+defining trmTIMER_SERVICE_TASK_NAME in FreeRTOSConfig.h. */

+#ifndef configTIMER_SERVICE_TASK_NAME

+	#define configTIMER_SERVICE_TASK_NAME "Tmr Svc"

+#endif

+

+/* Bit definitions used in the ucStatus member of a timer structure. */

+#define tmrSTATUS_IS_ACTIVE					( ( uint8_t ) 0x01 )

+#define tmrSTATUS_IS_STATICALLY_ALLOCATED	( ( uint8_t ) 0x02 )

+#define tmrSTATUS_IS_AUTORELOAD				( ( uint8_t ) 0x04 )

+

 /* The definition of the timers themselves. */

-typedef struct tmrTimerControl

+typedef struct tmrTimerControl /* The old naming convention is used to prevent breaking kernel aware debuggers. */

 {

 	const char				*pcTimerName;		/*<< Text name.  This is not used by the kernel, it is included simply to make debugging easier. */ /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

 	ListItem_t				xTimerListItem;		/*<< Standard linked list item as used by all kernel features for event management. */

 	TickType_t				xTimerPeriodInTicks;/*<< How quickly and often the timer expires. */

-	UBaseType_t				uxAutoReload;		/*<< Set to pdTRUE if the timer should be automatically restarted once expired.  Set to pdFALSE if the timer is, in effect, a one-shot timer. */

 	void 					*pvTimerID;			/*<< An ID to identify the timer.  This allows the timer to be identified when the same callback is used for multiple timers. */

 	TimerCallbackFunction_t	pxCallbackFunction;	/*<< The function that will be called when the timer expires. */

 	#if( configUSE_TRACE_FACILITY == 1 )

 		UBaseType_t			uxTimerNumber;		/*<< An ID assigned by trace tools such as FreeRTOS+Trace */

 	#endif

+	uint8_t 				ucStatus;			/*<< Holds bits to say if the timer was statically allocated or not, and if it is active or not. */

 } xTIMER;

 

 /* The old xTIMER name is maintained above then typedefed to the new Timer_t

@@ -154,12 +123,15 @@ typedef struct tmrTimerQueueMessage
 	} u;

 } DaemonTaskMessage_t;

 

-/*lint -e956 A manual analysis and inspection has been used to determine which

-static variables must be declared volatile. */

+/*lint -save -e956 A manual analysis and inspection has been used to determine

+which static variables must be declared volatile. */

 

 /* The list in which active timers are stored.  Timers are referenced in expire

 time order, with the nearest expiry time at the front of the list.  Only the

-timer service task is allowed to access these lists. */

+timer service task is allowed to access these lists.

+xActiveTimerList1 and xActiveTimerList2 could be at function scope but that

+breaks some kernel aware debuggers, and debuggers that reply on removing the

+static qualifier. */

 PRIVILEGED_DATA static List_t xActiveTimerList1;

 PRIVILEGED_DATA static List_t xActiveTimerList2;

 PRIVILEGED_DATA static List_t *pxCurrentTimerList;

@@ -167,16 +139,21 @@ PRIVILEGED_DATA static List_t *pxOverflowTimerList;
 

 /* A queue that is used to send commands to the timer service task. */

 PRIVILEGED_DATA static QueueHandle_t xTimerQueue = NULL;

+PRIVILEGED_DATA static TaskHandle_t xTimerTaskHandle = NULL;

 

-#if ( INCLUDE_xTimerGetTimerDaemonTaskHandle == 1 )

+/*lint -restore */

 

-	PRIVILEGED_DATA static TaskHandle_t xTimerTaskHandle = NULL;

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

 

-#endif

+#if( configSUPPORT_STATIC_ALLOCATION == 1 )

 

-/*lint +e956 */

+	/* If static allocation is supported then the application must provide the

+	following callback function - which enables the application to optionally

+	provide the memory that will be used by the timer task as the task's stack

+	and TCB. */

+	extern void vApplicationGetTimerTaskMemory( StaticTask_t **ppxTimerTaskTCBBuffer, StackType_t **ppxTimerTaskStackBuffer, uint32_t *pulTimerTaskStackSize );

 

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

+#endif

 

 /*

  * Initialise the infrastructure used by the timer service task if it has not

@@ -189,7 +166,7 @@ static void prvCheckForValidListAndQueue( void ) PRIVILEGED_FUNCTION;
  * task.  Other tasks communicate with the timer service task using the

  * xTimerQueue queue.

  */

-static void prvTimerTask( void *pvParameters ) PRIVILEGED_FUNCTION;

+static portTASK_FUNCTION_PROTO( prvTimerTask, pvParameters ) PRIVILEGED_FUNCTION;

 

 /*

  * Called by the timer service task to interpret and process a command it

@@ -235,6 +212,16 @@ static TickType_t prvGetNextExpireTime( BaseType_t * const pxListWasEmpty ) PRIV
  */

 static void prvProcessTimerOrBlockTask( const TickType_t xNextExpireTime, BaseType_t xListWasEmpty ) PRIVILEGED_FUNCTION;

 

+/*

+ * Called after a Timer_t structure has been allocated either statically or

+ * dynamically to fill in the structure's members.

+ */

+static void prvInitialiseNewTimer(	const char * const pcTimerName,			/*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+									const TickType_t xTimerPeriodInTicks,

+									const UBaseType_t uxAutoReload,

+									void * const pvTimerID,

+									TimerCallbackFunction_t pxCallbackFunction,

+									Timer_t *pxNewTimer ) PRIVILEGED_FUNCTION;

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

 

 BaseType_t xTimerCreateTimerTask( void )

@@ -249,18 +236,36 @@ BaseType_t xReturn = pdFAIL;
 

 	if( xTimerQueue != NULL )

 	{

-		#if ( INCLUDE_xTimerGetTimerDaemonTaskHandle == 1 )

+		#if( configSUPPORT_STATIC_ALLOCATION == 1 )

 		{

-			/* Create the timer task, storing its handle in xTimerTaskHandle so

-			it can be returned by the xTimerGetTimerDaemonTaskHandle() function. */

-			xReturn = xTaskCreate( prvTimerTask, "Tmr Svc", ( uint16_t ) configTIMER_TASK_STACK_DEPTH, NULL, ( ( UBaseType_t ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT, &xTimerTaskHandle );

+			StaticTask_t *pxTimerTaskTCBBuffer = NULL;

+			StackType_t *pxTimerTaskStackBuffer = NULL;

+			uint32_t ulTimerTaskStackSize;

+

+			vApplicationGetTimerTaskMemory( &pxTimerTaskTCBBuffer, &pxTimerTaskStackBuffer, &ulTimerTaskStackSize );

+			xTimerTaskHandle = xTaskCreateStatic(	prvTimerTask,

+													configTIMER_SERVICE_TASK_NAME,

+													ulTimerTaskStackSize,

+													NULL,

+													( ( UBaseType_t ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT,

+													pxTimerTaskStackBuffer,

+													pxTimerTaskTCBBuffer );

+

+			if( xTimerTaskHandle != NULL )

+			{

+				xReturn = pdPASS;

+			}

 		}

 		#else

 		{

-			/* Create the timer task without storing its handle. */

-			xReturn = xTaskCreate( prvTimerTask, "Tmr Svc", ( uint16_t ) configTIMER_TASK_STACK_DEPTH, NULL, ( ( UBaseType_t ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT, NULL);

+			xReturn = xTaskCreate(	prvTimerTask,

+									configTIMER_SERVICE_TASK_NAME,

+									configTIMER_TASK_STACK_DEPTH,

+									NULL,

+									( ( UBaseType_t ) configTIMER_TASK_PRIORITY ) | portPRIVILEGE_BIT,

+									&xTimerTaskHandle );

 		}

-		#endif

+		#endif /* configSUPPORT_STATIC_ALLOCATION */

 	}

 	else

 	{

@@ -272,44 +277,104 @@ BaseType_t xReturn = pdFAIL;
 }

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

 

-TimerHandle_t xTimerCreate( const char * const pcTimerName, const TickType_t xTimerPeriodInTicks, const UBaseType_t uxAutoReload, void * const pvTimerID, TimerCallbackFunction_t pxCallbackFunction ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

-{

-Timer_t *pxNewTimer;

+#if( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

 

-	/* Allocate the timer structure. */

-	if( xTimerPeriodInTicks == ( TickType_t ) 0U )

+	TimerHandle_t xTimerCreate(	const char * const pcTimerName,			/*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+								const TickType_t xTimerPeriodInTicks,

+								const UBaseType_t uxAutoReload,

+								void * const pvTimerID,

+								TimerCallbackFunction_t pxCallbackFunction )

 	{

-		pxNewTimer = NULL;

+	Timer_t *pxNewTimer;

+

+		pxNewTimer = ( Timer_t * ) pvPortMalloc( sizeof( Timer_t ) ); /*lint !e9087 !e9079 All values returned by pvPortMalloc() have at least the alignment required by the MCU's stack, and the first member of Timer_t is always a pointer to the timer's mame. */

+

+		if( pxNewTimer != NULL )

+		{

+			/* Status is thus far zero as the timer is not created statically

+			and has not been started.  The autoreload bit may get set in

+			prvInitialiseNewTimer. */

+			pxNewTimer->ucStatus = 0x00;

+			prvInitialiseNewTimer( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction, pxNewTimer );

+		}

+

+		return pxNewTimer;

 	}

-	else

+

+#endif /* configSUPPORT_DYNAMIC_ALLOCATION */

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

+

+#if( configSUPPORT_STATIC_ALLOCATION == 1 )

+

+	TimerHandle_t xTimerCreateStatic(	const char * const pcTimerName,		/*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+										const TickType_t xTimerPeriodInTicks,

+										const UBaseType_t uxAutoReload,

+										void * const pvTimerID,

+										TimerCallbackFunction_t pxCallbackFunction,

+										StaticTimer_t *pxTimerBuffer )

 	{

-		pxNewTimer = ( Timer_t * ) pvPortMalloc( sizeof( Timer_t ) );

-		if( pxNewTimer != NULL )

+	Timer_t *pxNewTimer;

+

+		#if( configASSERT_DEFINED == 1 )

 		{

-			/* Ensure the infrastructure used by the timer service task has been

-			created/initialised. */

-			prvCheckForValidListAndQueue();

-

-			/* Initialise the timer structure members using the function parameters. */

-			pxNewTimer->pcTimerName = pcTimerName;

-			pxNewTimer->xTimerPeriodInTicks = xTimerPeriodInTicks;

-			pxNewTimer->uxAutoReload = uxAutoReload;

-			pxNewTimer->pvTimerID = pvTimerID;

-			pxNewTimer->pxCallbackFunction = pxCallbackFunction;

-			vListInitialiseItem( &( pxNewTimer->xTimerListItem ) );

-

-			traceTIMER_CREATE( pxNewTimer );

+			/* Sanity check that the size of the structure used to declare a

+			variable of type StaticTimer_t equals the size of the real timer

+			structure. */

+			volatile size_t xSize = sizeof( StaticTimer_t );

+			configASSERT( xSize == sizeof( Timer_t ) );

+			( void ) xSize; /* Keeps lint quiet when configASSERT() is not defined. */

 		}

-		else

+		#endif /* configASSERT_DEFINED */

+

+		/* A pointer to a StaticTimer_t structure MUST be provided, use it. */

+		configASSERT( pxTimerBuffer );

+		pxNewTimer = ( Timer_t * ) pxTimerBuffer; /*lint !e740 !e9087 StaticTimer_t is a pointer to a Timer_t, so guaranteed to be aligned and sized correctly (checked by an assert()), so this is safe. */

+

+		if( pxNewTimer != NULL )

 		{

-			traceTIMER_CREATE_FAILED();

+			/* Timers can be created statically or dynamically so note this

+			timer was created statically in case it is later deleted.  The

+			autoreload bit may get set in prvInitialiseNewTimer(). */

+			pxNewTimer->ucStatus = tmrSTATUS_IS_STATICALLY_ALLOCATED;

+

+			prvInitialiseNewTimer( pcTimerName, xTimerPeriodInTicks, uxAutoReload, pvTimerID, pxCallbackFunction, pxNewTimer );

 		}

+

+		return pxNewTimer;

 	}

 

+#endif /* configSUPPORT_STATIC_ALLOCATION */

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

+

+static void prvInitialiseNewTimer(	const char * const pcTimerName,			/*lint !e971 Unqualified char types are allowed for strings and single characters only. */

+									const TickType_t xTimerPeriodInTicks,

+									const UBaseType_t uxAutoReload,

+									void * const pvTimerID,

+									TimerCallbackFunction_t pxCallbackFunction,

+									Timer_t *pxNewTimer )

+{

 	/* 0 is not a valid value for xTimerPeriodInTicks. */

 	configASSERT( ( xTimerPeriodInTicks > 0 ) );

 

-	return ( TimerHandle_t ) pxNewTimer;

+	if( pxNewTimer != NULL )

+	{

+		/* Ensure the infrastructure used by the timer service task has been

+		created/initialised. */

+		prvCheckForValidListAndQueue();

+

+		/* Initialise the timer structure members using the function

+		parameters. */

+		pxNewTimer->pcTimerName = pcTimerName;

+		pxNewTimer->xTimerPeriodInTicks = xTimerPeriodInTicks;

+		pxNewTimer->pvTimerID = pvTimerID;

+		pxNewTimer->pxCallbackFunction = pxCallbackFunction;

+		vListInitialiseItem( &( pxNewTimer->xTimerListItem ) );

+		if( uxAutoReload != pdFALSE )

+		{

+			pxNewTimer->ucStatus |= tmrSTATUS_IS_AUTORELOAD;

+		}

+		traceTIMER_CREATE( pxNewTimer );

+	}

 }

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

 

@@ -327,7 +392,7 @@ DaemonTaskMessage_t xMessage;
 		/* Send a command to the timer service task to start the xTimer timer. */

 		xMessage.xMessageID = xCommandID;

 		xMessage.u.xTimerParameters.xMessageValue = xOptionalValue;

-		xMessage.u.xTimerParameters.pxTimer = ( Timer_t * ) xTimer;

+		xMessage.u.xTimerParameters.pxTimer = xTimer;

 

 		if( xCommandID < tmrFIRST_FROM_ISR_COMMAND )

 		{

@@ -356,22 +421,58 @@ DaemonTaskMessage_t xMessage;
 }

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

 

-#if ( INCLUDE_xTimerGetTimerDaemonTaskHandle == 1 )

+TaskHandle_t xTimerGetTimerDaemonTaskHandle( void )

+{

+	/* If xTimerGetTimerDaemonTaskHandle() is called before the scheduler has been

+	started, then xTimerTaskHandle will be NULL. */

+	configASSERT( ( xTimerTaskHandle != NULL ) );

+	return xTimerTaskHandle;

+}

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

 

-	TaskHandle_t xTimerGetTimerDaemonTaskHandle( void )

+TickType_t xTimerGetPeriod( TimerHandle_t xTimer )

+{

+Timer_t *pxTimer = xTimer;

+

+	configASSERT( xTimer );

+	return pxTimer->xTimerPeriodInTicks;

+}

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

+

+void vTimerSetReloadMode( TimerHandle_t xTimer, const UBaseType_t uxAutoReload )

+{

+Timer_t * pxTimer =  xTimer;

+

+	configASSERT( xTimer );

+	taskENTER_CRITICAL();

 	{

-		/* If xTimerGetTimerDaemonTaskHandle() is called before the scheduler has been

-		started, then xTimerTaskHandle will be NULL. */

-		configASSERT( ( xTimerTaskHandle != NULL ) );

-		return xTimerTaskHandle;

+		if( uxAutoReload != pdFALSE )

+		{

+			pxTimer->ucStatus |= tmrSTATUS_IS_AUTORELOAD;

+		}

+		else

+		{

+			pxTimer->ucStatus &= ~tmrSTATUS_IS_AUTORELOAD;

+		}

 	}

+	taskEXIT_CRITICAL();

+}

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

 

-#endif

+TickType_t xTimerGetExpiryTime( TimerHandle_t xTimer )

+{

+Timer_t * pxTimer =  xTimer;

+TickType_t xReturn;

+

+	configASSERT( xTimer );

+	xReturn = listGET_LIST_ITEM_VALUE( &( pxTimer->xTimerListItem ) );

+	return xReturn;

+}

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

 

-const char * pcTimerGetTimerName( TimerHandle_t xTimer )

+const char * pcTimerGetName( TimerHandle_t xTimer ) /*lint !e971 Unqualified char types are allowed for strings and single characters only. */

 {

-Timer_t *pxTimer = ( Timer_t * ) xTimer;

+Timer_t *pxTimer = xTimer;

 

 	configASSERT( xTimer );

 	return pxTimer->pcTimerName;

@@ -381,7 +482,7 @@ Timer_t *pxTimer = ( Timer_t * ) xTimer;
 static void prvProcessExpiredTimer( const TickType_t xNextExpireTime, const TickType_t xTimeNow )

 {

 BaseType_t xResult;

-Timer_t * const pxTimer = ( Timer_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxCurrentTimerList );

+Timer_t * const pxTimer = ( Timer_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxCurrentTimerList ); /*lint !e9087 !e9079 void * is used as this macro is used with tasks and co-routines too.  Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */

 

 	/* Remove the timer from the list of active timers.  A check has already

 	been performed to ensure the list is not empty. */

@@ -390,12 +491,12 @@ Timer_t * const pxTimer = ( Timer_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxCurrentTi
 

 	/* If the timer is an auto reload timer then calculate the next

 	expiry time and re-insert the timer in the list of active timers. */

-	if( pxTimer->uxAutoReload == ( UBaseType_t ) pdTRUE )

+	if( ( pxTimer->ucStatus & tmrSTATUS_IS_AUTORELOAD ) != 0 )

 	{

 		/* The timer is inserted into a list using a time relative to anything

 		other than the current time.  It will therefore be inserted into the

 		correct list relative to the time this task thinks it is now. */

-		if( prvInsertTimerInActiveList( pxTimer, ( xNextExpireTime + pxTimer->xTimerPeriodInTicks ), xTimeNow, xNextExpireTime ) == pdTRUE )

+		if( prvInsertTimerInActiveList( pxTimer, ( xNextExpireTime + pxTimer->xTimerPeriodInTicks ), xTimeNow, xNextExpireTime ) != pdFALSE )

 		{

 			/* The timer expired before it was added to the active timer

 			list.  Reload it now.  */

@@ -410,6 +511,7 @@ Timer_t * const pxTimer = ( Timer_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxCurrentTi
 	}

 	else

 	{

+		pxTimer->ucStatus &= ~tmrSTATUS_IS_ACTIVE;

 		mtCOVERAGE_TEST_MARKER();

 	}

 

@@ -418,7 +520,7 @@ Timer_t * const pxTimer = ( Timer_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxCurrentTi
 }

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

 

-static void prvTimerTask( void *pvParameters )

+static portTASK_FUNCTION( prvTimerTask, pvParameters )

 {

 TickType_t xNextExpireTime;

 BaseType_t xListWasEmpty;

@@ -426,6 +528,18 @@ BaseType_t xListWasEmpty;
 	/* Just to avoid compiler warnings. */

 	( void ) pvParameters;

 

+	#if( configUSE_DAEMON_TASK_STARTUP_HOOK == 1 )

+	{

+		extern void vApplicationDaemonTaskStartupHook( void );

+

+		/* Allow the application writer to execute some code in the context of

+		this task at the point the task starts executing.  This is useful if the

+		application includes initialisation code that would benefit from

+		executing after the scheduler has been started. */

+		vApplicationDaemonTaskStartupHook();

+	}

+	#endif /* configUSE_DAEMON_TASK_STARTUP_HOOK */

+

 	for( ;; )

 	{

 		/* Query the timers list to see if it contains any timers, and if so,

@@ -562,7 +676,7 @@ BaseType_t xProcessTimerNow = pdFALSE;
 	{

 		/* Has the expiry time elapsed between the command to start/reset a

 		timer was issued, and the time the command was processed? */

-		if( ( xTimeNow - xCommandTime ) >= pxTimer->xTimerPeriodInTicks )

+		if( ( ( TickType_t ) ( xTimeNow - xCommandTime ) ) >= pxTimer->xTimerPeriodInTicks ) /*lint !e961 MISRA exception as the casts are only redundant for some ports. */

 		{

 			/* The time between a command being issued and the command being

 			processed actually exceeds the timers period.  */

@@ -631,7 +745,7 @@ TickType_t xTimeNow;
 			software timer. */

 			pxTimer = xMessage.u.xTimerParameters.pxTimer;

 

-			if( listIS_CONTAINED_WITHIN( NULL, &( pxTimer->xTimerListItem ) ) == pdFALSE )

+			if( listIS_CONTAINED_WITHIN( NULL, &( pxTimer->xTimerListItem ) ) == pdFALSE ) /*lint !e961. The cast is only redundant when NULL is passed into the macro. */

 			{

 				/* The timer is in a list, remove it. */

 				( void ) uxListRemove( &( pxTimer->xTimerListItem ) );

@@ -654,19 +768,20 @@ TickType_t xTimeNow;
 			switch( xMessage.xMessageID )

 			{

 				case tmrCOMMAND_START :

-			    case tmrCOMMAND_START_FROM_ISR :

-			    case tmrCOMMAND_RESET :

-			    case tmrCOMMAND_RESET_FROM_ISR :

+				case tmrCOMMAND_START_FROM_ISR :

+				case tmrCOMMAND_RESET :

+				case tmrCOMMAND_RESET_FROM_ISR :

 				case tmrCOMMAND_START_DONT_TRACE :

 					/* Start or restart a timer. */

-					if( prvInsertTimerInActiveList( pxTimer,  xMessage.u.xTimerParameters.xMessageValue + pxTimer->xTimerPeriodInTicks, xTimeNow, xMessage.u.xTimerParameters.xMessageValue ) == pdTRUE )

+					pxTimer->ucStatus |= tmrSTATUS_IS_ACTIVE;

+					if( prvInsertTimerInActiveList( pxTimer,  xMessage.u.xTimerParameters.xMessageValue + pxTimer->xTimerPeriodInTicks, xTimeNow, xMessage.u.xTimerParameters.xMessageValue ) != pdFALSE )

 					{

 						/* The timer expired before it was added to the active

 						timer list.  Process it now. */

 						pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );

 						traceTIMER_EXPIRED( pxTimer );

 

-						if( pxTimer->uxAutoReload == ( UBaseType_t ) pdTRUE )

+						if( ( pxTimer->ucStatus & tmrSTATUS_IS_AUTORELOAD ) != 0 )

 						{

 							xResult = xTimerGenericCommand( pxTimer, tmrCOMMAND_START_DONT_TRACE, xMessage.u.xTimerParameters.xMessageValue + pxTimer->xTimerPeriodInTicks, NULL, tmrNO_DELAY );

 							configASSERT( xResult );

@@ -685,28 +800,49 @@ TickType_t xTimeNow;
 

 				case tmrCOMMAND_STOP :

 				case tmrCOMMAND_STOP_FROM_ISR :

-					/* The timer has already been removed from the active list.

-					There is nothing to do here. */

+					/* The timer has already been removed from the active list. */

+					pxTimer->ucStatus &= ~tmrSTATUS_IS_ACTIVE;

 					break;

 

 				case tmrCOMMAND_CHANGE_PERIOD :

 				case tmrCOMMAND_CHANGE_PERIOD_FROM_ISR :

+					pxTimer->ucStatus |= tmrSTATUS_IS_ACTIVE;

 					pxTimer->xTimerPeriodInTicks = xMessage.u.xTimerParameters.xMessageValue;

 					configASSERT( ( pxTimer->xTimerPeriodInTicks > 0 ) );

 

-					/* The new period does not really have a reference, and can be

-					longer or shorter than the old one.  The command time is

-					therefore set to the current time, and as the period cannot be

-					zero the next expiry time can only be in the future, meaning

-					(unlike for the xTimerStart() case above) there is no fail case

-					that needs to be handled here. */

+					/* The new period does not really have a reference, and can

+					be longer or shorter than the old one.  The command time is

+					therefore set to the current time, and as the period cannot

+					be zero the next expiry time can only be in the future,

+					meaning (unlike for the xTimerStart() case above) there is

+					no fail case that needs to be handled here. */

 					( void ) prvInsertTimerInActiveList( pxTimer, ( xTimeNow + pxTimer->xTimerPeriodInTicks ), xTimeNow, xTimeNow );

 					break;

 

 				case tmrCOMMAND_DELETE :

-					/* The timer has already been removed from the active list,

-					just free up the memory. */

-					vPortFree( pxTimer );

+					#if ( configSUPPORT_DYNAMIC_ALLOCATION == 1 )

+					{

+						/* The timer has already been removed from the active list,

+						just free up the memory if the memory was dynamically

+						allocated. */

+						if( ( pxTimer->ucStatus & tmrSTATUS_IS_STATICALLY_ALLOCATED ) == ( uint8_t ) 0 )

+						{

+							vPortFree( pxTimer );

+						}

+						else

+						{

+							pxTimer->ucStatus &= ~tmrSTATUS_IS_ACTIVE;

+						}

+					}

+					#else

+					{

+						/* If dynamic allocation is not enabled, the memory

+						could not have been dynamically allocated. So there is

+						no need to free the memory - just mark the timer as

+						"not active". */

+						pxTimer->ucStatus &= ~tmrSTATUS_IS_ACTIVE;

+					}

+					#endif /* configSUPPORT_DYNAMIC_ALLOCATION */

 					break;

 

 				default	:

@@ -734,7 +870,7 @@ BaseType_t xResult;
 		xNextExpireTime = listGET_ITEM_VALUE_OF_HEAD_ENTRY( pxCurrentTimerList );

 

 		/* Remove the timer from the list. */

-		pxTimer = ( Timer_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxCurrentTimerList );

+		pxTimer = ( Timer_t * ) listGET_OWNER_OF_HEAD_ENTRY( pxCurrentTimerList ); /*lint !e9087 !e9079 void * is used as this macro is used with tasks and co-routines too.  Alignment is known to be fine as the type of the pointer stored and retrieved is the same. */

 		( void ) uxListRemove( &( pxTimer->xTimerListItem ) );

 		traceTIMER_EXPIRED( pxTimer );

 

@@ -743,7 +879,7 @@ BaseType_t xResult;
 		have not yet been switched. */

 		pxTimer->pxCallbackFunction( ( TimerHandle_t ) pxTimer );

 

-		if( pxTimer->uxAutoReload == ( UBaseType_t ) pdTRUE )

+		if( ( pxTimer->ucStatus & tmrSTATUS_IS_AUTORELOAD ) != 0 )

 		{

 			/* Calculate the reload value, and if the reload value results in

 			the timer going into the same timer list then it has already expired

@@ -790,8 +926,21 @@ static void prvCheckForValidListAndQueue( void )
 			vListInitialise( &xActiveTimerList2 );

 			pxCurrentTimerList = &xActiveTimerList1;

 			pxOverflowTimerList = &xActiveTimerList2;

-			xTimerQueue = xQueueCreate( ( UBaseType_t ) configTIMER_QUEUE_LENGTH, sizeof( DaemonTaskMessage_t ) );

-			configASSERT( xTimerQueue );

+

+			#if( configSUPPORT_STATIC_ALLOCATION == 1 )

+			{

+				/* The timer queue is allocated statically in case

+				configSUPPORT_DYNAMIC_ALLOCATION is 0. */

+				static StaticQueue_t xStaticTimerQueue; /*lint !e956 Ok to declare in this manner to prevent additional conditional compilation guards in other locations. */

+				static uint8_t ucStaticTimerQueueStorage[ ( size_t ) configTIMER_QUEUE_LENGTH * sizeof( DaemonTaskMessage_t ) ]; /*lint !e956 Ok to declare in this manner to prevent additional conditional compilation guards in other locations. */

+

+				xTimerQueue = xQueueCreateStatic( ( UBaseType_t ) configTIMER_QUEUE_LENGTH, ( UBaseType_t ) sizeof( DaemonTaskMessage_t ), &( ucStaticTimerQueueStorage[ 0 ] ), &xStaticTimerQueue );

+			}

+			#else

+			{

+				xTimerQueue = xQueueCreate( ( UBaseType_t ) configTIMER_QUEUE_LENGTH, sizeof( DaemonTaskMessage_t ) );

+			}

+			#endif

 

 			#if ( configQUEUE_REGISTRY_SIZE > 0 )

 			{

@@ -817,28 +966,32 @@ static void prvCheckForValidListAndQueue( void )
 

 BaseType_t xTimerIsTimerActive( TimerHandle_t xTimer )

 {

-BaseType_t xTimerIsInActiveList;

-Timer_t *pxTimer = ( Timer_t * ) xTimer;

+BaseType_t xReturn;

+Timer_t *pxTimer = xTimer;

 

 	configASSERT( xTimer );

 

 	/* Is the timer in the list of active timers? */

 	taskENTER_CRITICAL();

 	{

-		/* Checking to see if it is in the NULL list in effect checks to see if

-		it is referenced from either the current or the overflow timer lists in

-		one go, but the logic has to be reversed, hence the '!'. */

-		xTimerIsInActiveList = ( BaseType_t ) !( listIS_CONTAINED_WITHIN( NULL, &( pxTimer->xTimerListItem ) ) );

+		if( ( pxTimer->ucStatus & tmrSTATUS_IS_ACTIVE ) == 0 )

+		{

+			xReturn = pdFALSE;

+		}

+		else

+		{

+			xReturn = pdTRUE;

+		}

 	}

 	taskEXIT_CRITICAL();

 

-	return xTimerIsInActiveList;

+	return xReturn;

 } /*lint !e818 Can't be pointer to const due to the typedef. */

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

 

 void *pvTimerGetTimerID( const TimerHandle_t xTimer )

 {

-Timer_t * const pxTimer = ( Timer_t * ) xTimer;

+Timer_t * const pxTimer = xTimer;

 void *pvReturn;

 

 	configASSERT( xTimer );

@@ -855,7 +1008,7 @@ void *pvReturn;
 

 void vTimerSetTimerID( TimerHandle_t xTimer, void *pvNewID )

 {

-Timer_t * const pxTimer = ( Timer_t * ) xTimer;

+Timer_t * const pxTimer = xTimer;

 

 	configASSERT( xTimer );

 

@@ -920,6 +1073,26 @@ Timer_t * const pxTimer = ( Timer_t * ) xTimer;
 #endif /* INCLUDE_xTimerPendFunctionCall */

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

 

+#if ( configUSE_TRACE_FACILITY == 1 )

+

+	UBaseType_t uxTimerGetTimerNumber( TimerHandle_t xTimer )

+	{

+		return ( ( Timer_t * ) xTimer )->uxTimerNumber;

+	}

+

+#endif /* configUSE_TRACE_FACILITY */

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

+

+#if ( configUSE_TRACE_FACILITY == 1 )

+

+	void vTimerSetTimerNumber( TimerHandle_t xTimer, UBaseType_t uxTimerNumber )

+	{

+		( ( Timer_t * ) xTimer )->uxTimerNumber = uxTimerNumber;

+	}

+

+#endif /* configUSE_TRACE_FACILITY */

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

+

 /* This entire source file will be skipped if the application is not configured

 to include software timer functionality.  If you want to include software timer

 functionality then ensure configUSE_TIMERS is set to 1 in FreeRTOSConfig.h. */