Simuator - Work in progress

7 files changed, 2524 insertions, 0 deletions

diff --git a/src/FreeRTOS-Sim-master/Source/portable/GCC/POSIX/port.c b/src/FreeRTOS-Sim-master/Source/portable/GCC/POSIX/port.c
new file mode 100644
index 0000000..53e030f
--- /dev/null
+++ b/src/FreeRTOS-Sim-master/Source/portable/GCC/POSIX/port.c
@@ -0,0 +1,787 @@
+/*
+	Copyright (C) 2009 William Davy - william.davy@wittenstein.co.uk
+	Contributed to FreeRTOS.org V5.3.0.
+
+	This file is part of the FreeRTOS.org distribution.
+
+	FreeRTOS.org is free software; you can redistribute it and/or modify it
+	under the terms of the GNU General Public License (version 2) as published
+	by the Free Software Foundation and modified by the FreeRTOS exception.
+
+	FreeRTOS.org is distributed in the hope that it will be useful,	but WITHOUT
+	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+	FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+	more details.
+
+	You should have received a copy of the GNU General Public License along
+	with FreeRTOS.org; if not, write to the Free Software Foundation, Inc., 59
+	Temple Place, Suite 330, Boston, MA  02111-1307  USA.
+
+	A special exception to the GPL is included to allow you to distribute a
+	combined work that includes FreeRTOS.org without being obliged to provide
+	the source code for any proprietary components.  See the licensing section
+	of http://www.FreeRTOS.org for full details.
+
+
+	***************************************************************************
+	*                                                                         *
+	* Get the FreeRTOS eBook!  See http://www.FreeRTOS.org/Documentation      *
+	*                                                                         *
+	* This is a concise, step by step, 'hands on' guide that describes both   *
+	* general multitasking concepts and FreeRTOS specifics. It presents and   *
+	* explains numerous examples that are written using the FreeRTOS API.     *
+	* Full source code for all the examples is provided in an accompanying    *
+	* .zip file.                                                              *
+	*                                                                         *
+	***************************************************************************
+
+	1 tab == 4 spaces!
+
+	Please ensure to read the configuration and relevant port sections of the
+	online documentation.
+
+	http://www.FreeRTOS.org - Documentation, latest information, license and
+	contact details.
+
+	http://www.SafeRTOS.com - A version that is certified for use in safety
+	critical systems.
+
+	http://www.OpenRTOS.com - Commercial support, development, porting,
+	licensing and training services.
+*/
+
+/*-----------------------------------------------------------
+ * Implementation of functions defined in portable.h for the Posix port.
+ *----------------------------------------------------------*/
+
+#include <pthread.h>
+#include <sched.h>
+#include <signal.h>
+#include <errno.h>
+#include <sys/time.h>
+#include <time.h>
+#include <sys/times.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <unistd.h>
+#include <limits.h>
+
+/* Scheduler includes. */
+#include "FreeRTOS.h"
+#include "task.h"
+/*-----------------------------------------------------------*/
+#ifndef MAX_NUMBER_OF_TASKS
+#define MAX_NUMBER_OF_TASKS 		( _POSIX_THREAD_THREADS_MAX )
+#endif
+/*-----------------------------------------------------------*/
+
+/* Parameters to pass to the newly created pthread. */
+typedef struct XPARAMS
+{
+	pdTASK_CODE pxCode;
+	void *pvParams;
+} xParams;
+
+/* Each task maintains its own interrupt status in the critical nesting variable. */
+typedef struct THREAD_SUSPENSIONS
+{
+	pthread_t hThread;
+	xTaskHandle hTask;
+	unsigned portBASE_TYPE uxCriticalNesting;
+} xThreadState;
+/*-----------------------------------------------------------*/
+
+static xThreadState *pxThreads;
+static pthread_once_t hSigSetupThread = PTHREAD_ONCE_INIT;
+static pthread_attr_t xThreadAttributes;
+static pthread_mutex_t xSuspendResumeThreadMutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_mutex_t xSingleThreadMutex = PTHREAD_MUTEX_INITIALIZER;
+static pthread_t hMainThread = ( pthread_t )NULL;
+/*-----------------------------------------------------------*/
+
+static volatile portBASE_TYPE xSentinel = 0;
+static volatile portBASE_TYPE xSchedulerEnd = pdFALSE;
+static volatile portBASE_TYPE xInterruptsEnabled = pdTRUE;
+static volatile portBASE_TYPE xServicingTick = pdFALSE;
+static volatile portBASE_TYPE xPendYield = pdFALSE;
+static volatile portLONG lIndexOfLastAddedTask = 0;
+static volatile unsigned portBASE_TYPE uxCriticalNesting;
+/*-----------------------------------------------------------*/
+
+/*
+ * Setup the timer to generate the tick interrupts.
+ */
+static void prvSetupTimerInterrupt( void );
+static void *prvWaitForStart( void * pvParams );
+static void prvSuspendSignalHandler(int sig);
+static void prvResumeSignalHandler(int sig);
+static void prvSetupSignalsAndSchedulerPolicy( void );
+static void prvSuspendThread( pthread_t xThreadId );
+static void prvResumeThread( pthread_t xThreadId );
+static pthread_t prvGetThreadHandle( xTaskHandle hTask );
+static portLONG prvGetFreeThreadState( void );
+static void prvSetTaskCriticalNesting( pthread_t xThreadId, unsigned portBASE_TYPE uxNesting );
+static unsigned portBASE_TYPE prvGetTaskCriticalNesting( pthread_t xThreadId );
+static void prvDeleteThread( void *xThreadId );
+/*-----------------------------------------------------------*/
+
+/*
+ * Exception handlers.
+ */
+void vPortYield( void );
+void vPortSystemTickHandler( int sig );
+
+/*
+ * Start first task is a separate function so it can be tested in isolation.
+ */
+void vPortStartFirstTask( void );
+/*-----------------------------------------------------------*/
+
+/*
+ * See header file for description.
+ */
+portSTACK_TYPE *pxPortInitialiseStack( portSTACK_TYPE *pxTopOfStack, pdTASK_CODE pxCode, void *pvParameters )
+{
+/* Should actually keep this struct on the stack. */
+xParams *pxThisThreadParams = pvPortMalloc( sizeof( xParams ) );
+
+	(void)pthread_once( &hSigSetupThread, prvSetupSignalsAndSchedulerPolicy );
+
+	if ( (pthread_t)NULL == hMainThread )
+	{
+		hMainThread = pthread_self();
+	}
+
+	/* No need to join the threads. */
+	pthread_attr_init( &xThreadAttributes );
+	pthread_attr_setdetachstate( &xThreadAttributes, PTHREAD_CREATE_DETACHED );
+
+	/* Add the task parameters. */
+	pxThisThreadParams->pxCode = pxCode;
+	pxThisThreadParams->pvParams = pvParameters;
+
+	vPortEnterCritical();
+
+	lIndexOfLastAddedTask = prvGetFreeThreadState();
+
+	/* Create the new pThread. */
+	if ( 0 == pthread_mutex_lock( &xSingleThreadMutex ) )
+	{
+		xSentinel = 0;
+		if ( 0 != pthread_create( &( pxThreads[ lIndexOfLastAddedTask ].hThread ), &xThreadAttributes, prvWaitForStart, (void *)pxThisThreadParams ) )
+		{
+			/* Thread create failed, signal the failure */
+			pxTopOfStack = 0;
+		}
+
+		/* Wait until the task suspends. */
+		(void)pthread_mutex_unlock( &xSingleThreadMutex );
+		while ( xSentinel == 0 );
+		vPortExitCritical();
+	}
+
+	return pxTopOfStack;
+}
+/*-----------------------------------------------------------*/
+
+void vPortStartFirstTask( void )
+{
+	/* Initialise the critical nesting count ready for the first task. */
+	uxCriticalNesting = 0;
+
+	/* Start the first task. */
+	vPortEnableInterrupts();
+
+	/* Start the first task. */
+	prvResumeThread( prvGetThreadHandle( xTaskGetCurrentTaskHandle() ) );
+}
+/*-----------------------------------------------------------*/
+
+/*
+ * See header file for description.
+ */
+portBASE_TYPE xPortStartScheduler( void )
+{
+portBASE_TYPE xResult;
+int iSignal;
+sigset_t xSignals;
+sigset_t xSignalToBlock;
+sigset_t xSignalsBlocked;
+portLONG lIndex;
+
+	/* Establish the signals to block before they are needed. */
+	sigfillset( &xSignalToBlock );
+
+	/* Block until the end */
+	(void)pthread_sigmask( SIG_SETMASK, &xSignalToBlock, &xSignalsBlocked );
+
+	for ( lIndex = 0; lIndex < MAX_NUMBER_OF_TASKS; lIndex++ )
+	{
+		pxThreads[ lIndex ].uxCriticalNesting = 0;
+	}
+
+	/* Start the timer that generates the tick ISR.  Interrupts are disabled
+	here already. */
+	prvSetupTimerInterrupt();
+
+	/* Start the first task. Will not return unless all threads are killed. */
+	vPortStartFirstTask();
+
+	/* This is the end signal we are looking for. */
+	sigemptyset( &xSignals );
+	sigaddset( &xSignals, SIG_RESUME );
+
+	while ( pdTRUE != xSchedulerEnd )
+	{
+		if ( 0 != sigwait( &xSignals, &iSignal ) )
+		{
+			printf( "Main thread spurious signal: %d\n", iSignal );
+		}
+	}
+
+	printf( "Cleaning Up, Exiting.\n" );
+	/* Cleanup the mutexes */
+	xResult = pthread_mutex_destroy( &xSuspendResumeThreadMutex );
+	xResult = pthread_mutex_destroy( &xSingleThreadMutex );
+	vPortFree( (void *)pxThreads );
+
+	/* Should not get here! */
+	return xResult;
+}
+/*-----------------------------------------------------------*/
+
+void vPortEndScheduler( void )
+{
+portBASE_TYPE xNumberOfThreads;
+portBASE_TYPE xResult;
+	for ( xNumberOfThreads = 0; xNumberOfThreads < MAX_NUMBER_OF_TASKS; xNumberOfThreads++ )
+	{
+		if ( ( pthread_t )NULL != pxThreads[ xNumberOfThreads ].hThread )
+		{
+			/* Kill all of the threads, they are in the detached state. */
+			xResult = pthread_cancel( pxThreads[ xNumberOfThreads ].hThread );
+            if (xResult)
+                printf("pthread_cancel error!\n");
+		}
+	}
+
+	/* Signal the scheduler to exit its loop. */
+	xSchedulerEnd = pdTRUE;
+	(void)pthread_kill( hMainThread, SIG_RESUME );
+}
+/*-----------------------------------------------------------*/
+
+void vPortYieldFromISR( void )
+{
+	/* Calling Yield from a Interrupt/Signal handler often doesn't work because the
+	 * xSingleThreadMutex is already owned by an original call to Yield. Therefore,
+	 * simply indicate that a yield is required soon.
+	 */
+	xPendYield = pdTRUE;
+}
+/*-----------------------------------------------------------*/
+
+void vPortEnterCritical( void )
+{
+	vPortDisableInterrupts();
+	uxCriticalNesting++;
+}
+/*-----------------------------------------------------------*/
+
+void vPortExitCritical( void )
+{
+	/* Check for unmatched exits. */
+	if ( uxCriticalNesting > 0 )
+	{
+		uxCriticalNesting--;
+	}
+
+	/* If we have reached 0 then re-enable the interrupts. */
+	if( uxCriticalNesting == 0 )
+	{
+		/* Have we missed ticks? This is the equivalent of pending an interrupt. */
+		if ( pdTRUE == xPendYield )
+		{
+			xPendYield = pdFALSE;
+			vPortYield();
+		}
+		vPortEnableInterrupts();
+	}
+}
+/*-----------------------------------------------------------*/
+
+void vPortYield( void )
+{
+pthread_t xTaskToSuspend;
+pthread_t xTaskToResume;
+
+	if ( 0 == pthread_mutex_lock( &xSingleThreadMutex ) )
+	{
+		xTaskToSuspend = prvGetThreadHandle( xTaskGetCurrentTaskHandle() );
+
+		vTaskSwitchContext();
+
+		xTaskToResume = prvGetThreadHandle( xTaskGetCurrentTaskHandle() );
+		if ( xTaskToSuspend != xTaskToResume )
+		{
+			/* Remember and switch the critical nesting. */
+			prvSetTaskCriticalNesting( xTaskToSuspend, uxCriticalNesting );
+			uxCriticalNesting = prvGetTaskCriticalNesting( xTaskToResume );
+			/* Switch tasks. */
+			prvResumeThread( xTaskToResume );
+			prvSuspendThread( xTaskToSuspend );
+		}
+		else
+		{
+			/* Yielding to self */
+			(void)pthread_mutex_unlock( &xSingleThreadMutex );
+		}
+	}
+}
+/*-----------------------------------------------------------*/
+
+void vPortDisableInterrupts( void )
+{
+	xInterruptsEnabled = pdFALSE;
+}
+/*-----------------------------------------------------------*/
+
+void vPortEnableInterrupts( void )
+{
+	xInterruptsEnabled = pdTRUE;
+}
+/*-----------------------------------------------------------*/
+
+portBASE_TYPE xPortSetInterruptMask( void )
+{
+portBASE_TYPE xReturn = xInterruptsEnabled;
+	xInterruptsEnabled = pdFALSE;
+	return xReturn;
+}
+/*-----------------------------------------------------------*/
+
+void vPortClearInterruptMask( portBASE_TYPE xMask )
+{
+	xInterruptsEnabled = xMask;
+}
+/*-----------------------------------------------------------*/
+
+/*
+ * Setup the systick timer to generate the tick interrupts at the required
+ * frequency.
+ */
+void prvSetupTimerInterrupt( void )
+{
+struct itimerval itimer, oitimer;
+portTickType xMicroSeconds = portTICK_PERIOD_MS * 1000;
+
+	/* Initialise the structure with the current timer information. */
+	if ( 0 == getitimer( TIMER_TYPE, &itimer ) )
+	{
+		/* Set the interval between timer events. */
+		itimer.it_interval.tv_sec = 0;
+		itimer.it_interval.tv_usec = xMicroSeconds;
+
+		/* Set the current count-down. */
+		itimer.it_value.tv_sec = 0;
+		itimer.it_value.tv_usec = xMicroSeconds;
+
+		/* Set-up the timer interrupt. */
+		if ( 0 != setitimer( TIMER_TYPE, &itimer, &oitimer ) )
+		{
+			printf( "Set Timer problem.\n" );
+		}
+	}
+	else
+	{
+		printf( "Get Timer problem.\n" );
+	}
+}
+/*-----------------------------------------------------------*/
+
+void vPortSystemTickHandler( int sig )
+{
+pthread_t xTaskToSuspend;
+pthread_t xTaskToResume;
+
+    (void)(sig);
+	if ( ( pdTRUE == xInterruptsEnabled ) && ( pdTRUE != xServicingTick ) )
+	{
+		if ( 0 == pthread_mutex_trylock( &xSingleThreadMutex ) )
+		{
+			xServicingTick = pdTRUE;
+
+			xTaskToSuspend = prvGetThreadHandle( xTaskGetCurrentTaskHandle() );
+			/* Tick Increment. */
+			xTaskIncrementTick();
+
+			/* Select Next Task. */
+#if ( configUSE_PREEMPTION == 1 )
+			vTaskSwitchContext();
+#endif
+			xTaskToResume = prvGetThreadHandle( xTaskGetCurrentTaskHandle() );
+
+			/* The only thread that can process this tick is the running thread. */
+			if ( xTaskToSuspend != xTaskToResume )
+			{
+				/* Remember and switch the critical nesting. */
+				prvSetTaskCriticalNesting( xTaskToSuspend, uxCriticalNesting );
+				uxCriticalNesting = prvGetTaskCriticalNesting( xTaskToResume );
+				/* Resume next task. */
+				prvResumeThread( xTaskToResume );
+				/* Suspend the current task. */
+				prvSuspendThread( xTaskToSuspend );
+			}
+			else
+			{
+				/* Release the lock as we are Resuming. */
+				(void)pthread_mutex_unlock( &xSingleThreadMutex );
+			}
+			xServicingTick = pdFALSE;
+		}
+		else
+		{
+			xPendYield = pdTRUE;
+		}
+	}
+	else
+	{
+		xPendYield = pdTRUE;
+	}
+}
+/*-----------------------------------------------------------*/
+
+void vPortForciblyEndThread( void *pxTaskToDelete )
+{
+xTaskHandle hTaskToDelete = ( xTaskHandle )pxTaskToDelete;
+pthread_t xTaskToDelete;
+pthread_t xTaskToResume;
+portBASE_TYPE xResult;
+
+	if ( 0 == pthread_mutex_lock( &xSingleThreadMutex ) )
+	{
+		xTaskToDelete = prvGetThreadHandle( hTaskToDelete );
+		xTaskToResume = prvGetThreadHandle( xTaskGetCurrentTaskHandle() );
+
+		if ( xTaskToResume == xTaskToDelete )
+		{
+			/* This is a suicidal thread, need to select a different task to run. */
+			vTaskSwitchContext();
+			xTaskToResume = prvGetThreadHandle( xTaskGetCurrentTaskHandle() );
+		}
+
+		if ( pthread_self() != xTaskToDelete )
+		{
+			/* Cancelling a thread that is not me. */
+			if ( xTaskToDelete != ( pthread_t )NULL )
+			{
+				/* Send a signal to wake the task so that it definitely cancels. */
+				pthread_testcancel();
+				xResult = pthread_cancel( xTaskToDelete );
+                if (xResult)
+                    printf("pthread_cancel error!\n");
+				/* Pthread Clean-up function will note the cancellation. */
+			}
+			(void)pthread_mutex_unlock( &xSingleThreadMutex );
+		}
+		else
+		{
+			/* Resume the other thread. */
+			prvResumeThread( xTaskToResume );
+			/* Pthread Clean-up function will note the cancellation. */
+			/* Release the execution. */
+			uxCriticalNesting = 0;
+			vPortEnableInterrupts();
+			(void)pthread_mutex_unlock( &xSingleThreadMutex );
+			/* Commit suicide */
+			pthread_exit( (void *)1 );
+		}
+	}
+}
+/*-----------------------------------------------------------*/
+
+void *prvWaitForStart( void * pvParams )
+{
+xParams * pxParams = ( xParams * )pvParams;
+pdTASK_CODE pvCode = pxParams->pxCode;
+void * pParams = pxParams->pvParams;
+	vPortFree( pvParams );
+
+	pthread_cleanup_push( prvDeleteThread, (void *)pthread_self() );
+
+	if ( 0 == pthread_mutex_lock( &xSingleThreadMutex ) )
+	{
+		prvSuspendThread( pthread_self() );
+	}
+
+	pvCode( pParams );
+
+	pthread_cleanup_pop( 1 );
+	return (void *)NULL;
+}
+/*-----------------------------------------------------------*/
+
+void prvSuspendSignalHandler(int sig)
+{
+sigset_t xSignals;
+
+	/* Only interested in the resume signal. */
+	sigemptyset( &xSignals );
+	sigaddset( &xSignals, SIG_RESUME );
+	xSentinel = 1;
+
+	/* Unlock the Single thread mutex to allow the resumed task to continue. */
+	if ( 0 != pthread_mutex_unlock( &xSingleThreadMutex ) )
+	{
+		printf( "Releasing someone else's lock.\n" );
+	}
+
+	/* Wait on the resume signal. */
+	if ( 0 != sigwait( &xSignals, &sig ) )
+	{
+		printf( "SSH: Sw %d\n", sig );
+	}
+
+	/* Will resume here when the SIG_RESUME signal is received. */
+	/* Need to set the interrupts based on the task's critical nesting. */
+	if ( uxCriticalNesting == 0 )
+	{
+		vPortEnableInterrupts();
+	}
+	else
+	{
+		vPortDisableInterrupts();
+	}
+}
+/*-----------------------------------------------------------*/
+
+void prvSuspendThread( pthread_t xThreadId )
+{
+portBASE_TYPE xResult = pthread_mutex_lock( &xSuspendResumeThreadMutex );
+	if ( 0 == xResult )
+	{
+		/* Set-up for the Suspend Signal handler? */
+		xSentinel = 0;
+		xResult = pthread_mutex_unlock( &xSuspendResumeThreadMutex );
+		xResult = pthread_kill( xThreadId, SIG_SUSPEND );
+        if (xResult)
+            printf("pthread_kill error!\n");
+		while ( ( xSentinel == 0 ) && ( pdTRUE != xServicingTick ) )
+		{
+			sched_yield();
+		}
+	}
+}
+/*-----------------------------------------------------------*/
+
+void prvResumeSignalHandler(int sig)
+{
+    (void)(sig);
+	/* Yield the Scheduler to ensure that the yielding thread completes. */
+	if ( 0 == pthread_mutex_lock( &xSingleThreadMutex ) )
+	{
+		(void)pthread_mutex_unlock( &xSingleThreadMutex );
+	}
+}
+/*-----------------------------------------------------------*/
+
+void prvResumeThread( pthread_t xThreadId )
+{
+portBASE_TYPE xResult;
+	if ( 0 == pthread_mutex_lock( &xSuspendResumeThreadMutex ) )
+	{
+		if ( pthread_self() != xThreadId )
+		{
+			xResult = pthread_kill( xThreadId, SIG_RESUME );
+            if (xResult)
+                printf("pthread_kill error!\n");
+		}
+		xResult = pthread_mutex_unlock( &xSuspendResumeThreadMutex );
+        if (xResult)
+            printf("pthread_mutex_unlock error!\n");
+	}
+}
+/*-----------------------------------------------------------*/
+
+void prvSetupSignalsAndSchedulerPolicy( void )
+{
+/* The following code would allow for configuring the scheduling of this task as a Real-time task.
+ * The process would then need to be run with higher privileges for it to take affect.
+int iPolicy;
+int iResult;
+int iSchedulerPriority;
+	iResult = pthread_getschedparam( pthread_self(), &iPolicy, &iSchedulerPriority );
+	iResult = pthread_attr_setschedpolicy( &xThreadAttributes, SCHED_FIFO );
+	iPolicy = SCHED_FIFO;
+	iResult = pthread_setschedparam( pthread_self(), iPolicy, &iSchedulerPriority );		*/
+
+struct sigaction sigsuspendself, sigresume, sigtick;
+portLONG lIndex;
+
+	pxThreads = ( xThreadState *)pvPortMalloc( sizeof( xThreadState ) * MAX_NUMBER_OF_TASKS );
+	for ( lIndex = 0; lIndex < MAX_NUMBER_OF_TASKS; lIndex++ )
+	{
+		pxThreads[ lIndex ].hThread = ( pthread_t )NULL;
+		pxThreads[ lIndex ].hTask = ( xTaskHandle )NULL;
+		pxThreads[ lIndex ].uxCriticalNesting = 0;
+	}
+
+	sigsuspendself.sa_flags = 0;
+	sigsuspendself.sa_handler = prvSuspendSignalHandler;
+	sigfillset( &sigsuspendself.sa_mask );
+
+	sigresume.sa_flags = 0;
+	sigresume.sa_handler = prvResumeSignalHandler;
+	sigfillset( &sigresume.sa_mask );
+
+	sigtick.sa_flags = 0;
+	sigtick.sa_handler = vPortSystemTickHandler;
+	sigfillset( &sigtick.sa_mask );
+
+	if ( 0 != sigaction( SIG_SUSPEND, &sigsuspendself, NULL ) )
+	{
+		printf( "Problem installing SIG_SUSPEND_SELF\n" );
+	}
+	if ( 0 != sigaction( SIG_RESUME, &sigresume, NULL ) )
+	{
+		printf( "Problem installing SIG_RESUME\n" );
+	}
+	if ( 0 != sigaction( SIG_TICK, &sigtick, NULL ) )
+	{
+		printf( "Problem installing SIG_TICK\n" );
+	}
+	printf( "Running as PID: %d\n", getpid() );
+}
+/*-----------------------------------------------------------*/
+
+pthread_t prvGetThreadHandle( xTaskHandle hTask )
+{
+pthread_t hThread = ( pthread_t )NULL;
+portLONG lIndex;
+	for ( lIndex = 0; lIndex < MAX_NUMBER_OF_TASKS; lIndex++ )
+	{
+		if ( pxThreads[ lIndex ].hTask == hTask )
+		{
+			hThread = pxThreads[ lIndex ].hThread;
+			break;
+		}
+	}
+	return hThread;
+}
+/*-----------------------------------------------------------*/
+
+portLONG prvGetFreeThreadState( void )
+{
+portLONG lIndex;
+	for ( lIndex = 0; lIndex < MAX_NUMBER_OF_TASKS; lIndex++ )
+	{
+		if ( pxThreads[ lIndex ].hThread == ( pthread_t )NULL )
+		{
+			break;
+		}
+	}
+
+	if ( MAX_NUMBER_OF_TASKS == lIndex )
+	{
+		printf( "No more free threads, please increase the maximum.\n" );
+		lIndex = 0;
+		vPortEndScheduler();
+	}
+
+	return lIndex;
+}
+/*-----------------------------------------------------------*/
+
+void prvSetTaskCriticalNesting( pthread_t xThreadId, unsigned portBASE_TYPE uxNesting )
+{
+portLONG lIndex;
+	for ( lIndex = 0; lIndex < MAX_NUMBER_OF_TASKS; lIndex++ )
+	{
+		if ( pxThreads[ lIndex ].hThread == xThreadId )
+		{
+			pxThreads[ lIndex ].uxCriticalNesting = uxNesting;
+			break;
+		}
+	}
+}
+/*-----------------------------------------------------------*/
+
+unsigned portBASE_TYPE prvGetTaskCriticalNesting( pthread_t xThreadId )
+{
+unsigned portBASE_TYPE uxNesting = 0;
+portLONG lIndex;
+	for ( lIndex = 0; lIndex < MAX_NUMBER_OF_TASKS; lIndex++ )
+	{
+		if ( pxThreads[ lIndex ].hThread == xThreadId )
+		{
+			uxNesting = pxThreads[ lIndex ].uxCriticalNesting;
+			break;
+		}
+	}
+	return uxNesting;
+}
+/*-----------------------------------------------------------*/
+
+void prvDeleteThread( void *xThreadId )
+{
+portLONG lIndex;
+	for ( lIndex = 0; lIndex < MAX_NUMBER_OF_TASKS; lIndex++ )
+	{
+		if ( pxThreads[ lIndex ].hThread == ( pthread_t )xThreadId )
+		{
+			pxThreads[ lIndex ].hThread = (pthread_t)NULL;
+			pxThreads[ lIndex ].hTask = (xTaskHandle)NULL;
+			if ( pxThreads[ lIndex ].uxCriticalNesting > 0 )
+			{
+				uxCriticalNesting = 0;
+				vPortEnableInterrupts();
+			}
+			pxThreads[ lIndex ].uxCriticalNesting = 0;
+			break;
+		}
+	}
+}
+/*-----------------------------------------------------------*/
+
+void vPortAddTaskHandle( void *pxTaskHandle )
+{
+portLONG lIndex;
+
+	pxThreads[ lIndexOfLastAddedTask ].hTask = ( xTaskHandle )pxTaskHandle;
+	for ( lIndex = 0; lIndex < MAX_NUMBER_OF_TASKS; lIndex++ )
+	{
+		if ( pxThreads[ lIndex ].hThread == pxThreads[ lIndexOfLastAddedTask ].hThread )
+		{
+			if ( pxThreads[ lIndex ].hTask != pxThreads[ lIndexOfLastAddedTask ].hTask )
+			{
+				pxThreads[ lIndex ].hThread = ( pthread_t )NULL;
+				pxThreads[ lIndex ].hTask = NULL;
+				pxThreads[ lIndex ].uxCriticalNesting = 0;
+			}
+		}
+	}
+}
+/*-----------------------------------------------------------*/
+
+void vPortFindTicksPerSecond( void )
+{
+	/* Needs to be reasonably high for accuracy. */
+	unsigned long ulTicksPerSecond = sysconf(_SC_CLK_TCK);
+	printf( "Timer Resolution for Run TimeStats is %ld ticks per second.\n", ulTicksPerSecond );
+}
+/*-----------------------------------------------------------*/
+
+unsigned long ulPortGetTimerValue( void )
+{
+struct tms xTimes;
+	unsigned long ulTotalTime = times( &xTimes );
+	/* Return the application code times.
+	 * The timer only increases when the application code is actually running
+	 * which means that the total execution times should add up to 100%.
+	 */
+	return ( unsigned long ) xTimes.tms_utime;
+
+	/* Should check ulTotalTime for being clock_t max minus 1. */
+	(void)ulTotalTime;
+}
+/*-----------------------------------------------------------*/
diff --git a/src/FreeRTOS-Sim-master/Source/portable/GCC/POSIX/portmacro.h b/src/FreeRTOS-Sim-master/Source/portable/GCC/POSIX/portmacro.h
new file mode 100644
index 0000000..a4219cd
--- /dev/null
+++ b/src/FreeRTOS-Sim-master/Source/portable/GCC/POSIX/portmacro.h
@@ -0,0 +1,128 @@
+/*

+    POSIX Simulator

+		Tested with FreeRTOS V8.2.2

+    1 tab == 4 spaces!

+*/

