FreeRTOS port

---
 .../{old/rtxc => freertos/port}/include/arch/cc.h  |  72 ++--
 .../rtxc => freertos/port}/include/arch/init.h     |   0
 .../{old/rtxc => freertos/port}/include/arch/lib.h |   0
 .../rtxc => freertos/port}/include/arch/sys_arch.h |  19 +-
 .../include/arch => freertos/port/include}/perf.h  |   0
 ports/freertos/port/sys_arch.c                     | 480 +++++++++++++++++++++
 6 files changed, 540 insertions(+), 31 deletions(-)
 copy ports/{old/rtxc => freertos/port}/include/arch/cc.h (64%)
 copy ports/{old/rtxc => freertos/port}/include/arch/init.h (100%)
 copy ports/{old/rtxc => freertos/port}/include/arch/lib.h (100%)
 copy ports/{old/rtxc => freertos/port}/include/arch/sys_arch.h (81%)
 copy ports/{old/rtxc/include/arch => freertos/port/include}/perf.h (100%)
 create mode 100644 ports/freertos/port/sys_arch.c

diff --git a/ports/old/rtxc/include/arch/cc.h b/ports/freertos/port/include/arch/cc.h
similarity index 64%
copy from ports/old/rtxc/include/arch/cc.h
copy to ports/freertos/port/include/arch/cc.h
index ac55609..05b4e62 100644
--- a/ports/old/rtxc/include/arch/cc.h
+++ b/ports/freertos/port/include/arch/cc.h
@@ -1,8 +1,8 @@
 /*
  * Copyright (c) 2001-2003 Swedish Institute of Computer Science.
- * All rights reserved. 
- * 
- * Redistribution and use in source and binary forms, with or without modification, 
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
  * are permitted provided that the following conditions are met:
  *
  * 1. Redistributions of source code must retain the above copyright notice,
@@ -11,27 +11,37 @@
  *    this list of conditions and the following disclaimer in the documentation
  *    and/or other materials provided with the distribution.
  * 3. The name of the author may not be used to endorse or promote products
- *    derived from this software without specific prior written permission. 
+ *    derived from this software without specific prior written permission.
  *
- * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED 
- * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF 
- * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT 
- * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, 
- * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT 
- * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 
- * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 
- * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING 
- * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY 
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
  * OF SUCH DAMAGE.
  *
  * This file is part of the lwIP TCP/IP stack.
- * 
+ *
  * Author: Adam Dunkels <address@hidden>
  *
  */
 #ifndef __CC_H__
 #define __CC_H__
 
+#include <stdio.h>
+#include <stdlib.h>
+
+#define U16_F "hu"
+#define X16_F "hX"
+#define U32_F "u"
+#define X32_F "X"
+#define S16_F "hd"
+#define S32_F "d"
+
 typedef unsigned   char    u8_t;
 typedef signed     char    s8_t;
 typedef unsigned   short   u16_t;
@@ -39,16 +49,28 @@ typedef signed     short   s16_t;
 typedef unsigned   long    u32_t;
 typedef signed     long    s32_t;
 
-#define U16_F "hu"
-#define S16_F "hd"
-#define X16_F "hx"
-#define U32_F "lu"
-#define S32_F "ld"
-#define X32_F "lx"
-
-#define PACK_STRUCT_BEGIN
-#define PACK_STRUCT_STRUCT
-#define PACK_STRUCT_END
-#define PACK_STRUCT_FIELD(x) x
+/* typedef u32_t mem_ptr_t; */
+typedef int sys_prot_t;
+
+#define LWIP_TIMEVAL_PRIVATE 0
+
+/* Define platform endianness */
+#ifndef BYTE_ORDER
+#define BYTE_ORDER LITTLE_ENDIAN
+#endif /* BYTE_ORDER */
+
+/* Compiler hints for packing structures */
+#define PACK_STRUCT_STRUCT __attribute__((packed))
+
+
+/* Plaform specific diagnostic output */
+#define LWIP_PLATFORM_DIAG(x)   do {printf x;} while(0)
+
+#define LWIP_PLATFORM_ASSERT(x) do {printf("Assertion \"%s\" failed at line %d
+in %s\n", \
+                                     x, __LINE__, __FILE__); fflush(NULL);
+abort();} while(0)
+
+#define LWIP_RAND() ((u32_t)rand())
 
 #endif /* __CC_H__ */
