/*\r
- * FreeRTOS Kernel V10.2.1\r
- * Copyright (C) 2019 Amazon.com, Inc. or its affiliates. All Rights Reserved.\r
+ * FreeRTOS Kernel V10.3.0\r
+ * Copyright (C) 2020 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
* MACROS AND DEFINITIONS\r
*----------------------------------------------------------*/\r
\r
-#define tskKERNEL_VERSION_NUMBER "V10.2.1"\r
+#define tskKERNEL_VERSION_NUMBER "V10.3.0"\r
#define tskKERNEL_VERSION_MAJOR 10\r
-#define tskKERNEL_VERSION_MINOR 2\r
-#define tskKERNEL_VERSION_BUILD 1\r
+#define tskKERNEL_VERSION_MINOR 3\r
+#define tskKERNEL_VERSION_BUILD 0\r
\r
/* MPU region parameters passed in ulParameters\r
* of MemoryRegion_t struct. */\r
// an automatic stack variable it might no longer exist, or at least have been corrupted, by the time\r
// the new task attempts to access it.\r
xTaskCreate( vTaskCode, "NAME", STACK_SIZE, &ucParameterToPass, tskIDLE_PRIORITY, &xHandle );\r
- configASSERT( xHandle );\r
+ configASSERT( xHandle );\r
\r
// Use the handle to delete the task.\r
- if( xHandle != NULL )\r
- {\r
- vTaskDelete( xHandle );\r
- }\r
+ if( xHandle != NULL )\r
+ {\r
+ vTaskDelete( xHandle );\r
+ }\r
}\r
</pre>\r
* \defgroup xTaskCreate xTaskCreate\r
// for full information.\r
{\r
// Base address Length Parameters\r
- { cReadWriteArray, 32, portMPU_REGION_READ_WRITE },\r
- { cReadOnlyArray, 32, portMPU_REGION_READ_ONLY },\r
- { cPrivilegedOnlyAccessArray, 128, portMPU_REGION_PRIVILEGED_READ_WRITE }\r
+ { cReadWriteArray, 32, portMPU_REGION_READ_WRITE },\r
+ { cReadOnlyArray, 32, portMPU_REGION_READ_ONLY },\r
+ { cPrivilegedOnlyAccessArray, 128, portMPU_REGION_PRIVILEGED_READ_WRITE }\r
}\r
};\r
\r
// for full information.\r
{\r
// Base address Length Parameters\r
- { cReadWriteArray, 32, portMPU_REGION_READ_WRITE },\r
- { cReadOnlyArray, 32, portMPU_REGION_READ_ONLY },\r
- { cPrivilegedOnlyAccessArray, 128, portMPU_REGION_PRIVILEGED_READ_WRITE }\r
+ { cReadWriteArray, 32, portMPU_REGION_READ_WRITE },\r
+ { cReadOnlyArray, 32, portMPU_REGION_READ_ONLY },\r
+ { cPrivilegedOnlyAccessArray, 128, portMPU_REGION_PRIVILEGED_READ_WRITE }\r
}\r
\r
&xTaskBuffer; // Holds the task's data structure.\r
* task will leave the Blocked state, and return from whichever function call\r
* placed the task into the Blocked state.\r
*\r
+ * There is no 'FromISR' version of this function as an interrupt would need to\r
+ * know which object a task was blocked on in order to know which actions to\r
+ * take. For example, if the task was blocked on a queue the interrupt handler\r
+ * would then need to know if the queue was locked.\r
+ *\r
* @param xTask The handle of the task to remove from the Blocked state.\r
*\r
* @return If the task referenced by xTask was not in the Blocked state then\r
*/\r
BaseType_t xTaskNotifyStateClear( TaskHandle_t xTask );\r
\r
+/**\r
+* task. h\r
+* <PRE>uint32_t ulTaskNotifyValueClear( TaskHandle_t xTask, uint32_t ulBitsToClear );</pre>\r
+*\r
+* Clears the bits specified by the ulBitsToClear bit mask in the notification\r
+* value of the task referenced by xTask.\r
+*\r
+* Set ulBitsToClear to 0xffffffff (UINT_MAX on 32-bit architectures) to clear\r
+* the notification value to 0. Set ulBitsToClear to 0 to query the task's\r
+* notification value without clearing any bits.\r
+*\r
+* @return The value of the target task's notification value before the bits\r
+* specified by ulBitsToClear were cleared.\r
+* \defgroup ulTaskNotifyValueClear ulTaskNotifyValueClear\r
+* \ingroup TaskNotifications\r
+*/\r
+uint32_t ulTaskNotifyValueClear( TaskHandle_t xTask, uint32_t ulBitsToClear ) PRIVILEGED_FUNCTION;\r
+\r
+/**\r
+ * task.h\r
+ * <pre>void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut )</pre>\r
+ *\r
+ * Capture the current time for future use with xTaskCheckForTimeOut().\r
+ *\r
+ * @param pxTimeOut Pointer to a timeout object into which the current time\r
+ * is to be captured. The captured time includes the tick count and the number\r
+ * of times the tick count has overflowed since the system first booted.\r
+ * \defgroup vTaskSetTimeOutState vTaskSetTimeOutState\r
+ * \ingroup TaskCtrl\r
+ */\r
+void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) PRIVILEGED_FUNCTION;\r
+\r
+/**\r
+ * task.h\r
+ * <pre>BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait );</pre>\r
+ *\r
+ * Determines if pxTicksToWait ticks has passed since a time was captured\r
+ * using a call to vTaskSetTimeOutState(). The captured time includes the tick\r
+ * count and the number of times the tick count has overflowed.\r
+ *\r
+ * @param pxTimeOut The time status as captured previously using\r
+ * vTaskSetTimeOutState. If the timeout has not yet occurred, it is updated\r
+ * to reflect the current time status.\r
+ * @param pxTicksToWait The number of ticks to check for timeout i.e. if\r
+ * pxTicksToWait ticks have passed since pxTimeOut was last updated (either by\r
+ * vTaskSetTimeOutState() or xTaskCheckForTimeOut()), the timeout has occurred.\r
+ * If the timeout has not occurred, pxTIcksToWait is updated to reflect the\r
+ * number of remaining ticks.\r
+ *\r
+ * @return If timeout has occurred, pdTRUE is returned. Otherwise pdFALSE is\r
+ * returned and pxTicksToWait is updated to reflect the number of remaining\r
+ * ticks.\r
+ *\r
+ * @see https://www.freertos.org/xTaskCheckForTimeOut.html\r
+ *\r
+ * Example Usage:\r
+ * <pre>\r
+ // Driver library function used to receive uxWantedBytes from an Rx buffer\r
+ // that is filled by a UART interrupt. If there are not enough bytes in the\r
+ // Rx buffer then the task enters the Blocked state until it is notified that\r
+ // more data has been placed into the buffer. If there is still not enough\r
+ // data then the task re-enters the Blocked state, and xTaskCheckForTimeOut()\r
+ // is used to re-calculate the Block time to ensure the total amount of time\r
+ // spent in the Blocked state does not exceed MAX_TIME_TO_WAIT. This\r
+ // continues until either the buffer contains at least uxWantedBytes bytes,\r
+ // or the total amount of time spent in the Blocked state reaches\r
+ // MAX_TIME_TO_WAIT – at which point the task reads however many bytes are\r
+ // available up to a maximum of uxWantedBytes.\r
+\r
+ size_t xUART_Receive( uint8_t *pucBuffer, size_t uxWantedBytes )\r
+ {\r
+ size_t uxReceived = 0;\r
+ TickType_t xTicksToWait = MAX_TIME_TO_WAIT;\r
+ TimeOut_t xTimeOut;\r
+\r
+ // Initialize xTimeOut. This records the time at which this function\r
+ // was entered.\r
+ vTaskSetTimeOutState( &xTimeOut );\r
+\r
+ // Loop until the buffer contains the wanted number of bytes, or a\r
+ // timeout occurs.\r
+ while( UART_bytes_in_rx_buffer( pxUARTInstance ) < uxWantedBytes )\r
+ {\r
+ // The buffer didn't contain enough data so this task is going to\r
+ // enter the Blocked state. Adjusting xTicksToWait to account for\r
+ // any time that has been spent in the Blocked state within this\r
+ // function so far to ensure the total amount of time spent in the\r
+ // Blocked state does not exceed MAX_TIME_TO_WAIT.\r
+ if( xTaskCheckForTimeOut( &xTimeOut, &xTicksToWait ) != pdFALSE )\r
+ {\r
+ //Timed out before the wanted number of bytes were available,\r
+ // exit the loop.\r
+ break;\r
+ }\r
+\r
+ // Wait for a maximum of xTicksToWait ticks to be notified that the\r
+ // receive interrupt has placed more data into the buffer.\r
+ ulTaskNotifyTake( pdTRUE, xTicksToWait );\r
+ }\r
+\r
+ // Attempt to read uxWantedBytes from the receive buffer into pucBuffer.\r
+ // The actual number of bytes read (which might be less than\r
+ // uxWantedBytes) is returned.\r
+ uxReceived = UART_read_from_receive_buffer( pxUARTInstance,\r
+ pucBuffer,\r
+ uxWantedBytes );\r
+\r
+ return uxReceived;\r
+ }\r
+ </pre>\r
+ * \defgroup xTaskCheckForTimeOut xTaskCheckForTimeOut\r
+ * \ingroup TaskCtrl\r
+ */\r
+BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait ) PRIVILEGED_FUNCTION;\r
+\r
/*-----------------------------------------------------------\r
* SCHEDULER INTERNALS AVAILABLE FOR PORTING PURPOSES\r
*----------------------------------------------------------*/\r
*/\r
TaskHandle_t xTaskGetCurrentTaskHandle( void ) PRIVILEGED_FUNCTION;\r
\r
-/*\r
- * Capture the current time status for future reference.\r
- */\r
-void vTaskSetTimeOutState( TimeOut_t * const pxTimeOut ) PRIVILEGED_FUNCTION;\r
-\r
-/*\r
- * Compare the time status now with that previously captured to see if the\r
- * timeout has expired.\r
- */\r
-BaseType_t xTaskCheckForTimeOut( TimeOut_t * const pxTimeOut, TickType_t * const pxTicksToWait ) PRIVILEGED_FUNCTION;\r
-\r
/*\r
* Shortcut used by the queue implementation to prevent unnecessary call to\r
* taskYIELD();\r
projects / freertos / blobdiff