+

+#ifndef PORTMACRO_H

+#define PORTMACRO_H

+

+#ifdef __cplusplus

+	extern "C" {

+#endif

+

+/******************************************************************************

+	Defines

+******************************************************************************/

+/* Type definitions. */

+#define portCHAR		char

+#define portFLOAT		float

+#define portDOUBLE		double

+#define portLONG		long

+#define portSHORT		short

+#define portSTACK_TYPE	size_t

+#define portBASE_TYPE	long

+#define portPOINTER_SIZE_TYPE size_t

+

+typedef portSTACK_TYPE StackType_t;

+typedef long BaseType_t;

+typedef unsigned long UBaseType_t;

+

+#if( configUSE_16_BIT_TICKS == 1 )

+    typedef uint16_t TickType_t;

+    #define portMAX_DELAY ( TickType_t ) 0xffff

+#else

+    typedef uint32_t TickType_t;

+    #define portMAX_DELAY ( TickType_t ) 0xffffffffUL

+

+	/* 32/64-bit tick type on a 32/64-bit architecture, so reads of the tick

+	count do not need to be guarded with a critical section. */

+	#define portTICK_TYPE_IS_ATOMIC 1

+#endif

+

+/* Hardware specifics. */

+#define portSTACK_GROWTH			( -1 )

+#define portTICK_PERIOD_MS			( ( TickType_t ) 1000 / configTICK_RATE_HZ )

+#define portINLINE __inline__

+

+#if defined( __x86_64__)

+	#define portBYTE_ALIGNMENT		8

+#else

+	#define portBYTE_ALIGNMENT		4

+#endif

+

+//TODO: check portREMOVE_STATIC_QUALIFIER

+#define portREMOVE_STATIC_QUALIFIER

+

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

+

+/* Scheduler utilities. */

+extern void vPortYieldFromISR( void );

+extern void vPortYield( void );

+#define portYIELD()					vPortYield()

+#define portEND_SWITCHING_ISR( xSwitchRequired ) if( xSwitchRequired ) vPortYieldFromISR()

+#define portYIELD_FROM_ISR( x ) portEND_SWITCHING_ISR( x )

+

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

+

+/* Critical section management. */

+extern BaseType_t xPortSetInterruptMask( void );

+extern void vPortClearInterruptMask( portBASE_TYPE xMask );

+

+#define portSET_INTERRUPT_MASK_FROM_ISR()		xPortSetInterruptMask()

+#define portCLEAR_INTERRUPT_MASK_FROM_ISR(x)	vPortClearInterruptMask(x)

+

+extern void vPortDisableInterrupts( void );

+extern void vPortEnableInterrupts( void );

+#define portSET_INTERRUPT_MASK()	( vPortDisableInterrupts() )

+#define portCLEAR_INTERRUPT_MASK()	( vPortEnableInterrupts() )

+

+#define portDISABLE_INTERRUPTS()	portSET_INTERRUPT_MASK()

+#define portENABLE_INTERRUPTS()		portCLEAR_INTERRUPT_MASK()

+

+extern void vPortEnterCritical( void );

+extern void vPortExitCritical( void );

+#define portENTER_CRITICAL()		vPortEnterCritical()

+#define portEXIT_CRITICAL()			vPortExitCritical()

+

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

+

+/* Task function macros as described on the FreeRTOS.org WEB site. */

+#define portTASK_FUNCTION_PROTO( vFunction, pvParameters ) void vFunction( void * pvParameters )

+#define portTASK_FUNCTION( vFunction, pvParameters ) void vFunction( void * pvParameters )

+

+#define portNOP()

+

+#define portOUTPUT_BYTE( a, b )

+

+extern void vPortForciblyEndThread( void *pxTaskToDelete );

+#define traceTASK_DELETE( pxTaskToDelete )		vPortForciblyEndThread( pxTaskToDelete )

+

+extern void vPortAddTaskHandle( void *pxTaskHandle );

+#define traceTASK_CREATE( pxNewTCB )			vPortAddTaskHandle( pxNewTCB )

+

+/* Posix Signal definitions that can be changed or read as appropriate. */

+#define SIG_SUSPEND					SIGUSR1

+#define SIG_RESUME					SIGUSR2

+

+/* Enable the following hash defines to make use of the real-time tick where time progresses at real-time. */

+#define SIG_TICK					SIGALRM

+#define TIMER_TYPE					ITIMER_REAL

+/* Enable the following hash defines to make use of the process tick where time progresses only when the process is executing.

+#define SIG_TICK					SIGVTALRM

+#define TIMER_TYPE					ITIMER_VIRTUAL		*/

+/* Enable the following hash defines to make use of the profile tick where time progresses when the process or system calls are executing.

+#define SIG_TICK					SIGPROF

+#define TIMER_TYPE					ITIMER_PROF */

+

+/* Make use of times(man 2) to gather run-time statistics on the tasks. */

+extern void vPortFindTicksPerSecond( void );

+#define portCONFIGURE_TIMER_FOR_RUN_TIME_STATS()	vPortFindTicksPerSecond()		/* Nothing to do because the timer is already present. */

+extern unsigned long ulPortGetTimerValue( void );

+#define portGET_RUN_TIME_COUNTER_VALUE()			ulPortGetTimerValue()			/* Query the System time stats for this process. */

+

+#ifdef __cplusplus

+} /* extern C */