diff --git a/ports/old/rtxc/include/arch/init.h b/ports/freertos/port/include/arch/init.h
similarity index 100%
copy from ports/old/rtxc/include/arch/init.h
copy to ports/freertos/port/include/arch/init.h
diff --git a/ports/old/rtxc/include/arch/lib.h b/ports/freertos/port/include/arch/lib.h
similarity index 100%
copy from ports/old/rtxc/include/arch/lib.h
copy to ports/freertos/port/include/arch/lib.h
diff --git a/ports/old/rtxc/include/arch/sys_arch.h b/ports/freertos/port/include/arch/sys_arch.h
similarity index 81%
copy from ports/old/rtxc/include/arch/sys_arch.h
copy to ports/freertos/port/include/arch/sys_arch.h
index f423fb6..cdf4c29 100644
--- a/ports/old/rtxc/include/arch/sys_arch.h
+++ b/ports/freertos/port/include/arch/sys_arch.h
@@ -32,14 +32,21 @@
 #ifndef __SYS_RTXC_H__
 #define __SYS_RTXC_H__
 
-#include "rtxcapi.h"
+#include "FreeRTOS.h"
+#include "task.h"
+#include "queue.h"
+#include "semphr.h"
 
-#define SYS_MBOX_NULL (QUEUE)0
-#define SYS_SEM_NULL  (SEMA)0
+#define SYS_MBOX_NULL (xQueueHandle)0
+#define SYS_SEM_NULL  (xSemaphoreHandle)0
 
-typedef SEMA sys_sem_t;
-typedef QUEUE sys_mbox_t;
-typedef TASK sys_thread_t;
+typedef xSemaphoreHandle sys_sem_t;
+typedef xQueueHandle sys_mbox_t;
+typedef xTaskHandle sys_thread_t;
+
+/* Message queue constants. */
+#define archMESG_QUEUE_LENGTH	( 32 )
+#define archPOST_BLOCK_TIME_MS	( ( unsigned portLONG ) 10000 )
 
 #endif /* __SYS_RTXC_H__ */
 
