Add the files from the MQTT project that were not check in.

git-svn-id: https://svn.code.sf.net/p/freertos/code/trunk@2689 1d2547de-c912-0410-9cb9-b8ca96c0e9e2

diff --git a/FreeRTOS-Plus/Source/FreeRTOS-Plus-IoT-SDK/abstractions/platform/freertos/iot_clock_freertos.c b/FreeRTOS-Plus/Source/FreeRTOS-Plus-IoT-SDK/abstractions/platform/freertos/iot_clock_freertos.c
new file mode 100644 (file)
index 0000000..4d74b82
--- /dev/null
+++ b/FreeRTOS-Plus/Source/FreeRTOS-Plus-IoT-SDK/abstractions/platform/freertos/iot_clock_freertos.c
@@ -0,0 +1,224 @@
+/*\r
+ * Amazon FreeRTOS Platform V1.0.0\r
+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
+ *\r
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
+ * this software and associated documentation files (the "Software"), to deal in\r
+ * the Software without restriction, including without limitation the rights to\r
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
+ * the Software, and to permit persons to whom the Software is furnished to do so,\r
+ * subject to the following conditions:\r
+ *\r
+ * The above copyright notice and this permission notice shall be included in all\r
+ * copies or substantial portions of the Software.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+ *\r
+ * http://aws.amazon.com/freertos\r
+ * http://www.FreeRTOS.org\r
+ */\r
+\r
+/**\r
+ * @file iot_clock_freertos.c\r
+ * @brief Implementation of the functions in iot_clock.h for Amazon FreeRTOS systems.\r
+ */\r
+\r
+/* The config header is always included first. */\r
+#include "iot_config.h"\r
+\r
+/* Standard includes. */\r
+#include <stdio.h>\r
+\r
+/* Platform clock include. */\r
+#include "platform/iot_platform_types_freertos.h"\r
+#include "platform/iot_clock.h"\r
+#include "task.h"\r
+\r
+/* Configure logs for the functions in this file. */\r
+#ifdef IOT_LOG_LEVEL_PLATFORM\r
+    #define LIBRARY_LOG_LEVEL        IOT_LOG_LEVEL_PLATFORM\r
+#else\r
+    #ifdef IOT_LOG_LEVEL_GLOBAL\r
+        #define LIBRARY_LOG_LEVEL    IOT_LOG_LEVEL_GLOBAL\r
+    #else\r
+        #define LIBRARY_LOG_LEVEL    IOT_LOG_NONE\r
+    #endif\r
+#endif\r
+\r
+#define LIBRARY_LOG_NAME    ( "CLOCK" )\r
+#include "iot_logging_setup.h"\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+/*\r
+ * Time conversion constants.\r
+ */\r
+#define _MILLISECONDS_PER_SECOND    ( 1000 )                                          /**< @brief Milliseconds per second. */\r
+#define _MILLISECONDS_PER_TICK      ( _MILLISECONDS_PER_SECOND / configTICK_RATE_HZ ) /**< Milliseconds per FreeRTOS tick. */\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+/*  Private Callback function for timer expiry, delegate work to a Task to free\r
+ *  up the timer task for managing other timers */\r
+static void prvTimerCallback( TimerHandle_t xTimerHandle )\r
+{\r
+    _IotSystemTimer_t * pxTimer = ( _IotSystemTimer_t * ) pvTimerGetTimerID( xTimerHandle );\r
+\r
+    /* The value of the timer ID, set in timer_create, should not be NULL. */\r
+    configASSERT( pxTimer != NULL );\r
+\r
+    /* Restart the timer if it is periodic. */\r
+    if( pxTimer->xTimerPeriod > 0 )\r
+    {\r
+        xTimerChangePeriod( xTimerHandle, pxTimer->xTimerPeriod, 0 );\r
+    }\r
+\r
+    /* Call timer Callback from this task */\r
+    pxTimer->threadRoutine( ( void * ) pxTimer->pArgument );\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+bool IotClock_GetTimestring( char * pBuffer,\r
+                             size_t bufferSize,\r
+                             size_t * pTimestringLength )\r
+{\r
+    uint64_t milliSeconds = IotClock_GetTimeMs();\r
+    int timestringLength = 0;\r
+\r
+    configASSERT( pBuffer != NULL );\r
+    configASSERT( pTimestringLength != NULL );\r
+\r
+    /* Convert the localTime struct to a string. */\r
+    timestringLength = snprintf( pBuffer, bufferSize, "%llu", milliSeconds );\r
+\r
+    /* Check for error from no string */\r
+    if( timestringLength == 0 )\r
+    {\r
+        return false;\r
+    }\r
+\r
+    /* Set the output parameter. */\r
+    *pTimestringLength = timestringLength;\r
+\r
+    return true;\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+uint64_t IotClock_GetTimeMs( void )\r
+{\r
+    TimeOut_t xCurrentTime = { 0 };\r
+\r
+    /* This must be unsigned because the behavior of signed integer overflow is undefined. */\r
+    uint64_t ullTickCount = 0ULL;\r
+\r
+    /* Get the current tick count and overflow count. vTaskSetTimeOutState()\r
+     * is used to get these values because they are both static in tasks.c. */\r
+    vTaskSetTimeOutState( &xCurrentTime );\r
+\r
+    /* Adjust the tick count for the number of times a TickType_t has overflowed. */\r
+    ullTickCount = ( uint64_t ) ( xCurrentTime.xOverflowCount ) << ( sizeof( TickType_t ) * 8 );\r
+\r
+    /* Add the current tick count. */\r
+    ullTickCount += xCurrentTime.xTimeOnEntering;\r
+\r
+    /* Return the ticks converted to Milliseconds */\r
+    return ullTickCount * _MILLISECONDS_PER_TICK;\r
+}\r
+/*-----------------------------------------------------------*/\r
+\r
+void IotClock_SleepMs( uint32_t sleepTimeMs )\r
+{\r
+    vTaskDelay( pdMS_TO_TICKS( sleepTimeMs ) );\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+bool IotClock_TimerCreate( IotTimer_t * pNewTimer,\r
+                           IotThreadRoutine_t expirationRoutine,\r
+                           void * pArgument )\r
+{\r
+    _IotSystemTimer_t * pxTimer = ( _IotSystemTimer_t * ) pNewTimer;\r
+\r
+    configASSERT( pNewTimer != NULL );\r
+    configASSERT( expirationRoutine != NULL );\r
+\r
+    IotLogDebug( "Creating new timer %p.", pNewTimer );\r
+\r
+    /* Set the timer expiration routine, argument and period */\r
+    pxTimer->threadRoutine = expirationRoutine;\r
+    pxTimer->pArgument = pArgument;\r
+    pxTimer->xTimerPeriod = 0;\r
+\r
+    /* Create a new FreeRTOS timer. This call will not fail because the\r
+     * memory for it has already been allocated, so the output parameter is\r
+     * also set. */\r
+    pxTimer->timer = ( TimerHandle_t ) xTimerCreateStatic( "timer",                  /* Timer name. */\r
+                                                           portMAX_DELAY,            /* Initial timer period. Timers are created disarmed. */\r
+                                                           pdFALSE,                  /* Don't auto-reload timer. */\r
+                                                           ( void * ) pxTimer,       /* Timer id. */\r
+                                                           prvTimerCallback,         /* Timer expiration callback. */\r
+                                                           &pxTimer->xTimerBuffer ); /* Pre-allocated memory for timer. */\r
+\r
+    return true;\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+void IotClock_TimerDestroy( IotTimer_t * pTimer )\r
+{\r
+    _IotSystemTimer_t * pTimerInfo = ( _IotSystemTimer_t * ) pTimer;\r
+\r
+    configASSERT( pTimerInfo != NULL );\r
+    configASSERT( pTimerInfo->timer != NULL );\r
+\r
+    IotLogDebug( "Destroying timer %p.", pTimer );\r
+\r
+    if( xTimerIsTimerActive( pTimerInfo->timer ) == pdTRUE )\r
+    {\r
+        /* Stop the FreeRTOS timer. Because the timer is statically allocated, no call\r
+         * to xTimerDelete is necessary. The timer is stopped so that it's not referenced\r
+         * anywhere. xTimerStop will not fail when it has unlimited block time. */\r
+        ( void ) xTimerStop( pTimerInfo->timer, portMAX_DELAY );\r
+\r
+        /* Wait until the timer stop command is processed. */\r
+        while( xTimerIsTimerActive( pTimerInfo->timer ) == pdTRUE )\r
+        {\r
+            vTaskDelay( 1 );\r
+        }\r
+    }\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+bool IotClock_TimerArm( IotTimer_t * pTimer,\r
+                        uint32_t relativeTimeoutMs,\r
+                        uint32_t periodMs )\r
+{\r
+    _IotSystemTimer_t * pTimerInfo = ( _IotSystemTimer_t * ) pTimer;\r
+\r
+    configASSERT( pTimerInfo != NULL );\r
+\r
+    TimerHandle_t xTimerHandle = pTimerInfo->timer;\r
+\r
+    IotLogDebug( "Arming timer %p with timeout %llu and period %llu.",\r
+                 pTimer,\r
+                 relativeTimeoutMs,\r
+                 periodMs );\r
+\r
+    /* Set the timer period in ticks */\r
+    pTimerInfo->xTimerPeriod = pdMS_TO_TICKS( periodMs );\r
+\r
+    /* Set the timer to expire after relativeTimeoutMs, and restart it. */\r
+    ( void ) xTimerChangePeriod( xTimerHandle, pdMS_TO_TICKS( relativeTimeoutMs ), portMAX_DELAY );\r
+\r
+    return true;\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r

diff --git a/FreeRTOS-Plus/Source/FreeRTOS-Plus-IoT-SDK/abstractions/platform/freertos/iot_threads_freertos.c b/FreeRTOS-Plus/Source/FreeRTOS-Plus-IoT-SDK/abstractions/platform/freertos/iot_threads_freertos.c
new file mode 100644 (file)
index 0000000..f4a5f97
--- /dev/null
+++ b/FreeRTOS-Plus/Source/FreeRTOS-Plus-IoT-SDK/abstractions/platform/freertos/iot_threads_freertos.c
@@ -0,0 +1,364 @@
+/*\r
+ * Amazon FreeRTOS Platform V1.0.0\r
+ * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
+ *\r
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
+ * this software and associated documentation files (the "Software"), to deal in\r
+ * the Software without restriction, including without limitation the rights to\r
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
+ * the Software, and to permit persons to whom the Software is furnished to do so,\r
+ * subject to the following conditions:\r
+ *\r
+ * The above copyright notice and this permission notice shall be included in all\r
+ * copies or substantial portions of the Software.\r
+ *\r
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
+ *\r
+ * http://aws.amazon.com/freertos\r
+ * http://www.FreeRTOS.org\r
+ */\r
+\r
+/**\r
+ * @file iot_threads_freertos.c\r
+ * @brief Implementation of the functions in iot_threads.h for POSIX systems.\r
+ */\r
+\r
+/* The config header is always included first. */\r
+#include "iot_config.h"\r
+\r
+#include "semphr.h"\r
+\r
+/* Platform threads include. */\r
+#include "platform/iot_platform_types_freertos.h"\r
+#include "platform/iot_threads.h"\r
+#include "types/iot_platform_types.h"\r
+\r
+/* Configure logs for the functions in this file. */\r
+#ifdef IOT_LOG_LEVEL_PLATFORM\r
+    #define LIBRARY_LOG_LEVEL        IOT_LOG_LEVEL_PLATFORM\r
+#else\r
+    #ifdef IOT_LOG_LEVEL_GLOBAL\r
+        #define LIBRARY_LOG_LEVEL    IOT_LOG_LEVEL_GLOBAL\r
+    #else\r
+        #define LIBRARY_LOG_LEVEL    IOT_LOG_NONE\r
+    #endif\r
+#endif\r
+\r
+#define LIBRARY_LOG_NAME    ( "THREAD" )\r
+#include "iot_logging_setup.h"\r
+\r
+/*\r
+ * Provide default values for undefined memory allocation functions based on\r
+ * the usage of dynamic memory allocation.\r
+ */\r
+#ifndef IotThreads_Malloc\r
+    #include <stdlib.h>\r
+\r
+/**\r
+ * @brief Memory allocation. This function should have the same signature\r
+ * as [malloc](http://pubs.opengroup.org/onlinepubs/9699919799/functions/malloc.html).\r
+ */\r
+    #define IotThreads_Malloc    malloc\r
+#endif\r
+#ifndef IotThreads_Free\r
+    #include <stdlib.h>\r
+\r
+/**\r
+ * @brief Free memory. This function should have the same signature as\r
+ * [free](http://pubs.opengroup.org/onlinepubs/9699919799/functions/free.html).\r
+ */\r
+    #define IotThreads_Free    free\r
+#endif\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+static void _threadRoutineWrapper( void * pArgument )\r
+{\r
+    threadInfo_t * pThreadInfo = ( threadInfo_t * ) pArgument;\r
+\r
+    /* Run the thread routine. */\r
+    pThreadInfo->threadRoutine( pThreadInfo->pArgument );\r
+    IotThreads_Free( pThreadInfo );\r
+\r
+    vTaskDelete( NULL );\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+bool Iot_CreateDetachedThread( IotThreadRoutine_t threadRoutine,\r
+                               void * pArgument,\r
+                               int32_t priority,\r
+                               size_t stackSize )\r
+{\r
+    bool status = true;\r
+\r
+    configASSERT( threadRoutine != NULL );\r
+\r
+    IotLogDebug( "Creating new thread." );\r
+    threadInfo_t * pThreadInfo = IotThreads_Malloc( sizeof( threadInfo_t ) );\r
+\r
+    if( pThreadInfo == NULL )\r
+    {\r
+        IotLogDebug( "Unable to allocate memory for threadRoutine %p.", threadRoutine );\r
+        status = false;\r
+    }\r
+\r
+    /* Create the FreeRTOS task that will run the thread. */\r
+    if( status )\r
+    {\r
+        pThreadInfo->threadRoutine = threadRoutine;\r
+        pThreadInfo->pArgument = pArgument;\r
+\r
+        if( xTaskCreate( _threadRoutineWrapper,\r
+                         "iot_thread",\r
+                         ( configSTACK_DEPTH_TYPE ) stackSize,\r
+                         pThreadInfo,\r
+                         priority,\r
+                         NULL ) != pdPASS )\r
+        {\r
+            /* Task creation failed. */\r
+            IotLogWarn( "Failed to create thread." );\r
+            IotThreads_Free( pThreadInfo );\r
+            status = false;\r
+        }\r
+    }\r
+\r
+    return status;\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+bool IotMutex_Create( IotMutex_t * pNewMutex,\r
+                      bool recursive )\r
+{\r
+    _IotSystemMutex_t * internalMutex = ( _IotSystemMutex_t * ) pNewMutex;\r
+\r
+    configASSERT( internalMutex != NULL );\r
+\r
+    IotLogDebug( "Creating new mutex %p.", pNewMutex );\r
+\r
+    if( recursive )\r
+    {\r
+        ( void ) xSemaphoreCreateRecursiveMutexStatic( &internalMutex->xMutex );\r
+    }\r
+    else\r
+    {\r
+        ( void ) xSemaphoreCreateMutexStatic( &internalMutex->xMutex );\r
+    }\r
+\r
+    /* remember the type of mutex */\r
+    if( recursive )\r
+    {\r
+        internalMutex->recursive = pdTRUE;\r
+    }\r
+    else\r
+    {\r
+        internalMutex->recursive = pdFALSE;\r
+    }\r
+\r
+    return true;\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+void IotMutex_Destroy( IotMutex_t * pMutex )\r
+{\r
+    _IotSystemMutex_t * internalMutex = ( _IotSystemMutex_t * ) pMutex;\r
+\r
+    configASSERT( internalMutex != NULL );\r
+\r
+    vSemaphoreDelete( ( SemaphoreHandle_t ) &internalMutex->xMutex );\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+bool prIotMutexTimedLock( IotMutex_t * pMutex,\r
+                          TickType_t timeout )\r
+{\r
+    _IotSystemMutex_t * internalMutex = ( _IotSystemMutex_t * ) pMutex;\r
+    BaseType_t lockResult;\r
+\r
+    configASSERT( internalMutex != NULL );\r
+\r
+    IotLogDebug( "Locking mutex %p.", internalMutex );\r
+\r
+    /* Call the correct FreeRTOS mutex take function based on mutex type. */\r
+    if( internalMutex->recursive == pdTRUE )\r
+    {\r
+        lockResult = xSemaphoreTakeRecursive( ( SemaphoreHandle_t ) &internalMutex->xMutex, timeout );\r
+    }\r
+    else\r
+    {\r
+        lockResult = xSemaphoreTake( ( SemaphoreHandle_t ) &internalMutex->xMutex, timeout );\r
+    }\r
+\r
+    return( lockResult == pdTRUE );\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+void IotMutex_Lock( IotMutex_t * pMutex )\r
+{\r
+    prIotMutexTimedLock( pMutex, portMAX_DELAY );\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+bool IotMutex_TryLock( IotMutex_t * pMutex )\r
+{\r
+    return prIotMutexTimedLock( pMutex, 0 );\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+void IotMutex_Unlock( IotMutex_t * pMutex )\r
+{\r
+    _IotSystemMutex_t * internalMutex = ( _IotSystemMutex_t * ) pMutex;\r
+\r
+    configASSERT( internalMutex != NULL );\r
+\r
+    IotLogDebug( "Unlocking mutex %p.", internalMutex );\r
+\r
+    /* Call the correct FreeRTOS mutex unlock function based on mutex type. */\r
+    if( internalMutex->recursive == pdTRUE )\r
+    {\r
+        ( void ) xSemaphoreGiveRecursive( ( SemaphoreHandle_t ) &internalMutex->xMutex );\r
+    }\r
+    else\r
+    {\r
+        ( void ) xSemaphoreGive( ( SemaphoreHandle_t ) &internalMutex->xMutex );\r
+    }\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+bool IotSemaphore_Create( IotSemaphore_t * pNewSemaphore,\r
+                          uint32_t initialValue,\r
+                          uint32_t maxValue )\r
+{\r
+    _IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pNewSemaphore;\r
+\r
+    configASSERT( internalSemaphore != NULL );\r
+\r
+    IotLogDebug( "Creating new semaphore %p.", pNewSemaphore );\r
+\r
+    ( void ) xSemaphoreCreateCountingStatic( maxValue, initialValue, &internalSemaphore->xSemaphore );\r
+\r
+    return true;\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+uint32_t IotSemaphore_GetCount( IotSemaphore_t * pSemaphore )\r
+{\r
+    _IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;\r
+    UBaseType_t count = 0;\r
+\r
+    configASSERT( internalSemaphore != NULL );\r
+\r
+    count = uxSemaphoreGetCount( ( SemaphoreHandle_t ) &internalSemaphore->xSemaphore );\r
+\r
+    IotLogDebug( "Semaphore %p has count %d.", pSemaphore, count );\r
+\r
+    return ( uint32_t ) count;\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+void IotSemaphore_Destroy( IotSemaphore_t * pSemaphore )\r
+{\r
+    _IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;\r
+\r
+    configASSERT( internalSemaphore != NULL );\r
+\r
+    IotLogDebug( "Destroying semaphore %p.", internalSemaphore );\r
+\r
+    vSemaphoreDelete( ( SemaphoreHandle_t ) &internalSemaphore->xSemaphore );\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+void IotSemaphore_Wait( IotSemaphore_t * pSemaphore )\r
+{\r
+    _IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;\r
+\r
+    configASSERT( internalSemaphore != NULL );\r
+\r
+    IotLogDebug( "Waiting on semaphore %p.", internalSemaphore );\r
+\r
+    /* Take the semaphore using the FreeRTOS API. */\r
+    if( xSemaphoreTake( ( SemaphoreHandle_t ) &internalSemaphore->xSemaphore,\r
+                        portMAX_DELAY ) != pdTRUE )\r
+    {\r
+        IotLogWarn( "Failed to wait on semaphore %p.",\r
+                    pSemaphore );\r
+\r
+        /* Assert here, debugging we always want to know that this happened because you think\r
+         *   that you are waiting successfully on the semaphore but you are not   */\r
+        configASSERT( false );\r
+    }\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+bool IotSemaphore_TryWait( IotSemaphore_t * pSemaphore )\r
+{\r
+    _IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;\r
+\r
+    configASSERT( internalSemaphore != NULL );\r
+\r
+    IotLogDebug( "Attempting to wait on semaphore %p.", internalSemaphore );\r
+\r
+    return IotSemaphore_TimedWait( pSemaphore, 0 );\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+bool IotSemaphore_TimedWait( IotSemaphore_t * pSemaphore,\r
+                             uint32_t timeoutMs )\r
+{\r
+    _IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;\r
+\r
+    configASSERT( internalSemaphore != NULL );\r
+\r
+    /* Take the semaphore using the FreeRTOS API. Cast the calculation to 64 bit to avoid overflows*/\r
+    if( xSemaphoreTake( ( SemaphoreHandle_t ) &internalSemaphore->xSemaphore,\r
+                        pdMS_TO_TICKS( timeoutMs ) ) != pdTRUE )\r
+    {\r
+        /* Only warn if timeout > 0 */\r
+        if( timeoutMs > 0 )\r
+        {\r
+            IotLogWarn( "Timeout waiting on semaphore %p.",\r
+                        internalSemaphore );\r
+        }\r
+\r
+        return false;\r
+    }\r
+\r
+    return true;\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r
+\r
+void IotSemaphore_Post( IotSemaphore_t * pSemaphore )\r
+{\r
+    _IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;\r
+\r
+    configASSERT( internalSemaphore != NULL );\r
+\r
+    IotLogDebug( "Posting to semaphore %p.", internalSemaphore );\r
+    /* Give the semaphore using the FreeRTOS API. */\r
+    BaseType_t result = xSemaphoreGive( ( SemaphoreHandle_t ) &internalSemaphore->xSemaphore );\r
+\r
+    if( result == pdFALSE )\r
+    {\r
+        IotLogDebug( "Unable to give semaphore over maximum", internalSemaphore );\r
+    }\r
+}\r
+\r
+/*-----------------------------------------------------------*/\r