+#endif

+

+#endif /* PORTMACRO_H */

diff --git a/src/FreeRTOS-Sim-master/Source/portable/MemMang/heap_1.c b/src/FreeRTOS-Sim-master/Source/portable/MemMang/heap_1.c
new file mode 100644
index 0000000..560b256
--- /dev/null
+++ b/src/FreeRTOS-Sim-master/Source/portable/MemMang/heap_1.c
@@ -0,0 +1,174 @@
+/*

+    FreeRTOS V8.2.2 - 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!

+*/

+

+

+/*

+ * The simplest possible implementation of pvPortMalloc().  Note that this

+ * implementation does NOT allow allocated memory to be freed again.

+ *

+ * See heap_2.c, heap_3.c and heap_4.c for alternative implementations, and the

+ * memory management pages of http://www.FreeRTOS.org for more information.

+ */

+#include <stdlib.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

+

+#include "FreeRTOS.h"

+#include "task.h"

+

+#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE

+

+/* 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 ];

+static size_t xNextFreeByte = ( size_t ) 0;

+

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

+

+void *pvPortMalloc( size_t xWantedSize )

+{

+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( xWantedSize & portBYTE_ALIGNMENT_MASK )

+		{

+			/* Byte alignment required. */

+			xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );

+		}

+	#endif