diff --git a/ports/old/rtxc/include/arch/perf.h b/ports/freertos/port/include/perf.h
similarity index 100%
copy from ports/old/rtxc/include/arch/perf.h
copy to ports/freertos/port/include/perf.h
diff --git a/ports/freertos/port/sys_arch.c b/ports/freertos/port/sys_arch.c
new file mode 100644
index 0000000..2d04047
--- /dev/null
+++ b/ports/freertos/port/sys_arch.c
@@ -0,0 +1,480 @@
+/*
+ * Copyright (c) 2001-2003 Swedish Institute of Computer Science.
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without modification,
+ * are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ * 3. The name of the author may not be used to endorse or promote products
+ *    derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
+ * SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT
+ * OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING
+ * IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY
+ * OF SUCH DAMAGE.
+ *
+ * This file is part of the lwIP TCP/IP stack.
+ *
+ * Author: Adam Dunkels <address@hidden>
+ * Author: Stefano Oliveri <address@hidden>
+ *
+ * This file was modified by Stefano Oliveri to implement the system emulation layer for STR91x.
+ *
+ */
+
+/* lwIP includes. */
+#include "lwip/debug.h"
+#include "lwip/def.h"
+#include "lwip/sys.h"
+#include "lwip/mem.h"
+#include "lwip/stats.h"
+
+#define SYS_MAX_Q 20
+static xQueueHandle sys_mbox_table[SYS_MAX_Q];
+#define SYS_MAX_SEM 20
+static xQueueHandle sys_sem_table[SYS_MAX_SEM];
+
+/* This is the number of threads that can be started with sys_thread_new() */
+#define SYS_THREAD_MAX 4
+
+static u16_t s_nextthread = 0;
+
+/*-----------------------------------------------------------------------------------*/
+/*   Creates an empty mailbox. */
+err_t sys_mbox_new(sys_mbox_t *mbox, int size)
+{
+	int i;
+	err_t ret = ERR_OK;
+	*mbox = xQueueCreate( archMESG_QUEUE_LENGTH, sizeof( void * ) );
+
+#if SYS_STATS
+      ++lwip_stats.sys.mbox.used;
+      if (lwip_stats.sys.mbox.max < lwip_stats.sys.mbox.used) {
+         lwip_stats.sys.mbox.max = lwip_stats.sys.mbox.used;
+	  }
+#endif /* SYS_STATS */
+	vTaskSuspendAll();
+	for(i=0;i<SYS_MAX_Q;i++) {
+		if(sys_mbox_table[i] == NULL) {
+			sys_mbox_table[i] = *mbox;
+			break;
+		}
+	}
+	xTaskResumeAll();	
+	if(i == SYS_MAX_Q) {
+		/* If we reach here *mbox was never added to the table, we can safely delete it */
+		vQueueDelete( *mbox );
+		*mbox = NULL;
+		ret = ERR_MEM;
+	}
+	return ret;
+}
+
+/*-----------------------------------------------------------------------------------*/
+/*
+  Deallocates a mailbox. If there are messages still present in the
+  mailbox when the mailbox is deallocated, it is an indication of a
+  programming error in lwIP and the developer should be notified.
+*/
+void sys_mbox_free(sys_mbox_t *mbox)
+{
+	int i;
+	if( *mbox == NULL )
+		return;
+
+	if( uxQueueMessagesWaiting( *mbox ) ) {
+		/* Line for breakpoint.  Should never break here! */
+		portNOP();
+#if SYS_STATS
+	    lwip_stats.sys.mbox.err++;
+#endif /* SYS_STATS */
+
+	}
+
+#if SYS_STATS
+     --lwip_stats.sys.mbox.used;
+#endif /* SYS_STATS */
+	vTaskSuspendAll();
+	for(i=0;i<SYS_MAX_Q;i++)
+		if(*mbox == sys_mbox_table[i])
+			sys_mbox_table[i] = NULL;
+	xTaskResumeAll();
+	/* Delete after marking the mbox in the table as invalid */
+	vQueueDelete( *mbox );
+	*mbox = NULL;
+}
+
+/*-----------------------------------------------------------------------------------*/
+//   Posts the "msg" to the mailbox.
+void sys_mbox_post(sys_mbox_t *mbox, void *data)
+{
+	if( *mbox == NULL )
+		return;
+
+	while ( xQueueSendToBack(*mbox, &data, portMAX_DELAY ) != pdTRUE );
+}
+/*-----------------------------------------------------------------------------------*/
+//   Try to post the "msg" to the mailbox.
+err_t sys_mbox_trypost(sys_mbox_t *mbox, void *msg)
+{
+   err_t result = ERR_VAL;
+
+  if( *mbox == NULL )
+	return result;
+
+   if ( xQueueSend( *mbox, &msg, 0 ) == pdPASS ) {
+	result = ERR_OK;
+   } else {
+      /*  could not post, queue must be full */
+      result = ERR_MEM;
+
+#if SYS_STATS
+      lwip_stats.sys.mbox.err++;
+#endif /* SYS_STATS */
+
+   }
+   return result;
+}
+
+/*-----------------------------------------------------------------------------------*/
+/*
+  Blocks the thread until a message arrives in the mailbox, but does
+  not block the thread longer than "timeout" milliseconds (similar to
+  the sys_arch_sem_wait() function). The "msg" argument is a result
+  parameter that is set by the function (i.e., by doing "*msg =
+  ptr"). The "msg" parameter maybe NULL to indicate that the message
+  should be dropped.
+
+  The return values are the same as for the sys_arch_sem_wait() function:
+  Number of milliseconds spent waiting or SYS_ARCH_TIMEOUT if there was a
+  timeout.
+
+  Note that a function with a similar name, sys_mbox_fetch(), is
+  implemented by lwIP.
+*/
+u32_t sys_arch_mbox_fetch(sys_mbox_t *mbox, void **msg, u32_t timeout)
+{
+	void *dummyptr;
+	portTickType StartTime, EndTime, Elapsed;
+
+	if( *mbox == NULL )
+		return SYS_ARCH_TIMEOUT;
+
+	StartTime = xTaskGetTickCount();
+
+	if ( msg == NULL )
+		msg = &dummyptr;
+
+	if ( timeout != 0 )
+	{
+		if ( pdTRUE == xQueueReceive( *mbox, &(*msg), timeout / portTICK_RATE_MS ) )
+		{
+			EndTime = xTaskGetTickCount();
+			Elapsed = (EndTime - StartTime) * portTICK_RATE_MS;
+
+			return ( Elapsed );
+		}
+		else // timed out blocking for message
+		{
+			*msg = NULL;
+
+			return SYS_ARCH_TIMEOUT;
+		}
+	}
+	else // block forever for a message.
+	{
+		while( pdTRUE != xQueueReceive( *mbox, &(*msg), portMAX_DELAY ) ); // time is arbitrary
+		EndTime = xTaskGetTickCount();
+		Elapsed = (EndTime - StartTime) * portTICK_RATE_MS;
+		return (Elapsed);
+	}
+}
+
+/*-----------------------------------------------------------------------------------*/
+/*
+  Similar to sys_arch_mbox_fetch, but if message is not ready immediately, we'll
+  return with SYS_MBOX_EMPTY.  On success, 0 is returned.
+*/
+u32_t sys_arch_mbox_tryfetch(sys_mbox_t *mbox, void **msg)
+{
+	void *dummyptr;
+	if( *mbox == NULL )
+		return SYS_MBOX_EMPTY;
+
+	if ( msg == NULL )
+		msg = &dummyptr;
+
+	if ( pdTRUE == xQueueReceive( *mbox, &(*msg), 0 ) )
+		return ERR_OK;
+	else
+		return SYS_MBOX_EMPTY;
+}
+
+int sys_mbox_valid(sys_mbox_t *mbox)
+{
+	int i,ret=0;
+	if( *mbox == NULL )
+		return ret;
+	vTaskSuspendAll();
+	for(i=0;i<SYS_MAX_Q;i++) {
+		if(sys_mbox_table[i] == *mbox) {
+			ret = 1;
+		}
+	}
+	xTaskResumeAll();	
+
+	return ret;
+}
+void sys_mbox_set_invalid(sys_mbox_t *mbox)
+{
+	int i;
+	if( *mbox == NULL )
+		return;
+	vTaskSuspendAll();
+	for(i=0;i<SYS_MAX_Q;i++) {
+		if(sys_mbox_table[i] == *mbox) {
+			sys_mbox_table[i] = NULL;
+			break;
+		}
+	}
+	xTaskResumeAll();	
+	*mbox = NULL;
+}
+/*-----------------------------------------------------------------------------------*/
+//  Creates and returns a new semaphore. The "count" argument specifies
+//  the initial state of the semaphore.
+err_t sys_sem_new(sys_sem_t *sem, u8_t count)
+{
+	int i;
+	err_t ret = ERR_OK;
+	vSemaphoreCreateBinary( *sem );
+
+	if( *sem == NULL ) {
+
+#if SYS_STATS
+      ++lwip_stats.sys.sem.err;
+#endif /* SYS_STATS */
+
+		return ERR_MEM;	// TODO need assert
+	}
+
+	if(count == 0) { /*Means it can't be taken */
+		xSemaphoreTake(*sem,1);
+	}
+
+	vTaskSuspendAll();
+	for(i=0;i<SYS_MAX_SEM;i++) {
+		if(sys_sem_table[i] == NULL) {
+			sys_sem_table[i] = *sem;
+			break;
+		}
+	}
+	xTaskResumeAll();	
+	if(i == SYS_MAX_SEM) {
+		vQueueDelete( *sem );
+		*sem = NULL;
+		ret = ERR_MEM;
+	}
+
+#if SYS_STATS
+	++lwip_stats.sys.sem.used;
+ 	if (lwip_stats.sys.sem.max < lwip_stats.sys.sem.used) {
+		lwip_stats.sys.sem.max = lwip_stats.sys.sem.used;
+	}
+#endif /* SYS_STATS */
+
+	return ret;
+}
+
+/*-----------------------------------------------------------------------------------*/
+/*
+  Blocks the thread while waiting for the semaphore to be
+  signaled. If the "timeout" argument is non-zero, the thread should
+  only be blocked for the specified time (measured in
+  milliseconds).
+
+  If the timeout argument is non-zero, the return value is the number of
+  milliseconds spent waiting for the semaphore to be signaled. If the
+  semaphore wasn't signaled within the specified time, the return value is
+  SYS_ARCH_TIMEOUT. If the thread didn't have to wait for the semaphore
+  (i.e., it was already signaled), the function may return zero.
+
+  Notice that lwIP implements a function with a similar name,
+  sys_sem_wait(), that uses the sys_arch_sem_wait() function.
+*/
+u32_t sys_arch_sem_wait(sys_sem_t *sem, u32_t timeout)
+{
+	portTickType StartTime, EndTime, Elapsed;
+
+	StartTime = xTaskGetTickCount();
+
+	if (timeout != 0) {
+		if (xSemaphoreTake( *sem, timeout / portTICK_RATE_MS ) == pdTRUE) {
+			EndTime = xTaskGetTickCount();
+			Elapsed = (EndTime - StartTime) * portTICK_RATE_MS;
+
+			return (Elapsed);
+		}
+		else
+			return SYS_ARCH_TIMEOUT;
+	}
+	else {  /* must block without a timeout */
+		while( xSemaphoreTake( *sem, portMAX_DELAY ) != pdTRUE );
+		EndTime = xTaskGetTickCount();
+		Elapsed = (EndTime - StartTime) * portTICK_RATE_MS;
+		return ( Elapsed ); /* return time blocked */
+	}
+}
+
+/*-----------------------------------------------------------------------------------*/
+// Signals a semaphore
+void sys_sem_signal(sys_sem_t *sem)
+{
+	xSemaphoreGive( *sem );
+}
+
+/*-----------------------------------------------------------------------------------*/
+// Deallocates a semaphore
+void sys_sem_free(sys_sem_t *sem)
+{
+	int i;
+#if SYS_STATS
+      --lwip_stats.sys.sem.used;
+#endif /* SYS_STATS */
+
+	vTaskSuspendAll();
+	for(i=0;i<SYS_MAX_SEM;i++)
+		if(*sem == sys_sem_table[i])
+			sys_sem_table[i] = NULL;
+	xTaskResumeAll();
+	/* Delete after marking the sem in the table as invalid */
+	vQueueDelete( *sem );
+	*sem = NULL;
+
+}
+
+void sys_sem_set_invalid(sys_sem_t *sem)
+{
+	int i;
+	if( *sem == NULL )
+		return;
+	vTaskSuspendAll();
+	for(i=0;i<SYS_MAX_SEM;i++) {
+		if(sys_sem_table[i] == *sem) {
+			sys_sem_table[i] = NULL;
+		}
+	}
+	xTaskResumeAll();
+	*sem = NULL;
+}
+
+int sys_sem_valid(sys_sem_t *sem)
+{
+	int i,ret = 0;
+
+	if( *sem == NULL )
+		return ret;
+	vTaskSuspendAll();
+	for(i=0;i<SYS_MAX_SEM;i++) {
+		if(sys_sem_table[i] == *sem) {
+			ret = 1;
+		}
+	}
+	xTaskResumeAll();	
+	return ret;
+}
+/*-----------------------------------------------------------------------------------*/
+// Initialize sys arch
+void sys_init(void)
+{
+	int i;
+	for(i = 0; i < SYS_MAX_Q; i++) {
+		sys_mbox_table[i] = NULL;
+	}
+	for(i = 0; i < SYS_MAX_SEM; i++) {
+		sys_sem_table[i] = NULL;
+	}
+}
+/*-----------------------------------------------------------------------------------*/
+/*-----------------------------------------------------------------------------------*/
+// TODO
+/*-----------------------------------------------------------------------------------*/
+/*
+  Starts a new thread with priority "prio" that will begin its execution in the
+  function "thread()". The "arg" argument will be passed as an argument to the
+  thread() function. The id of the new thread is returned. Both the id and
+  the priority are system dependent.
+*/
+sys_thread_t sys_thread_new(const char *name, lwip_thread_fn thread, void *arg, int stacksize, int prio)
+{
+	xTaskHandle CreatedTask;
+	int result;
+
+	if (s_nextthread < SYS_THREAD_MAX ) {
+		result = xTaskCreate
+			(thread,
+			name,
+			stacksize,
+			arg,
+			prio,
+			&CreatedTask);
+
+		if(result == pdPASS)
+			   return CreatedTask;
+		 else
+			return NULL;
+	} else
+	      return NULL;
+}
+
+/*
+  This optional function does a "fast" critical region protection and returns
+  the previous protection level. This function is only called during very short
+  critical regions. An embedded system which supports ISR-based drivers might
+  want to implement this function by disabling interrupts. Task-based systems
+  might want to implement this by using a mutex or disabling tasking. This
+  function should support recursive calls from the same task or interrupt. In
+  other words, sys_arch_protect() could be called while already protected. In
+  that case the return value indicates that it is already protected.
+
+  sys_arch_protect() is only required if your port is supporting an operating
+  system.
+*/
+sys_prot_t sys_arch_protect(void)
+{
+	vPortEnterCritical();
+	return 1;
+}
+
+/*
+  This optional function does a "fast" set of critical region protection to the
+  value specified by pval. See the documentation for sys_arch_protect() for
+  more information. This function is only required if your port is supporting
+  an operating system.
+*/
+void sys_arch_unprotect(sys_prot_t pval)
+{
+	( void ) pval;
+	vPortExitCritical();
+}
+
+
+
+unsigned long sys_arch_get_os_ticks()
+{
+    return  xTaskGetTickCount();
+}
+
+
+
-- 
2.7.4