Add the files from the MQTT project that were not check in.
Richard Barry
6 years ago
parent
5dd6cf1295
commit
238a23e4d5
@ -0,0 +1,224 @@
|
||||
/*
|
||||
* Amazon FreeRTOS Platform V1.0.0
|
||||
* Copyright (C) 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://aws.amazon.com/freertos
|
||||
* http://www.FreeRTOS.org
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file iot_clock_freertos.c
|
||||
* @brief Implementation of the functions in iot_clock.h for Amazon FreeRTOS systems.
|
||||
*/
|
||||
|
||||
/* The config header is always included first. */
|
||||
#include "iot_config.h"
|
||||
|
||||
/* Standard includes. */
|
||||
#include <stdio.h>
|
||||
|
||||
/* Platform clock include. */
|
||||
#include "platform/iot_platform_types_freertos.h"
|
||||
#include "platform/iot_clock.h"
|
||||
#include "task.h"
|
||||
|
||||
/* Configure logs for the functions in this file. */
|
||||
#ifdef IOT_LOG_LEVEL_PLATFORM
|
||||
#define LIBRARY_LOG_LEVEL IOT_LOG_LEVEL_PLATFORM
|
||||
#else
|
||||
#ifdef IOT_LOG_LEVEL_GLOBAL
|
||||
#define LIBRARY_LOG_LEVEL IOT_LOG_LEVEL_GLOBAL
|
||||
#else
|
||||
#define LIBRARY_LOG_LEVEL IOT_LOG_NONE
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define LIBRARY_LOG_NAME ( "CLOCK" )
|
||||
#include "iot_logging_setup.h"
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/*
|
||||
* Time conversion constants.
|
||||
*/
|
||||
#define _MILLISECONDS_PER_SECOND ( 1000 ) /**< @brief Milliseconds per second. */
|
||||
#define _MILLISECONDS_PER_TICK ( _MILLISECONDS_PER_SECOND / configTICK_RATE_HZ ) /**< Milliseconds per FreeRTOS tick. */
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
/* Private Callback function for timer expiry, delegate work to a Task to free
|
||||
* up the timer task for managing other timers */
|
||||
static void prvTimerCallback( TimerHandle_t xTimerHandle )
|
||||
{
|
||||
_IotSystemTimer_t * pxTimer = ( _IotSystemTimer_t * ) pvTimerGetTimerID( xTimerHandle );
|
||||
|
||||
/* The value of the timer ID, set in timer_create, should not be NULL. */
|
||||
configASSERT( pxTimer != NULL );
|
||||
|
||||
/* Restart the timer if it is periodic. */
|
||||
if( pxTimer->xTimerPeriod > 0 )
|
||||
{
|
||||
xTimerChangePeriod( xTimerHandle, pxTimer->xTimerPeriod, 0 );
|
||||
}
|
||||
|
||||
/* Call timer Callback from this task */
|
||||
pxTimer->threadRoutine( ( void * ) pxTimer->pArgument );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool IotClock_GetTimestring( char * pBuffer,
|
||||
size_t bufferSize,
|
||||
size_t * pTimestringLength )
|
||||
{
|
||||
uint64_t milliSeconds = IotClock_GetTimeMs();
|
||||
int timestringLength = 0;
|
||||
|
||||
configASSERT( pBuffer != NULL );
|
||||
configASSERT( pTimestringLength != NULL );
|
||||
|
||||
/* Convert the localTime struct to a string. */
|
||||
timestringLength = snprintf( pBuffer, bufferSize, "%llu", milliSeconds );
|
||||
|
||||
/* Check for error from no string */
|
||||
if( timestringLength == 0 )
|
||||
{
|
||||
return false;
|
||||
}
|
||||
|
||||
/* Set the output parameter. */
|
||||
*pTimestringLength = timestringLength;
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
uint64_t IotClock_GetTimeMs( void )
|
||||
{
|
||||
TimeOut_t xCurrentTime = { 0 };
|
||||
|
||||
/* This must be unsigned because the behavior of signed integer overflow is undefined. */
|
||||
uint64_t ullTickCount = 0ULL;
|
||||
|
||||
/* Get the current tick count and overflow count. vTaskSetTimeOutState()
|
||||
* is used to get these values because they are both static in tasks.c. */
|
||||
vTaskSetTimeOutState( &xCurrentTime );
|
||||
|
||||
/* Adjust the tick count for the number of times a TickType_t has overflowed. */
|
||||
ullTickCount = ( uint64_t ) ( xCurrentTime.xOverflowCount ) << ( sizeof( TickType_t ) * 8 );
|
||||
|
||||
/* Add the current tick count. */
|
||||
ullTickCount += xCurrentTime.xTimeOnEntering;
|
||||
|
||||
/* Return the ticks converted to Milliseconds */
|
||||
return ullTickCount * _MILLISECONDS_PER_TICK;
|
||||
}
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotClock_SleepMs( uint32_t sleepTimeMs )
|
||||
{
|
||||
vTaskDelay( pdMS_TO_TICKS( sleepTimeMs ) );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool IotClock_TimerCreate( IotTimer_t * pNewTimer,
|
||||
IotThreadRoutine_t expirationRoutine,
|
||||
void * pArgument )
|
||||
{
|
||||
_IotSystemTimer_t * pxTimer = ( _IotSystemTimer_t * ) pNewTimer;
|
||||
|
||||
configASSERT( pNewTimer != NULL );
|
||||
configASSERT( expirationRoutine != NULL );
|
||||
|
||||
IotLogDebug( "Creating new timer %p.", pNewTimer );
|
||||
|
||||
/* Set the timer expiration routine, argument and period */
|
||||
pxTimer->threadRoutine = expirationRoutine;
|
||||
pxTimer->pArgument = pArgument;
|
||||
pxTimer->xTimerPeriod = 0;
|
||||
|
||||
/* Create a new FreeRTOS timer. This call will not fail because the
|
||||
* memory for it has already been allocated, so the output parameter is
|
||||
* also set. */
|
||||
pxTimer->timer = ( TimerHandle_t ) xTimerCreateStatic( "timer", /* Timer name. */
|
||||
portMAX_DELAY, /* Initial timer period. Timers are created disarmed. */
|
||||
pdFALSE, /* Don't auto-reload timer. */
|
||||
( void * ) pxTimer, /* Timer id. */
|
||||
prvTimerCallback, /* Timer expiration callback. */
|
||||
&pxTimer->xTimerBuffer ); /* Pre-allocated memory for timer. */
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotClock_TimerDestroy( IotTimer_t * pTimer )
|
||||
{
|
||||
_IotSystemTimer_t * pTimerInfo = ( _IotSystemTimer_t * ) pTimer;
|
||||
|
||||
configASSERT( pTimerInfo != NULL );
|
||||
configASSERT( pTimerInfo->timer != NULL );
|
||||
|
||||
IotLogDebug( "Destroying timer %p.", pTimer );
|
||||
|
||||
if( xTimerIsTimerActive( pTimerInfo->timer ) == pdTRUE )
|
||||
{
|
||||
/* Stop the FreeRTOS timer. Because the timer is statically allocated, no call
|
||||
* to xTimerDelete is necessary. The timer is stopped so that it's not referenced
|
||||
* anywhere. xTimerStop will not fail when it has unlimited block time. */
|
||||
( void ) xTimerStop( pTimerInfo->timer, portMAX_DELAY );
|
||||
|
||||
/* Wait until the timer stop command is processed. */
|
||||
while( xTimerIsTimerActive( pTimerInfo->timer ) == pdTRUE )
|
||||
{
|
||||
vTaskDelay( 1 );
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool IotClock_TimerArm( IotTimer_t * pTimer,
|
||||
uint32_t relativeTimeoutMs,
|
||||
uint32_t periodMs )
|
||||
{
|
||||
_IotSystemTimer_t * pTimerInfo = ( _IotSystemTimer_t * ) pTimer;
|
||||
|
||||
configASSERT( pTimerInfo != NULL );
|
||||
|
||||
TimerHandle_t xTimerHandle = pTimerInfo->timer;
|
||||
|
||||
IotLogDebug( "Arming timer %p with timeout %llu and period %llu.",
|
||||
pTimer,
|
||||
relativeTimeoutMs,
|
||||
periodMs );
|
||||
|
||||
/* Set the timer period in ticks */
|
||||
pTimerInfo->xTimerPeriod = pdMS_TO_TICKS( periodMs );
|
||||
|
||||
/* Set the timer to expire after relativeTimeoutMs, and restart it. */
|
||||
( void ) xTimerChangePeriod( xTimerHandle, pdMS_TO_TICKS( relativeTimeoutMs ), portMAX_DELAY );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
@ -0,0 +1,364 @@
|
||||
/*
|
||||
* Amazon FreeRTOS Platform V1.0.0
|
||||
* Copyright (C) 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.
|
||||
*
|
||||
* Permission is hereby granted, free of charge, to any person obtaining a copy of
|
||||
* this software and associated documentation files (the "Software"), to deal in
|
||||
* the Software without restriction, including without limitation the rights to
|
||||
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
|
||||
* the Software, and to permit persons to whom the Software is furnished to do so,
|
||||
* subject to the following conditions:
|
||||
*
|
||||
* The above copyright notice and this permission notice shall be included in all
|
||||
* copies or substantial portions of the Software.
|
||||
*
|
||||
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
||||
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
|
||||
* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
|
||||
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
|
||||
* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
||||
* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
|
||||
*
|
||||
* http://aws.amazon.com/freertos
|
||||
* http://www.FreeRTOS.org
|
||||
*/
|
||||
|
||||
/**
|
||||
* @file iot_threads_freertos.c
|
||||
* @brief Implementation of the functions in iot_threads.h for POSIX systems.
|
||||
*/
|
||||
|
||||
/* The config header is always included first. */
|
||||
#include "iot_config.h"
|
||||
|
||||
#include "semphr.h"
|
||||
|
||||
/* Platform threads include. */
|
||||
#include "platform/iot_platform_types_freertos.h"
|
||||
#include "platform/iot_threads.h"
|
||||
#include "types/iot_platform_types.h"
|
||||
|
||||
/* Configure logs for the functions in this file. */
|
||||
#ifdef IOT_LOG_LEVEL_PLATFORM
|
||||
#define LIBRARY_LOG_LEVEL IOT_LOG_LEVEL_PLATFORM
|
||||
#else
|
||||
#ifdef IOT_LOG_LEVEL_GLOBAL
|
||||
#define LIBRARY_LOG_LEVEL IOT_LOG_LEVEL_GLOBAL
|
||||
#else
|
||||
#define LIBRARY_LOG_LEVEL IOT_LOG_NONE
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define LIBRARY_LOG_NAME ( "THREAD" )
|
||||
#include "iot_logging_setup.h"
|
||||
|
||||
/*
|
||||
* Provide default values for undefined memory allocation functions based on
|
||||
* the usage of dynamic memory allocation.
|
||||
*/
|
||||
#ifndef IotThreads_Malloc
|
||||
#include <stdlib.h>
|
||||
|
||||
/**
|
||||
* @brief Memory allocation. This function should have the same signature
|
||||
* as [malloc](http://pubs.opengroup.org/onlinepubs/9699919799/functions/malloc.html).
|
||||
*/
|
||||
#define IotThreads_Malloc malloc
|
||||
#endif
|
||||
#ifndef IotThreads_Free
|
||||
#include <stdlib.h>
|
||||
|
||||
/**
|
||||
* @brief Free memory. This function should have the same signature as
|
||||
* [free](http://pubs.opengroup.org/onlinepubs/9699919799/functions/free.html).
|
||||
*/
|
||||
#define IotThreads_Free free
|
||||
#endif
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
static void _threadRoutineWrapper( void * pArgument )
|
||||
{
|
||||
threadInfo_t * pThreadInfo = ( threadInfo_t * ) pArgument;
|
||||
|
||||
/* Run the thread routine. */
|
||||
pThreadInfo->threadRoutine( pThreadInfo->pArgument );
|
||||
IotThreads_Free( pThreadInfo );
|
||||
|
||||
vTaskDelete( NULL );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool Iot_CreateDetachedThread( IotThreadRoutine_t threadRoutine,
|
||||
void * pArgument,
|
||||
int32_t priority,
|
||||
size_t stackSize )
|
||||
{
|
||||
bool status = true;
|
||||
|
||||
configASSERT( threadRoutine != NULL );
|
||||
|
||||
IotLogDebug( "Creating new thread." );
|
||||
threadInfo_t * pThreadInfo = IotThreads_Malloc( sizeof( threadInfo_t ) );
|
||||
|
||||
if( pThreadInfo == NULL )
|
||||
{
|
||||
IotLogDebug( "Unable to allocate memory for threadRoutine %p.", threadRoutine );
|
||||
status = false;
|
||||
}
|
||||
|
||||
/* Create the FreeRTOS task that will run the thread. */
|
||||
if( status )
|
||||
{
|
||||
pThreadInfo->threadRoutine = threadRoutine;
|
||||
pThreadInfo->pArgument = pArgument;
|
||||
|
||||
if( xTaskCreate( _threadRoutineWrapper,
|
||||
"iot_thread",
|
||||
( configSTACK_DEPTH_TYPE ) stackSize,
|
||||
pThreadInfo,
|
||||
priority,
|
||||
NULL ) != pdPASS )
|
||||
{
|
||||
/* Task creation failed. */
|
||||
IotLogWarn( "Failed to create thread." );
|
||||
IotThreads_Free( pThreadInfo );
|
||||
status = false;
|
||||
}
|
||||
}
|
||||
|
||||
return status;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool IotMutex_Create( IotMutex_t * pNewMutex,
|
||||
bool recursive )
|
||||
{
|
||||
_IotSystemMutex_t * internalMutex = ( _IotSystemMutex_t * ) pNewMutex;
|
||||
|
||||
configASSERT( internalMutex != NULL );
|
||||
|
||||
IotLogDebug( "Creating new mutex %p.", pNewMutex );
|
||||
|
||||
if( recursive )
|
||||
{
|
||||
( void ) xSemaphoreCreateRecursiveMutexStatic( &internalMutex->xMutex );
|
||||
}
|
||||
else
|
||||
{
|
||||
( void ) xSemaphoreCreateMutexStatic( &internalMutex->xMutex );
|
||||
}
|
||||
|
||||
/* remember the type of mutex */
|
||||
if( recursive )
|
||||
{
|
||||
internalMutex->recursive = pdTRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
internalMutex->recursive = pdFALSE;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotMutex_Destroy( IotMutex_t * pMutex )
|
||||
{
|
||||
_IotSystemMutex_t * internalMutex = ( _IotSystemMutex_t * ) pMutex;
|
||||
|
||||
configASSERT( internalMutex != NULL );
|
||||
|
||||
vSemaphoreDelete( ( SemaphoreHandle_t ) &internalMutex->xMutex );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool prIotMutexTimedLock( IotMutex_t * pMutex,
|
||||
TickType_t timeout )
|
||||
{
|
||||
_IotSystemMutex_t * internalMutex = ( _IotSystemMutex_t * ) pMutex;
|
||||
BaseType_t lockResult;
|
||||
|
||||
configASSERT( internalMutex != NULL );
|
||||
|
||||
IotLogDebug( "Locking mutex %p.", internalMutex );
|
||||
|
||||
/* Call the correct FreeRTOS mutex take function based on mutex type. */
|
||||
if( internalMutex->recursive == pdTRUE )
|
||||
{
|
||||
lockResult = xSemaphoreTakeRecursive( ( SemaphoreHandle_t ) &internalMutex->xMutex, timeout );
|
||||
}
|
||||
else
|
||||
{
|
||||
lockResult = xSemaphoreTake( ( SemaphoreHandle_t ) &internalMutex->xMutex, timeout );
|
||||
}
|
||||
|
||||
return( lockResult == pdTRUE );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotMutex_Lock( IotMutex_t * pMutex )
|
||||
{
|
||||
prIotMutexTimedLock( pMutex, portMAX_DELAY );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool IotMutex_TryLock( IotMutex_t * pMutex )
|
||||
{
|
||||
return prIotMutexTimedLock( pMutex, 0 );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotMutex_Unlock( IotMutex_t * pMutex )
|
||||
{
|
||||
_IotSystemMutex_t * internalMutex = ( _IotSystemMutex_t * ) pMutex;
|
||||
|
||||
configASSERT( internalMutex != NULL );
|
||||
|
||||
IotLogDebug( "Unlocking mutex %p.", internalMutex );
|
||||
|
||||
/* Call the correct FreeRTOS mutex unlock function based on mutex type. */
|
||||
if( internalMutex->recursive == pdTRUE )
|
||||
{
|
||||
( void ) xSemaphoreGiveRecursive( ( SemaphoreHandle_t ) &internalMutex->xMutex );
|
||||
}
|
||||
else
|
||||
{
|
||||
( void ) xSemaphoreGive( ( SemaphoreHandle_t ) &internalMutex->xMutex );
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool IotSemaphore_Create( IotSemaphore_t * pNewSemaphore,
|
||||
uint32_t initialValue,
|
||||
uint32_t maxValue )
|
||||
{
|
||||
_IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pNewSemaphore;
|
||||
|
||||
configASSERT( internalSemaphore != NULL );
|
||||
|
||||
IotLogDebug( "Creating new semaphore %p.", pNewSemaphore );
|
||||
|
||||
( void ) xSemaphoreCreateCountingStatic( maxValue, initialValue, &internalSemaphore->xSemaphore );
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
uint32_t IotSemaphore_GetCount( IotSemaphore_t * pSemaphore )
|
||||
{
|
||||
_IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;
|
||||
UBaseType_t count = 0;
|
||||
|
||||
configASSERT( internalSemaphore != NULL );
|
||||
|
||||
count = uxSemaphoreGetCount( ( SemaphoreHandle_t ) &internalSemaphore->xSemaphore );
|
||||
|
||||
IotLogDebug( "Semaphore %p has count %d.", pSemaphore, count );
|
||||
|
||||
return ( uint32_t ) count;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotSemaphore_Destroy( IotSemaphore_t * pSemaphore )
|
||||
{
|
||||
_IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;
|
||||
|
||||
configASSERT( internalSemaphore != NULL );
|
||||
|
||||
IotLogDebug( "Destroying semaphore %p.", internalSemaphore );
|
||||
|
||||
vSemaphoreDelete( ( SemaphoreHandle_t ) &internalSemaphore->xSemaphore );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotSemaphore_Wait( IotSemaphore_t * pSemaphore )
|
||||
{
|
||||
_IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;
|
||||
|
||||
configASSERT( internalSemaphore != NULL );
|
||||
|
||||
IotLogDebug( "Waiting on semaphore %p.", internalSemaphore );
|
||||
|
||||
/* Take the semaphore using the FreeRTOS API. */
|
||||
if( xSemaphoreTake( ( SemaphoreHandle_t ) &internalSemaphore->xSemaphore,
|
||||
portMAX_DELAY ) != pdTRUE )
|
||||
{
|
||||
IotLogWarn( "Failed to wait on semaphore %p.",
|
||||
pSemaphore );
|
||||
|
||||
/* Assert here, debugging we always want to know that this happened because you think
|
||||
* that you are waiting successfully on the semaphore but you are not */
|
||||
configASSERT( false );
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool IotSemaphore_TryWait( IotSemaphore_t * pSemaphore )
|
||||
{
|
||||
_IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;
|
||||
|
||||
configASSERT( internalSemaphore != NULL );
|
||||
|
||||
IotLogDebug( "Attempting to wait on semaphore %p.", internalSemaphore );
|
||||
|
||||
return IotSemaphore_TimedWait( pSemaphore, 0 );
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
bool IotSemaphore_TimedWait( IotSemaphore_t * pSemaphore,
|
||||
uint32_t timeoutMs )
|
||||
{
|
||||
_IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;
|
||||
|
||||
configASSERT( internalSemaphore != NULL );
|
||||
|
||||
/* Take the semaphore using the FreeRTOS API. Cast the calculation to 64 bit to avoid overflows*/
|
||||
if( xSemaphoreTake( ( SemaphoreHandle_t ) &internalSemaphore->xSemaphore,
|
||||
pdMS_TO_TICKS( timeoutMs ) ) != pdTRUE )
|
||||
{
|
||||
/* Only warn if timeout > 0 */
|
||||
if( timeoutMs > 0 )
|
||||
{
|
||||
IotLogWarn( "Timeout waiting on semaphore %p.",
|
||||
internalSemaphore );
|
||||
}
|
||||
|
||||
return false;
|
||||
}
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
|
||||
void IotSemaphore_Post( IotSemaphore_t * pSemaphore )
|
||||
{
|
||||
_IotSystemSemaphore_t * internalSemaphore = ( _IotSystemSemaphore_t * ) pSemaphore;
|
||||
|
||||
configASSERT( internalSemaphore != NULL );
|
||||
|
||||
IotLogDebug( "Posting to semaphore %p.", internalSemaphore );
|
||||
/* Give the semaphore using the FreeRTOS API. */
|
||||
BaseType_t result = xSemaphoreGive( ( SemaphoreHandle_t ) &internalSemaphore->xSemaphore );
|
||||
|
||||
if( result == pdFALSE )
|
||||
{
|
||||
IotLogDebug( "Unable to give semaphore over maximum", internalSemaphore );
|
||||
}
|
||||
}
|
||||
|
||||
/*-----------------------------------------------------------*/
|
||||
Loading…
Reference in New Issue