+

+	vTaskSuspendAll();

+	{

+		if( pucAlignedHeap == NULL )

+		{

+			/* Ensure the heap starts on a correctly aligned boundary. */

+			pucAlignedHeap = ( uint8_t * ) ( ( ( portPOINTER_SIZE_TYPE ) &ucHeap[ portBYTE_ALIGNMENT ] ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) );

+		}

+

+		/* Check there is enough room left for the allocation. */

+		if( ( ( xNextFreeByte + xWantedSize ) < configADJUSTED_HEAP_SIZE ) &&

+			( ( xNextFreeByte + xWantedSize ) > xNextFreeByte )	)/* Check for overflow. */

+		{

+			/* Return the next free byte then increment the index past this

+			block. */

+			pvReturn = pucAlignedHeap + xNextFreeByte;

+			xNextFreeByte += xWantedSize;

+		}

+

+		traceMALLOC( pvReturn, xWantedSize );

+	}

+	( void ) xTaskResumeAll();

+

+	#if( configUSE_MALLOC_FAILED_HOOK == 1 )

+	{

+		if( pvReturn == NULL )

+		{

+			extern void vApplicationMallocFailedHook( void );

+			vApplicationMallocFailedHook();

+		}

+	}

+	#endif

+

+	return pvReturn;

+}

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

+

+void vPortFree( void *pv )

+{

+	/* Memory cannot be freed using this scheme.  See heap_2.c, heap_3.c and

+	heap_4.c for alternative implementations, and the memory management pages of

+	http://www.FreeRTOS.org for more information. */

+	( void ) pv;

+

+	/* Force an assert as it is invalid to call this function. */

+	configASSERT( pv == NULL );

+}

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

+

+void vPortInitialiseBlocks( void )

+{

+	/* Only required when static memory is not cleared. */

+	xNextFreeByte = ( size_t ) 0;

+}

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

+

+size_t xPortGetFreeHeapSize( void )

+{

+	return ( configADJUSTED_HEAP_SIZE - xNextFreeByte );

+}

+

+

+

diff --git a/src/FreeRTOS-Sim-master/Source/portable/MemMang/heap_2.c b/src/FreeRTOS-Sim-master/Source/portable/MemMang/heap_2.c
new file mode 100644
index 0000000..4e0c92e
--- /dev/null
+++ b/src/FreeRTOS-Sim-master/Source/portable/MemMang/heap_2.c
@@ -0,0 +1,303 @@
+/*

+    FreeRTOS V8.2.2 - 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!

+*/

+

+/*

+ * A sample implementation of pvPortMalloc() and vPortFree() that permits

+ * allocated blocks to be freed, but does not combine adjacent free blocks

+ * into a single larger block (and so will fragment memory).  See heap_4.c for

+ * an equivalent that does combine adjacent blocks into single larger blocks.

+ *

+ * See heap_1.c, heap_3.c and heap_4.c for alternative implementations, and the

+ * memory management pages of http://www.FreeRTOS.org for more information.

+ */

+#include <stdlib.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

+

+#include "FreeRTOS.h"

+#include "task.h"

+

+#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE

+

+/* A few bytes might be lost to byte aligning the heap start address. */

+#define configADJUSTED_HEAP_SIZE	( configTOTAL_HEAP_SIZE - portBYTE_ALIGNMENT )

+

+/*

+ * Initialises the heap structures before their first use.

+ */

+static void prvHeapInit( void );

+

+/* Allocate the memory for the heap. */

+static uint8_t ucHeap[ configTOTAL_HEAP_SIZE ];

+

+/* Define the linked list structure.  This is used to link free blocks in order

+of their size. */

+typedef struct A_BLOCK_LINK

+{

+	struct A_BLOCK_LINK *pxNextFreeBlock;	/*<< The next free block in the list. */

+	size_t xBlockSize;						/*<< The size of the free block. */

+} BlockLink_t;

+

+

+static const uint16_t heapSTRUCT_SIZE	= ( ( sizeof ( BlockLink_t ) + ( portBYTE_ALIGNMENT - 1 ) ) & ~portBYTE_ALIGNMENT_MASK );

+#define heapMINIMUM_BLOCK_SIZE	( ( size_t ) ( heapSTRUCT_SIZE * 2 ) )

+

+/* Create a couple of list links to mark the start and end of the list. */

+static BlockLink_t xStart, xEnd;

+

+/* Keeps track of the number of free bytes remaining, but says nothing about

+fragmentation. */

+static size_t xFreeBytesRemaining = configADJUSTED_HEAP_SIZE;

+

+/* STATIC FUNCTIONS ARE DEFINED AS MACROS TO MINIMIZE THE FUNCTION CALL DEPTH. */

+

+/*

+ * Insert a block into the list of free blocks - which is ordered by size of

+ * the block.  Small blocks at the start of the list and large blocks at the end

+ * of the list.

+ */

+#define prvInsertBlockIntoFreeList( pxBlockToInsert )								\

+{																					\

+BlockLink_t *pxIterator;																\

+size_t xBlockSize;																	\

+																					\

+	xBlockSize = pxBlockToInsert->xBlockSize;										\

+																					\

+	/* Iterate through the list until a block is found that has a larger size */	\

+	/* than the block we are inserting. */											\

+	for( pxIterator = &xStart; pxIterator->pxNextFreeBlock->xBlockSize < xBlockSize; pxIterator = pxIterator->pxNextFreeBlock )	\

+	{																				\

+		/* There is nothing to do here - just iterate to the correct position. */	\

+	}																				\

+																					\

+	/* Update the list to include the block being inserted in the correct */		\

+	/* position. */																	\

+	pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock;					\

+	pxIterator->pxNextFreeBlock = pxBlockToInsert;									\

+}

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

+

+void *pvPortMalloc( size_t xWantedSize )

+{

+BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;

+static BaseType_t xHeapHasBeenInitialised = pdFALSE;

+void *pvReturn = NULL;

+

+	vTaskSuspendAll();

+	{

+		/* If this is the first call to malloc then the heap will require

+		initialisation to setup the list of free blocks. */

+		if( xHeapHasBeenInitialised == pdFALSE )

+		{

+			prvHeapInit();

+			xHeapHasBeenInitialised = pdTRUE;

+		}

+

+		/* The wanted size is increased so it can contain a BlockLink_t

+		structure in addition to the requested amount of bytes. */

+		if( xWantedSize > 0 )

+		{

+			xWantedSize += heapSTRUCT_SIZE;

+

+			/* Ensure that blocks are always aligned to the required number of bytes. */

+			if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0 )

+			{

+				/* Byte alignment required. */

+				xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );

+			}

+		}

+

+		if( ( xWantedSize > 0 ) && ( xWantedSize < configADJUSTED_HEAP_SIZE ) )

+		{

+			/* Blocks are stored in byte order - traverse the list from the start

+			(smallest) block until one of adequate size is found. */

+			pxPreviousBlock = &xStart;

+			pxBlock = xStart.pxNextFreeBlock;

+			while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )

+			{

+				pxPreviousBlock = pxBlock;

+				pxBlock = pxBlock->pxNextFreeBlock;

+			}

+

+			/* If we found the end marker then a block of adequate size was not found. */

+			if( pxBlock != &xEnd )

+			{

+				/* Return the memory space - jumping over the BlockLink_t structure

+				at its start. */

+				pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + heapSTRUCT_SIZE );

+

+				/* This block is being returned for use so must be taken out of the

+				list of free blocks. */

+				pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;

+

+				/* If the block is larger than required it can be split into two. */

+				if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )

+				{

+					/* This block is to be split into two.  Create a new block

+					following the number of bytes requested. The void cast is

+					used to prevent byte alignment warnings from the compiler. */

+					pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );

+

+					/* Calculate the sizes of two blocks split from the single

+					block. */

+					pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;

+					pxBlock->xBlockSize = xWantedSize;

+

+					/* Insert the new block into the list of free blocks. */

+					prvInsertBlockIntoFreeList( ( pxNewBlockLink ) );

+				}

+

+				xFreeBytesRemaining -= pxBlock->xBlockSize;

+			}

+		}

+

+		traceMALLOC( pvReturn, xWantedSize );

+	}

+	( void ) xTaskResumeAll();

+

+	#if( configUSE_MALLOC_FAILED_HOOK == 1 )

+	{

+		if( pvReturn == NULL )

+		{

+			extern void vApplicationMallocFailedHook( void );

+			vApplicationMallocFailedHook();

+		}

+	}

+	#endif

+

+	return pvReturn;

+}

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

+

+void vPortFree( void *pv )

+{

+uint8_t *puc = ( uint8_t * ) pv;

+BlockLink_t *pxLink;

+

+	if( pv != NULL )

+	{

+		/* The memory being freed will have an BlockLink_t structure immediately

+		before it. */

+		puc -= heapSTRUCT_SIZE;

+

+		/* This unexpected casting is to keep some compilers from issuing

+		byte alignment warnings. */

+		pxLink = ( void * ) puc;

+

+		vTaskSuspendAll();

+		{

+			/* Add this block to the list of free blocks. */

+			prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );

+			xFreeBytesRemaining += pxLink->xBlockSize;

+			traceFREE( pv, pxLink->xBlockSize );

+		}

+		( void ) xTaskResumeAll();

+	}

+}

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

+

+size_t xPortGetFreeHeapSize( void )

+{

+	return xFreeBytesRemaining;

+}

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

+

+void vPortInitialiseBlocks( void )

+{

+	/* This just exists to keep the linker quiet. */

+}

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

+

+static void prvHeapInit( void )

+{

+BlockLink_t *pxFirstFreeBlock;

+uint8_t *pucAlignedHeap;

+

+	/* Ensure the heap starts on a correctly aligned boundary. */

+	pucAlignedHeap = ( uint8_t * ) ( ( ( portPOINTER_SIZE_TYPE ) &ucHeap[ portBYTE_ALIGNMENT ] ) & ( ~( ( portPOINTER_SIZE_TYPE ) portBYTE_ALIGNMENT_MASK ) ) );

+

+	/* xStart is used to hold a pointer to the first item in the list of free

+	blocks.  The void cast is used to prevent compiler warnings. */

+	xStart.pxNextFreeBlock = ( void * ) pucAlignedHeap;

+	xStart.xBlockSize = ( size_t ) 0;

+

+	/* xEnd is used to mark the end of the list of free blocks. */

+	xEnd.xBlockSize = configADJUSTED_HEAP_SIZE;

+	xEnd.pxNextFreeBlock = NULL;

+

+	/* To start with there is a single free block that is sized to take up the

+	entire heap space. */

+	pxFirstFreeBlock = ( void * ) pucAlignedHeap;

+	pxFirstFreeBlock->xBlockSize = configADJUSTED_HEAP_SIZE;

+	pxFirstFreeBlock->pxNextFreeBlock = &xEnd;

+}

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

diff --git a/src/FreeRTOS-Sim-master/Source/portable/MemMang/heap_3.c b/src/FreeRTOS-Sim-master/Source/portable/MemMang/heap_3.c
new file mode 100644
index 0000000..0fa88f5
--- /dev/null
+++ b/src/FreeRTOS-Sim-master/Source/portable/MemMang/heap_3.c
@@ -0,0 +1,135 @@
+/*

+    FreeRTOS V8.2.2 - 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!

+*/

+

+

+/*

+ * Implementation of pvPortMalloc() and vPortFree() that relies on the

+ * compilers own malloc() and free() implementations.

+ *

+ * This file can only be used if the linker is configured to to generate

+ * a heap memory area.

+ *

+ * See heap_1.c, heap_2.c and heap_4.c for alternative implementations, and the

+ * memory management pages of http://www.FreeRTOS.org for more information.

+ */

+

+#include <stdlib.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

+

+#include "FreeRTOS.h"

+#include "task.h"

+

+#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE

+

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

+

+void *pvPortMalloc( size_t xWantedSize )

+{

+void *pvReturn;

+

+	vTaskSuspendAll();

+	{

+		pvReturn = malloc( xWantedSize );

+		traceMALLOC( pvReturn, xWantedSize );

+	}

+	( void ) xTaskResumeAll();

+

+	#if( configUSE_MALLOC_FAILED_HOOK == 1 )

+	{

+		if( pvReturn == NULL )

+		{

+			extern void vApplicationMallocFailedHook( void );

+			vApplicationMallocFailedHook();

+		}

+	}

+	#endif

+

+	return pvReturn;

+}

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

+

+void vPortFree( void *pv )

+{

+	if( pv )

+	{

+		vTaskSuspendAll();

+		{

+			free( pv );

+			traceFREE( pv, 0 );

+		}

+		( void ) xTaskResumeAll();

+	}

+}

+

+

+

diff --git a/src/FreeRTOS-Sim-master/Source/portable/MemMang/heap_4.c b/src/FreeRTOS-Sim-master/Source/portable/MemMang/heap_4.c
new file mode 100644
index 0000000..ce482d0
--- /dev/null
+++ b/src/FreeRTOS-Sim-master/Source/portable/MemMang/heap_4.c
@@ -0,0 +1,474 @@
+/*

+    FreeRTOS V8.2.2 - 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!

+*/

+

+/*

+ * A sample implementation of pvPortMalloc() and vPortFree() that combines

+ * (coalescences) adjacent memory blocks as they are freed, and in so doing

+ * limits memory fragmentation.

+ *

+ * See heap_1.c, heap_2.c and heap_3.c for alternative implementations, and the

+ * memory management pages of http://www.FreeRTOS.org for more information.

+ */

+#include <stdlib.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

+

+#include "FreeRTOS.h"

+#include "task.h"

+

+#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE

+

+/* Block sizes must not get too small. */

+#define heapMINIMUM_BLOCK_SIZE	( ( size_t ) ( xHeapStructSize << 1 ) )

+

+/* Assumes 8bit bytes! */

+#define heapBITS_PER_BYTE		( ( size_t ) 8 )

+

+/* Allocate the memory for the heap. */

+#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 memory address. */

+typedef struct A_BLOCK_LINK

+{

+	struct A_BLOCK_LINK *pxNextFreeBlock;	/*<< The next free block in the list. */

+	size_t xBlockSize;						/*<< The size of the free block. */

+} BlockLink_t;

+

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

+

+/*

+ * Inserts a block of memory that is being freed into the correct position in

+ * the list of free memory blocks.  The block being freed will be merged with

+ * the block in front it and/or the block behind it if the memory blocks are

+ * adjacent to each other.

+ */

+static void prvInsertBlockIntoFreeList( BlockLink_t *pxBlockToInsert );

+

+/*

+ * Called automatically to setup the required heap structures the first time

+ * pvPortMalloc() is called.

+ */

+static void prvHeapInit( void );

+

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

+

+/* The size of the structure placed at the beginning of each allocated memory

+block must by correctly byte aligned. */

+static const size_t xHeapStructSize	= ( sizeof( BlockLink_t ) + ( ( size_t ) ( portBYTE_ALIGNMENT - 1 ) ) ) & ~( ( size_t ) portBYTE_ALIGNMENT_MASK );

+

+/* Create a couple of list links to mark the start and end of the list. */

+static BlockLink_t xStart, *pxEnd = NULL;

+

+/* Keeps track of the number of free bytes remaining, but says nothing about

+fragmentation. */

+static size_t xFreeBytesRemaining = 0U;

+static size_t xMinimumEverFreeBytesRemaining = 0U;

+

+/* Gets set to the top bit of an size_t type.  When this bit in the xBlockSize

+member of an BlockLink_t structure is set then the block belongs to the

+application.  When the bit is free the block is still part of the free heap

+space. */

+static size_t xBlockAllocatedBit = 0;

+

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

+

+void *pvPortMalloc( size_t xWantedSize )

+{

+BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;

+void *pvReturn = NULL;

+

+	vTaskSuspendAll();

+	{

+		/* If this is the first call to malloc then the heap will require

+		initialisation to setup the list of free blocks. */

+		if( pxEnd == NULL )

+		{

+			prvHeapInit();

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+

+		/* Check the requested block size is not so large that the top bit is

+		set.  The top bit of the block size member of the BlockLink_t structure

+		is used to determine who owns the block - the application or the

+		kernel, so it must be free. */

+		if( ( xWantedSize & xBlockAllocatedBit ) == 0 )

+		{

+			/* The wanted size is increased so it can contain a BlockLink_t

+			structure in addition to the requested amount of bytes. */

+			if( xWantedSize > 0 )

+			{

+				xWantedSize += xHeapStructSize;

+

+				/* Ensure that blocks are always aligned to the required number

+				of bytes. */

+				if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )

+				{

+					/* Byte alignment required. */

+					xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );

+					configASSERT( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) == 0 );

+				}

+				else

+				{

+					mtCOVERAGE_TEST_MARKER();

+				}

+			}

+			else

+			{

+				mtCOVERAGE_TEST_MARKER();

+			}

+

+			if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )

+			{

+				/* Traverse the list from the start	(lowest address) block until

+				one	of adequate size is found. */

+				pxPreviousBlock = &xStart;

+				pxBlock = xStart.pxNextFreeBlock;

+				while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )

+				{

+					pxPreviousBlock = pxBlock;

+					pxBlock = pxBlock->pxNextFreeBlock;

+				}

+

+				/* If the end marker was reached then a block of adequate size

+				was	not found. */

+				if( pxBlock != pxEnd )

+				{

+					/* Return the memory space pointed to - jumping over the

+					BlockLink_t structure at its start. */

+					pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + xHeapStructSize );

+

+					/* This block is being returned for use so must be taken out

+					of the list of free blocks. */

+					pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;

+

+					/* If the block is larger than required it can be split into

+					two. */

+					if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )

+					{

+						/* This block is to be split into two.  Create a new

+						block following the number of bytes requested. The void

+						cast is used to prevent byte alignment warnings from the

+						compiler. */

+						pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );

+						configASSERT( ( ( ( size_t ) pxNewBlockLink ) & portBYTE_ALIGNMENT_MASK ) == 0 );

+

+						/* Calculate the sizes of two blocks split from the

+						single block. */

+						pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;

+						pxBlock->xBlockSize = xWantedSize;

+

+						/* Insert the new block into the list of free blocks. */

+						prvInsertBlockIntoFreeList( ( pxNewBlockLink ) );

+					}

+					else

+					{

+						mtCOVERAGE_TEST_MARKER();

+					}

+

+					xFreeBytesRemaining -= pxBlock->xBlockSize;

+

+					if( xFreeBytesRemaining < xMinimumEverFreeBytesRemaining )

+					{

+						xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;

+					}

+					else

+					{

+						mtCOVERAGE_TEST_MARKER();

+					}

+

+					/* The block is being returned - it is allocated and owned

+					by the application and has no "next" block. */

+					pxBlock->xBlockSize |= xBlockAllocatedBit;

+					pxBlock->pxNextFreeBlock = NULL;

+				}

+				else

+				{

+					mtCOVERAGE_TEST_MARKER();

+				}

+			}

+			else

+			{

+				mtCOVERAGE_TEST_MARKER();

+			}

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+

+		traceMALLOC( pvReturn, xWantedSize );

+	}

+	( void ) xTaskResumeAll();

+

+	#if( configUSE_MALLOC_FAILED_HOOK == 1 )

+	{

+		if( pvReturn == NULL )

+		{

+			extern void vApplicationMallocFailedHook( void );

+			vApplicationMallocFailedHook();

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+	}

+	#endif

+

+	configASSERT( ( ( ( uint32_t ) pvReturn ) & portBYTE_ALIGNMENT_MASK ) == 0 );

+	return pvReturn;

+}

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

+

+void vPortFree( void *pv )

+{

+uint8_t *puc = ( uint8_t * ) pv;

+BlockLink_t *pxLink;

+

+	if( pv != NULL )

+	{

+		/* The memory being freed will have an BlockLink_t structure immediately

+		before it. */

+		puc -= xHeapStructSize;

+

+		/* This casting is to keep the compiler from issuing warnings. */

+		pxLink = ( void * ) puc;

+

+		/* Check the block is actually allocated. */

+		configASSERT( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 );

+		configASSERT( pxLink->pxNextFreeBlock == NULL );

+

+		if( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 )

+		{

+			if( pxLink->pxNextFreeBlock == NULL )

+			{

+				/* The block is being returned to the heap - it is no longer

+				allocated. */

+				pxLink->xBlockSize &= ~xBlockAllocatedBit;

+

+				vTaskSuspendAll();

+				{

+					/* Add this block to the list of free blocks. */

+					xFreeBytesRemaining += pxLink->xBlockSize;

+					traceFREE( pv, pxLink->xBlockSize );

+					prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );

+				}

+				( void ) xTaskResumeAll();

+			}

+			else

+			{

+				mtCOVERAGE_TEST_MARKER();

+			}

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+	}

+}

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

+

+size_t xPortGetFreeHeapSize( void )

+{

+	return xFreeBytesRemaining;

+}

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

+

+size_t xPortGetMinimumEverFreeHeapSize( void )

+{

+	return xMinimumEverFreeBytesRemaining;

+}

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

+

+void vPortInitialiseBlocks( void )

+{

+	/* This just exists to keep the linker quiet. */

+}

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

+

+static void prvHeapInit( void )

+{

+BlockLink_t *pxFirstFreeBlock;

+uint8_t *pucAlignedHeap;

+size_t uxAddress;

+size_t xTotalHeapSize = configTOTAL_HEAP_SIZE;

+

+	/* Ensure the heap starts on a correctly aligned boundary. */

+	uxAddress = ( size_t ) ucHeap;

+

+	if( ( uxAddress & portBYTE_ALIGNMENT_MASK ) != 0 )

+	{

+		uxAddress += ( portBYTE_ALIGNMENT - 1 );

+		uxAddress &= ~( ( size_t ) portBYTE_ALIGNMENT_MASK );

+		xTotalHeapSize -= uxAddress - ( size_t ) ucHeap;

+	}

+

+	pucAlignedHeap = ( uint8_t * ) uxAddress;

+

+	/* xStart is used to hold a pointer to the first item in the list of free

+	blocks.  The void cast is used to prevent compiler warnings. */

+	xStart.pxNextFreeBlock = ( void * ) pucAlignedHeap;

+	xStart.xBlockSize = ( size_t ) 0;

+

+	/* pxEnd is used to mark the end of the list of free blocks and is inserted

+	at the end of the heap space. */

+	uxAddress = ( ( size_t ) pucAlignedHeap ) + xTotalHeapSize;

+	uxAddress -= xHeapStructSize;

+	uxAddress &= ~( ( size_t ) portBYTE_ALIGNMENT_MASK );

+	pxEnd = ( void * ) uxAddress;

+	pxEnd->xBlockSize = 0;

+	pxEnd->pxNextFreeBlock = NULL;

+

+	/* To start with there is a single free block that is sized to take up the

+	entire heap space, minus the space taken by pxEnd. */

+	pxFirstFreeBlock = ( void * ) pucAlignedHeap;

+	pxFirstFreeBlock->xBlockSize = uxAddress - ( size_t ) pxFirstFreeBlock;

+	pxFirstFreeBlock->pxNextFreeBlock = pxEnd;

+

+	/* Only one block exists - and it covers the entire usable heap space. */

+	xMinimumEverFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;

+	xFreeBytesRemaining = pxFirstFreeBlock->xBlockSize;

+

+	/* Work out the position of the top bit in a size_t variable. */

+	xBlockAllocatedBit = ( ( size_t ) 1 ) << ( ( sizeof( size_t ) * heapBITS_PER_BYTE ) - 1 );

+}

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

+

+static void prvInsertBlockIntoFreeList( BlockLink_t *pxBlockToInsert )

+{

+BlockLink_t *pxIterator;

+uint8_t *puc;

+

+	/* Iterate through the list until a block is found that has a higher address

+	than the block being inserted. */

+	for( pxIterator = &xStart; pxIterator->pxNextFreeBlock < pxBlockToInsert; pxIterator = pxIterator->pxNextFreeBlock )

+	{

+		/* Nothing to do here, just iterate to the right position. */

+	}

+

+	/* Do the block being inserted, and the block it is being inserted after

+	make a contiguous block of memory? */

+	puc = ( uint8_t * ) pxIterator;

+	if( ( puc + pxIterator->xBlockSize ) == ( uint8_t * ) pxBlockToInsert )

+	{

+		pxIterator->xBlockSize += pxBlockToInsert->xBlockSize;

+		pxBlockToInsert = pxIterator;

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

+

+	/* Do the block being inserted, and the block it is being inserted before

+	make a contiguous block of memory? */

+	puc = ( uint8_t * ) pxBlockToInsert;

+	if( ( puc + pxBlockToInsert->xBlockSize ) == ( uint8_t * ) pxIterator->pxNextFreeBlock )

+	{

+		if( pxIterator->pxNextFreeBlock != pxEnd )

+		{

+			/* Form one big block from the two blocks. */

+			pxBlockToInsert->xBlockSize += pxIterator->pxNextFreeBlock->xBlockSize;

+			pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock->pxNextFreeBlock;

+		}

+		else

+		{

+			pxBlockToInsert->pxNextFreeBlock = pxEnd;

+		}

+	}

+	else

+	{

+		pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock;

+	}

+

+	/* If the block being inserted plugged a gab, so was merged with the block

+	before and the block after, then it's pxNextFreeBlock pointer will have

+	already been set, and should not be set here as that would make it point

+	to itself. */

+	if( pxIterator != pxBlockToInsert )

+	{

+		pxIterator->pxNextFreeBlock = pxBlockToInsert;

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

+}

+

diff --git a/src/FreeRTOS-Sim-master/Source/portable/MemMang/heap_5.c b/src/FreeRTOS-Sim-master/Source/portable/MemMang/heap_5.c
new file mode 100644
index 0000000..666ec65
--- /dev/null
+++ b/src/FreeRTOS-Sim-master/Source/portable/MemMang/heap_5.c
@@ -0,0 +1,523 @@
+/*

+    FreeRTOS V8.2.2 - 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!

+*/

+

+/*

+ * A sample implementation of pvPortMalloc() that allows the heap to be defined

+ * across multiple non-contigous blocks and combines (coalescences) adjacent

+ * memory blocks as they are freed.

+ *

+ * See heap_1.c, heap_2.c, heap_3.c and heap_4.c for alternative

+ * implementations, and the memory management pages of http://www.FreeRTOS.org

+ * for more information.

+ *

+ * Usage notes:

+ *

+ * vPortDefineHeapRegions() ***must*** be called before pvPortMalloc().

+ * pvPortMalloc() will be called if any task objects (tasks, queues, event

+ * groups, etc.) are created, therefore vPortDefineHeapRegions() ***must*** be

+ * called before any other objects are defined.

+ *

+ * vPortDefineHeapRegions() takes a single parameter.  The parameter is an array

+ * of HeapRegion_t structures.  HeapRegion_t is defined in portable.h as

+ *

+ * typedef struct HeapRegion

+ * {

+ *	uint8_t *pucStartAddress; << Start address of a block of memory that will be part of the heap.

+ *	size_t xSizeInBytes;	  << Size of the block of memory.

+ * } HeapRegion_t;

+ *

+ * The array is terminated using a NULL zero sized region definition, and the

+ * memory regions defined in the array ***must*** appear in address order from

+ * low address to high address.  So the following is a valid example of how

+ * to use the function.

+ *

+ * HeapRegion_t xHeapRegions[] =

+ * {

+ * 	{ ( uint8_t * ) 0x80000000UL, 0x10000 }, << Defines a block of 0x10000 bytes starting at address 0x80000000

+ * 	{ ( uint8_t * ) 0x90000000UL, 0xa0000 }, << Defines a block of 0xa0000 bytes starting at address of 0x90000000

+ * 	{ NULL, 0 }                << Terminates the array.

+ * };

+ *

+ * vPortDefineHeapRegions( xHeapRegions ); << Pass the array into vPortDefineHeapRegions().

+ *

+ * Note 0x80000000 is the lower address so appears in the array first.

+ *

+ */

+#include <stdlib.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

+

+#include "FreeRTOS.h"

+#include "task.h"

+

+#undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE

+

+/* Block sizes must not get too small. */

+#define heapMINIMUM_BLOCK_SIZE	( ( size_t ) ( xHeapStructSize << 1 ) )

+

+/* Assumes 8bit bytes! */

+#define heapBITS_PER_BYTE		( ( size_t ) 8 )

+

+/* Define the linked list structure.  This is used to link free blocks in order

+of their memory address. */

+typedef struct A_BLOCK_LINK

+{

+	struct A_BLOCK_LINK *pxNextFreeBlock;	/*<< The next free block in the list. */

+	size_t xBlockSize;						/*<< The size of the free block. */

+} BlockLink_t;

+

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

+

+/*

+ * Inserts a block of memory that is being freed into the correct position in

+ * the list of free memory blocks.  The block being freed will be merged with

+ * the block in front it and/or the block behind it if the memory blocks are

+ * adjacent to each other.

+ */

+static void prvInsertBlockIntoFreeList( BlockLink_t *pxBlockToInsert );

+

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

+

+/* The size of the structure placed at the beginning of each allocated memory

+block must by correctly byte aligned. */

+static const size_t xHeapStructSize	= ( sizeof( BlockLink_t ) + ( ( size_t ) ( portBYTE_ALIGNMENT - 1 ) ) ) & ~( ( size_t ) portBYTE_ALIGNMENT_MASK );

+

+/* Create a couple of list links to mark the start and end of the list. */

+static BlockLink_t xStart, *pxEnd = NULL;

+

+/* Keeps track of the number of free bytes remaining, but says nothing about

+fragmentation. */

+static size_t xFreeBytesRemaining = 0U;

+static size_t xMinimumEverFreeBytesRemaining = 0U;

+

+/* Gets set to the top bit of an size_t type.  When this bit in the xBlockSize

+member of an BlockLink_t structure is set then the block belongs to the

+application.  When the bit is free the block is still part of the free heap

+space. */

+static size_t xBlockAllocatedBit = 0;

+

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

+

+void *pvPortMalloc( size_t xWantedSize )

+{

+BlockLink_t *pxBlock, *pxPreviousBlock, *pxNewBlockLink;

+void *pvReturn = NULL;

+

+	/* The heap must be initialised before the first call to

+	prvPortMalloc(). */

+	configASSERT( pxEnd );

+

+	vTaskSuspendAll();

+	{

+		/* Check the requested block size is not so large that the top bit is

+		set.  The top bit of the block size member of the BlockLink_t structure

+		is used to determine who owns the block - the application or the

+		kernel, so it must be free. */

+		if( ( xWantedSize & xBlockAllocatedBit ) == 0 )

+		{

+			/* The wanted size is increased so it can contain a BlockLink_t

+			structure in addition to the requested amount of bytes. */

+			if( xWantedSize > 0 )

+			{

+				xWantedSize += xHeapStructSize;

+

+				/* Ensure that blocks are always aligned to the required number

+				of bytes. */

+				if( ( xWantedSize & portBYTE_ALIGNMENT_MASK ) != 0x00 )

+				{

+					/* Byte alignment required. */

+					xWantedSize += ( portBYTE_ALIGNMENT - ( xWantedSize & portBYTE_ALIGNMENT_MASK ) );

+				}

+				else

+				{

+					mtCOVERAGE_TEST_MARKER();

+				}

+			}

+			else

+			{

+				mtCOVERAGE_TEST_MARKER();

+			}

+

+			if( ( xWantedSize > 0 ) && ( xWantedSize <= xFreeBytesRemaining ) )

+			{

+				/* Traverse the list from the start	(lowest address) block until

+				one	of adequate size is found. */

+				pxPreviousBlock = &xStart;

+				pxBlock = xStart.pxNextFreeBlock;

+				while( ( pxBlock->xBlockSize < xWantedSize ) && ( pxBlock->pxNextFreeBlock != NULL ) )

+				{

+					pxPreviousBlock = pxBlock;

+					pxBlock = pxBlock->pxNextFreeBlock;

+				}

+

+				/* If the end marker was reached then a block of adequate size

+				was	not found. */

+				if( pxBlock != pxEnd )

+				{

+					/* Return the memory space pointed to - jumping over the

+					BlockLink_t structure at its start. */

+					pvReturn = ( void * ) ( ( ( uint8_t * ) pxPreviousBlock->pxNextFreeBlock ) + xHeapStructSize );

+

+					/* This block is being returned for use so must be taken out

+					of the list of free blocks. */

+					pxPreviousBlock->pxNextFreeBlock = pxBlock->pxNextFreeBlock;

+

+					/* If the block is larger than required it can be split into

+					two. */

+					if( ( pxBlock->xBlockSize - xWantedSize ) > heapMINIMUM_BLOCK_SIZE )

+					{

+						/* This block is to be split into two.  Create a new

+						block following the number of bytes requested. The void

+						cast is used to prevent byte alignment warnings from the

+						compiler. */

+						pxNewBlockLink = ( void * ) ( ( ( uint8_t * ) pxBlock ) + xWantedSize );

+

+						/* Calculate the sizes of two blocks split from the

+						single block. */

+						pxNewBlockLink->xBlockSize = pxBlock->xBlockSize - xWantedSize;

+						pxBlock->xBlockSize = xWantedSize;

+

+						/* Insert the new block into the list of free blocks. */

+						prvInsertBlockIntoFreeList( ( pxNewBlockLink ) );

+					}

+					else

+					{

+						mtCOVERAGE_TEST_MARKER();

+					}

+

+					xFreeBytesRemaining -= pxBlock->xBlockSize;

+

+					if( xFreeBytesRemaining < xMinimumEverFreeBytesRemaining )

+					{

+						xMinimumEverFreeBytesRemaining = xFreeBytesRemaining;

+					}

+					else

+					{

+						mtCOVERAGE_TEST_MARKER();

+					}

+

+					/* The block is being returned - it is allocated and owned

+					by the application and has no "next" block. */

+					pxBlock->xBlockSize |= xBlockAllocatedBit;

+					pxBlock->pxNextFreeBlock = NULL;

+				}

+				else

+				{

+					mtCOVERAGE_TEST_MARKER();

+				}

+			}

+			else

+			{

+				mtCOVERAGE_TEST_MARKER();

+			}

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+

+		traceMALLOC( pvReturn, xWantedSize );

+	}

+	( void ) xTaskResumeAll();

+

+	#if( configUSE_MALLOC_FAILED_HOOK == 1 )

+	{

+		if( pvReturn == NULL )

+		{

+			extern void vApplicationMallocFailedHook( void );

+			vApplicationMallocFailedHook();

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+	}

+	#endif

+

+	return pvReturn;

+}

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

+

+void vPortFree( void *pv )

+{

+uint8_t *puc = ( uint8_t * ) pv;

+BlockLink_t *pxLink;

+

+	if( pv != NULL )

+	{

+		/* The memory being freed will have an BlockLink_t structure immediately

+		before it. */

+		puc -= xHeapStructSize;

+

+		/* This casting is to keep the compiler from issuing warnings. */

+		pxLink = ( void * ) puc;

+

+		/* Check the block is actually allocated. */

+		configASSERT( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 );

+		configASSERT( pxLink->pxNextFreeBlock == NULL );

+

+		if( ( pxLink->xBlockSize & xBlockAllocatedBit ) != 0 )

+		{

+			if( pxLink->pxNextFreeBlock == NULL )

+			{

+				/* The block is being returned to the heap - it is no longer

+				allocated. */

+				pxLink->xBlockSize &= ~xBlockAllocatedBit;

+

+				vTaskSuspendAll();

+				{

+					/* Add this block to the list of free blocks. */

+					xFreeBytesRemaining += pxLink->xBlockSize;

+					traceFREE( pv, pxLink->xBlockSize );

+					prvInsertBlockIntoFreeList( ( ( BlockLink_t * ) pxLink ) );

+				}

+				( void ) xTaskResumeAll();

+			}

+			else

+			{

+				mtCOVERAGE_TEST_MARKER();

+			}

+		}

+		else

+		{

+			mtCOVERAGE_TEST_MARKER();

+		}

+	}

+}

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

+

+size_t xPortGetFreeHeapSize( void )

+{

+	return xFreeBytesRemaining;

+}

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

+

+size_t xPortGetMinimumEverFreeHeapSize( void )

+{

+	return xMinimumEverFreeBytesRemaining;

+}

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

+

+static void prvInsertBlockIntoFreeList( BlockLink_t *pxBlockToInsert )

+{

+BlockLink_t *pxIterator;

+uint8_t *puc;

+

+	/* Iterate through the list until a block is found that has a higher address

+	than the block being inserted. */

+	for( pxIterator = &xStart; pxIterator->pxNextFreeBlock < pxBlockToInsert; pxIterator = pxIterator->pxNextFreeBlock )

+	{

+		/* Nothing to do here, just iterate to the right position. */

+	}

+

+	/* Do the block being inserted, and the block it is being inserted after

+	make a contiguous block of memory? */

+	puc = ( uint8_t * ) pxIterator;

+	if( ( puc + pxIterator->xBlockSize ) == ( uint8_t * ) pxBlockToInsert )

+	{

+		pxIterator->xBlockSize += pxBlockToInsert->xBlockSize;

+		pxBlockToInsert = pxIterator;

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

+

+	/* Do the block being inserted, and the block it is being inserted before

+	make a contiguous block of memory? */

+	puc = ( uint8_t * ) pxBlockToInsert;

+	if( ( puc + pxBlockToInsert->xBlockSize ) == ( uint8_t * ) pxIterator->pxNextFreeBlock )

+	{

+		if( pxIterator->pxNextFreeBlock != pxEnd )

+		{

+			/* Form one big block from the two blocks. */

+			pxBlockToInsert->xBlockSize += pxIterator->pxNextFreeBlock->xBlockSize;

+			pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock->pxNextFreeBlock;

+		}

+		else

+		{

+			pxBlockToInsert->pxNextFreeBlock = pxEnd;

+		}

+	}

+	else

+	{

+		pxBlockToInsert->pxNextFreeBlock = pxIterator->pxNextFreeBlock;

+	}

+

+	/* If the block being inserted plugged a gab, so was merged with the block

+	before and the block after, then it's pxNextFreeBlock pointer will have

+	already been set, and should not be set here as that would make it point

+	to itself. */

+	if( pxIterator != pxBlockToInsert )

+	{

+		pxIterator->pxNextFreeBlock = pxBlockToInsert;

+	}

+	else

+	{

+		mtCOVERAGE_TEST_MARKER();

+	}

+}

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

+

+void vPortDefineHeapRegions( const HeapRegion_t * const pxHeapRegions )

+{

+BlockLink_t *pxFirstFreeBlockInRegion = NULL, *pxPreviousFreeBlock;

+uint8_t *pucAlignedHeap;

+size_t xTotalRegionSize, xTotalHeapSize = 0;

+BaseType_t xDefinedRegions = 0;

+size_t xAddress;

+const HeapRegion_t *pxHeapRegion;

+

+	/* Can only call once! */

+	configASSERT( pxEnd == NULL );

+

+	pxHeapRegion = &( pxHeapRegions[ xDefinedRegions ] );

+

+	while( pxHeapRegion->xSizeInBytes > 0 )

+	{

+		xTotalRegionSize = pxHeapRegion->xSizeInBytes;

+

+		/* Ensure the heap region starts on a correctly aligned boundary. */

+		xAddress = ( size_t ) pxHeapRegion->pucStartAddress;

+		if( ( xAddress & portBYTE_ALIGNMENT_MASK ) != 0 )

+		{

+			xAddress += ( portBYTE_ALIGNMENT - 1 );

+			xAddress &= ~portBYTE_ALIGNMENT_MASK;

+

+			/* Adjust the size for the bytes lost to alignment. */

+			xTotalRegionSize -= xAddress - ( size_t ) pxHeapRegion->pucStartAddress;

+		}

+

+		pucAlignedHeap = ( uint8_t * ) xAddress;

+

+		/* Set xStart if it has not already been set. */

+		if( xDefinedRegions == 0 )

+		{

+			/* xStart is used to hold a pointer to the first item in the list of

+			free blocks.  The void cast is used to prevent compiler warnings. */

+			xStart.pxNextFreeBlock = ( BlockLink_t * ) pucAlignedHeap;

+			xStart.xBlockSize = ( size_t ) 0;

+		}

+		else

+		{

+			/* Should only get here if one region has already been added to the

+			heap. */

+			configASSERT( pxEnd != NULL );

+

+			/* Check blocks are passed in with increasing start addresses. */

+			configASSERT( xAddress > ( size_t ) pxEnd );

+		}

+

+		/* Remember the location of the end marker in the previous region, if

+		any. */

+		pxPreviousFreeBlock = pxEnd;

+

+		/* pxEnd is used to mark the end of the list of free blocks and is

+		inserted at the end of the region space. */

+		xAddress = ( ( size_t ) pucAlignedHeap ) + xTotalRegionSize;

+		xAddress -= xHeapStructSize;

+		xAddress &= ~portBYTE_ALIGNMENT_MASK;

+		pxEnd = ( BlockLink_t * ) xAddress;

+		pxEnd->xBlockSize = 0;

+		pxEnd->pxNextFreeBlock = NULL;

+

+		/* To start with there is a single free block in this region that is

+		sized to take up the entire heap region minus the space taken by the

+		free block structure. */

+		pxFirstFreeBlockInRegion = ( BlockLink_t * ) pucAlignedHeap;

+		pxFirstFreeBlockInRegion->xBlockSize = xAddress - ( size_t ) pxFirstFreeBlockInRegion;

+		pxFirstFreeBlockInRegion->pxNextFreeBlock = pxEnd;

+

+		/* If this is not the first region that makes up the entire heap space

+		then link the previous region to this region. */

+		if( pxPreviousFreeBlock != NULL )

+		{

+			pxPreviousFreeBlock->pxNextFreeBlock = pxFirstFreeBlockInRegion;

+		}

+

+		xTotalHeapSize += pxFirstFreeBlockInRegion->xBlockSize;

+

+		/* Move onto the next HeapRegion_t structure. */

+		xDefinedRegions++;

+		pxHeapRegion = &( pxHeapRegions[ xDefinedRegions ] );

+	}

+

+	xMinimumEverFreeBytesRemaining = xTotalHeapSize;

+	xFreeBytesRemaining = xTotalHeapSize;

+

+	/* Check something was actually defined before it is accessed. */

+	configASSERT( xTotalHeapSize );

+

+	/* Work out the position of the top bit in a size_t variable. */

+	xBlockAllocatedBit = ( ( size_t ) 1 ) << ( ( sizeof( size_t ) * heapBITS_PER_BYTE ) - 1 );

+}

+