Ensure both one-shot and auto-reload are written consistently with a hyphen in comments.

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

diff --git a/FreeRTOS/Demo/CORTEX_A2F200_IAR_and_Keil/main-blinky.c b/FreeRTOS/Demo/CORTEX_A2F200_IAR_and_Keil/main-blinky.c
index 051959b2eb6ae8a9a05eca0332e4f665ece69555..e0194876ec188aa0ddfd415e40ce8dd4d2224e05 100644 (file)
--- a/FreeRTOS/Demo/CORTEX_A2F200_IAR_and_Keil/main-blinky.c
+++ b/FreeRTOS/Demo/CORTEX_A2F200_IAR_and_Keil/main-blinky.c
@@ -158,7 +158,7 @@ int main(void)
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                                     /* A text name, purely to help debugging. */\r
                                                                        ( 5000 / portTICK_PERIOD_MS ),  /* The timer period, in this case 5000ms (5s). */\r
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                                     /* A text name, purely to help debugging. */\r
                                                                        ( 5000 / portTICK_PERIOD_MS ),  /* The timer period, in this case 5000ms (5s). */\r

-                                                                       pdFALSE,                                                /* This is a one shot timer, so xAutoReload is set to pdFALSE. */\r
+                                                                       pdFALSE,                                                /* This is a one-shot timer, so xAutoReload is set to pdFALSE. */\r

                                                                        ( void * ) 0,                                   /* The ID is not used, so can be set to anything. */\r
                                                                        vLEDTimerCallback                               /* The callback function that switches the LED off. */\r
                                                                );\r
                                                                        ( void * ) 0,                                   /* The ID is not used, so can be set to anything. */\r
                                                                        vLEDTimerCallback                               /* The callback function that switches the LED off. */\r
                                                                );\r

diff --git a/FreeRTOS/Demo/CORTEX_A2F200_IAR_and_Keil/main-full.c b/FreeRTOS/Demo/CORTEX_A2F200_IAR_and_Keil/main-full.c
index d0ec5d6f708e5fb13f4a313829b8c572002dcbd0..248e1355e11ebc6a1ad21c700c6802fc46c01616 100644 (file)
--- a/FreeRTOS/Demo/CORTEX_A2F200_IAR_and_Keil/main-full.c
+++ b/FreeRTOS/Demo/CORTEX_A2F200_IAR_and_Keil/main-full.c
@@ -273,7 +273,7 @@ int main(void)
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                                     /* A text name, purely to help debugging. */\r
                                                                        ( mainLED_TIMER_PERIOD_MS ),    /* The timer period, in this case 5000ms (5s). */\r
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                                     /* A text name, purely to help debugging. */\r
                                                                        ( mainLED_TIMER_PERIOD_MS ),    /* The timer period, in this case 5000ms (5s). */\r

-                                                                       pdFALSE,                                                /* This is a one shot timer, so xAutoReload is set to pdFALSE. */\r
+                                                                       pdFALSE,                                                /* This is a one-shot timer, so xAutoReload is set to pdFALSE. */\r

                                                                        ( void * ) 0,                                   /* The ID is not used, so can be set to anything. */\r
                                                                        prvLEDTimerCallback                             /* The callback function that switches the LED off. */\r
                                                                );\r
                                                                        ( void * ) 0,                                   /* The ID is not used, so can be set to anything. */\r
                                                                        prvLEDTimerCallback                             /* The callback function that switches the LED off. */\r
                                                                );\r

diff --git a/FreeRTOS/Demo/CORTEX_A2F200_SoftConsole/main-blinky.c b/FreeRTOS/Demo/CORTEX_A2F200_SoftConsole/main-blinky.c
index 9eec2bcdc0d4f10d713c92932f53a0ce46515ad4..5e4ca97f2e86ca82de1f7769c8c521c8b6db1d32 100644 (file)
--- a/FreeRTOS/Demo/CORTEX_A2F200_SoftConsole/main-blinky.c
+++ b/FreeRTOS/Demo/CORTEX_A2F200_SoftConsole/main-blinky.c
@@ -158,7 +158,7 @@ int main(void)
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                             /* A text name, purely to help debugging. */\r
                                                                        ( 5000 / portTICK_PERIOD_MS ),/* The timer period, in this case 5000ms (5s). */\r
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                             /* A text name, purely to help debugging. */\r
                                                                        ( 5000 / portTICK_PERIOD_MS ),/* The timer period, in this case 5000ms (5s). */\r

-                                                                       pdFALSE,                                        /* This is a one shot timer, so xAutoReload is set to pdFALSE. */\r
+                                                                       pdFALSE,                                        /* This is a one-shot timer, so xAutoReload is set to pdFALSE. */\r

                                                                        ( void * ) 0,                           /* The ID is not used, so can be set to anything. */\r
                                                                        vLEDTimerCallback                       /* The callback function that switches the LED off. */\r
                                                                );\r
                                                                        ( void * ) 0,                           /* The ID is not used, so can be set to anything. */\r
                                                                        vLEDTimerCallback                       /* The callback function that switches the LED off. */\r
                                                                );\r

diff --git a/FreeRTOS/Demo/CORTEX_A2F200_SoftConsole/main-full.c b/FreeRTOS/Demo/CORTEX_A2F200_SoftConsole/main-full.c
index 0e3056b21d56fe10a01f5b48b0a8cf172a1cedee..716fd8f3896537e3f9640eb0dc6df74c4d05ac0f 100644 (file)
--- a/FreeRTOS/Demo/CORTEX_A2F200_SoftConsole/main-full.c
+++ b/FreeRTOS/Demo/CORTEX_A2F200_SoftConsole/main-full.c
@@ -273,7 +273,7 @@ int main(void)
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                                     /* A text name, purely to help debugging. */\r
                                                                        ( mainLED_TIMER_PERIOD_MS ),    /* The timer period, in this case 5000ms (5s). */\r
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                                     /* A text name, purely to help debugging. */\r
                                                                        ( mainLED_TIMER_PERIOD_MS ),    /* The timer period, in this case 5000ms (5s). */\r

-                                                                       pdFALSE,                                                /* This is a one shot timer, so xAutoReload is set to pdFALSE. */\r
+                                                                       pdFALSE,                                                /* This is a one-shot timer, so xAutoReload is set to pdFALSE. */\r

                                                                        ( void * ) 0,                                   /* The ID is not used, so can be set to anything. */\r
                                                                        prvLEDTimerCallback                             /* The callback function that switches the LED off. */\r
                                                                );\r
                                                                        ( void * ) 0,                                   /* The ID is not used, so can be set to anything. */\r
                                                                        prvLEDTimerCallback                             /* The callback function that switches the LED off. */\r
                                                                );\r

diff --git a/FreeRTOS/Demo/CORTEX_Kinetis_K60_Tower_IAR/main-full.c b/FreeRTOS/Demo/CORTEX_Kinetis_K60_Tower_IAR/main-full.c
index 6fc5b4d8a20f60b8ca66159b4de523260805068e..366db237de6380c6071a542b1841ace857fd2017 100644 (file)
--- a/FreeRTOS/Demo/CORTEX_Kinetis_K60_Tower_IAR/main-full.c
+++ b/FreeRTOS/Demo/CORTEX_Kinetis_K60_Tower_IAR/main-full.c
@@ -452,7 +452,7 @@ static void prvCreateDemoSpecificTimers( void )
        this file. */\r
        xLEDButtonTimer = xTimerCreate( "ButtonLEDTimer",                                       /* A text name, purely to help debugging. */\r
                                                                        ( mainBUTTON_LED_TIMER_PERIOD_MS ),     /* The timer period, in this case 5000ms (5s). */\r
        this file. */\r
        xLEDButtonTimer = xTimerCreate( "ButtonLEDTimer",                                       /* A text name, purely to help debugging. */\r
                                                                        ( mainBUTTON_LED_TIMER_PERIOD_MS ),     /* The timer period, in this case 5000ms (5s). */\r

-                                                                       pdFALSE,                                                        /* This is a one shot timer, so xAutoReload is set to pdFALSE. */\r
+                                                                       pdFALSE,                                                        /* This is a one-shot timer, so xAutoReload is set to pdFALSE. */\r

                                                                        ( void * ) 0,                                           /* The ID is not used, so can be set to anything. */\r
                                                                        prvButtonLEDTimerCallback                       /* The callback function that switches the LED off. */\r
                                                        );\r
                                                                        ( void * ) 0,                                           /* The ID is not used, so can be set to anything. */\r
                                                                        prvButtonLEDTimerCallback                       /* The callback function that switches the LED off. */\r
                                                        );\r

diff --git a/FreeRTOS/Demo/CORTEX_Kinetis_K60_Tower_IAR/main_blinky.c b/FreeRTOS/Demo/CORTEX_Kinetis_K60_Tower_IAR/main_blinky.c
index c53db911053823f5882f25a291749604d55bf482..4493b0e5881cd55cdd65bd99a892b1a894d9007a 100644 (file)
--- a/FreeRTOS/Demo/CORTEX_Kinetis_K60_Tower_IAR/main_blinky.c
+++ b/FreeRTOS/Demo/CORTEX_Kinetis_K60_Tower_IAR/main_blinky.c
@@ -166,7 +166,7 @@ void main( void )
                this file. */\r
                xButtonLEDTimer = xTimerCreate( "ButtonLEDTimer",                       /* A text name, purely to help debugging. */\r
                                                                        mainBUTTON_LED_TIMER_PERIOD_MS, /* The timer period, in this case 5000ms (5s). */\r
                this file. */\r
                xButtonLEDTimer = xTimerCreate( "ButtonLEDTimer",                       /* A text name, purely to help debugging. */\r
                                                                        mainBUTTON_LED_TIMER_PERIOD_MS, /* The timer period, in this case 5000ms (5s). */\r

-                                                                       pdFALSE,                                                /* This is a one shot timer, so xAutoReload is set to pdFALSE. */\r
+                                                                       pdFALSE,                                                /* This is a one-shot timer, so xAutoReload is set to pdFALSE. */\r

                                                                        ( void * ) 0,                                   /* The ID is not used, so can be set to anything. */\r
                                                                        prvButtonLEDTimerCallback               /* The callback function that switches the LED off. */\r
                                                                );\r
                                                                        ( void * ) 0,                                   /* The ID is not used, so can be set to anything. */\r
                                                                        prvButtonLEDTimerCallback               /* The callback function that switches the LED off. */\r
                                                                );\r

diff --git a/FreeRTOS/Demo/CORTEX_MB9A310_IAR_Keil/main-full.c b/FreeRTOS/Demo/CORTEX_MB9A310_IAR_Keil/main-full.c
index 93ca7f563e18009b2490800d53a0b7cb5504e3b3..bde9d9add8c272ffc180b6119940941fb659597c 100644 (file)
--- a/FreeRTOS/Demo/CORTEX_MB9A310_IAR_Keil/main-full.c
+++ b/FreeRTOS/Demo/CORTEX_MB9A310_IAR_Keil/main-full.c
@@ -287,7 +287,7 @@ int main(void)
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                             /* A text name, purely to help debugging. */\r
                                                                        ( mainLED_TIMER_PERIOD_MS ),/* The timer period, in this case 5000ms (5s). */\r
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                             /* A text name, purely to help debugging. */\r
                                                                        ( mainLED_TIMER_PERIOD_MS ),/* The timer period, in this case 5000ms (5s). */\r

-                                                                       pdFALSE,                                        /* This is a one shot timer, so xAutoReload is set to pdFALSE. */\r
+                                                                       pdFALSE,                                        /* This is a one-shot timer, so xAutoReload is set to pdFALSE. */\r

                                                                        ( void * ) 0,                           /* The ID is not used, so can be set to anything. */\r
                                                                        prvLEDTimerCallback                     /* The callback function that switches the LED off. */\r
                                                                );\r
                                                                        ( void * ) 0,                           /* The ID is not used, so can be set to anything. */\r
                                                                        prvLEDTimerCallback                     /* The callback function that switches the LED off. */\r
                                                                );\r

diff --git a/FreeRTOS/Demo/CORTEX_MB9A310_IAR_Keil/main_blinky.c b/FreeRTOS/Demo/CORTEX_MB9A310_IAR_Keil/main_blinky.c
index e9065497f392531ca48f99b1b464ba47c1cff337..aaf9baa4e2eba943eeaf6a61f0ffc6443ea24d55 100644 (file)
--- a/FreeRTOS/Demo/CORTEX_MB9A310_IAR_Keil/main_blinky.c
+++ b/FreeRTOS/Demo/CORTEX_MB9A310_IAR_Keil/main_blinky.c
@@ -153,7 +153,7 @@ int main(void)
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                                     /* A text name, purely to help debugging. */\r
                                                                        ( 5000 / portTICK_PERIOD_MS ),  /* The timer period, in this case 5000ms (5s). */\r
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                                     /* A text name, purely to help debugging. */\r
                                                                        ( 5000 / portTICK_PERIOD_MS ),  /* The timer period, in this case 5000ms (5s). */\r

-                                                                       pdFALSE,                                                /* This is a one shot timer, so xAutoReload is set to pdFALSE. */\r
+                                                                       pdFALSE,                                                /* This is a one-shot timer, so xAutoReload is set to pdFALSE. */\r

                                                                        ( void * ) 0,                                   /* The ID is not used, so can be set to anything. */\r
                                                                        vLEDTimerCallback                               /* The callback function that switches the LED off. */\r
                                                                );\r
                                                                        ( void * ) 0,                                   /* The ID is not used, so can be set to anything. */\r
                                                                        vLEDTimerCallback                               /* The callback function that switches the LED off. */\r
                                                                );\r

diff --git a/FreeRTOS/Demo/CORTEX_MB9B500_IAR_Keil/main-full.c b/FreeRTOS/Demo/CORTEX_MB9B500_IAR_Keil/main-full.c
index 654c8363fe6358b259851c1c7313acaf5da7bc6b..4931e088c2f66d558172748b6617e17310fd73b1 100644 (file)
--- a/FreeRTOS/Demo/CORTEX_MB9B500_IAR_Keil/main-full.c
+++ b/FreeRTOS/Demo/CORTEX_MB9B500_IAR_Keil/main-full.c
@@ -288,7 +288,7 @@ int main(void)
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                             /* A text name, purely to help debugging. */\r
                                                                        ( mainLED_TIMER_PERIOD_MS ),/* The timer period, in this case 5000ms (5s). */\r
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                             /* A text name, purely to help debugging. */\r
                                                                        ( mainLED_TIMER_PERIOD_MS ),/* The timer period, in this case 5000ms (5s). */\r

-                                                                       pdFALSE,                                        /* This is a one shot timer, so xAutoReload is set to pdFALSE. */\r
+                                                                       pdFALSE,                                        /* This is a one-shot timer, so xAutoReload is set to pdFALSE. */\r

                                                                        ( void * ) 0,                           /* The ID is not used, so can be set to anything. */\r
                                                                        prvLEDTimerCallback                     /* The callback function that switches the LED off. */\r
                                                                );\r
                                                                        ( void * ) 0,                           /* The ID is not used, so can be set to anything. */\r
                                                                        prvLEDTimerCallback                     /* The callback function that switches the LED off. */\r
                                                                );\r

diff --git a/FreeRTOS/Demo/CORTEX_MB9B500_IAR_Keil/main_blinky.c b/FreeRTOS/Demo/CORTEX_MB9B500_IAR_Keil/main_blinky.c
index 4401c541897627681f2a2c209a4a0deb71816e4c..28b737760ef71281aaf78a59f79f2f0245797993 100644 (file)
--- a/FreeRTOS/Demo/CORTEX_MB9B500_IAR_Keil/main_blinky.c
+++ b/FreeRTOS/Demo/CORTEX_MB9B500_IAR_Keil/main_blinky.c
@@ -154,7 +154,7 @@ int main(void)
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                             /* A text name, purely to help debugging. */\r
                                                                        ( 5000 / portTICK_PERIOD_MS ),/* The timer period, in this case 5000ms (5s). */\r
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                             /* A text name, purely to help debugging. */\r
                                                                        ( 5000 / portTICK_PERIOD_MS ),/* The timer period, in this case 5000ms (5s). */\r

-                                                                       pdFALSE,                                        /* This is a one shot timer, so xAutoReload is set to pdFALSE. */\r
+                                                                       pdFALSE,                                        /* This is a one-shot timer, so xAutoReload is set to pdFALSE. */\r

                                                                        ( void * ) 0,                           /* The ID is not used, so can be set to anything. */\r
                                                                        vLEDTimerCallback                       /* The callback function that switches the LED off. */\r
                                                                );\r
                                                                        ( void * ) 0,                           /* The ID is not used, so can be set to anything. */\r
                                                                        vLEDTimerCallback                       /* The callback function that switches the LED off. */\r
                                                                );\r

diff --git a/FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC/main.c b/FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC/main.c
index 5834633ff0ac91d5b61120fce1f4549e570811e2..185ac7ba7069c4a171adbca7c17b914d63ab14b3 100644 (file)
--- a/FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC/main.c
+++ b/FreeRTOS/Demo/CORTEX_MPU_Simulator_Keil_GCC/main.c
@@ -812,7 +812,7 @@ uint32_t ulValueForTesting = 0;
 \r
        xTimer = xTimerCreate(  pcTimerName,\r
                                                        x3ms,\r
 \r
        xTimer = xTimerCreate(  pcTimerName,\r
                                                        x3ms,\r

-                                                       pdFALSE, /* Created as a one shot timer. */\r
+                                                       pdFALSE, /* Created as a one-shot timer. */\r

                                                        0,\r
                                                        prvTestTimerCallback );\r
        configASSERT( xTimer );\r
                                                        0,\r
                                                        prvTestTimerCallback );\r
        configASSERT( xTimer );\r


@@ -827,7 +827,7 @@ uint32_t ulValueForTesting = 0;
        vTaskDelay( x3ms );\r
        configASSERT( ulValueForTesting == 1 );\r
 \r
        vTaskDelay( x3ms );\r
        configASSERT( ulValueForTesting == 1 );\r
 \r

-       /* Timer was created as a one shot timer.  Its callback just increments the\r
+       /* Timer was created as a one-shot timer.  Its callback just increments the\r

        timer's ID - so set the ID to 0, let the timer run for a number of timeout\r
        periods, then check the timer has only executed once. */\r
        vTimerSetTimerID( xTimer, ( void * ) 0 );\r
        timer's ID - so set the ID to 0, let the timer run for a number of timeout\r
        periods, then check the timer has only executed once. */\r
        vTimerSetTimerID( xTimer, ( void * ) 0 );\r


@@ -835,7 +835,7 @@ uint32_t ulValueForTesting = 0;
        vTaskDelay( 3UL * x3ms );\r
        configASSERT( ( ( uint32_t ) ( pvTimerGetTimerID( xTimer ) ) ) == 1UL );\r
 \r
        vTaskDelay( 3UL * x3ms );\r
        configASSERT( ( ( uint32_t ) ( pvTimerGetTimerID( xTimer ) ) ) == 1UL );\r
 \r

-       /* Now change the timer to be an autoreload timer and check it executes\r
+       /* Now change the timer to be an auto-reload timer and check it executes\r

        the expected number of times. */\r
        vTimerSetReloadMode( xTimer, pdTRUE );\r
        xTimerStart( xTimer, 0 );\r
        the expected number of times. */\r
        vTimerSetReloadMode( xTimer, pdTRUE );\r
        xTimerStart( xTimer, 0 );\r

diff --git a/FreeRTOS/Demo/CORTEX_STM32F100_Atollic/Simple_Demo_Source/main.c b/FreeRTOS/Demo/CORTEX_STM32F100_Atollic/Simple_Demo_Source/main.c
index 99d9afa0e3a7cde7812da882e0f74b235fecba9f..1b434fa6d3f89ec15265248585e66b60510950dd 100644 (file)
--- a/FreeRTOS/Demo/CORTEX_STM32F100_Atollic/Simple_Demo_Source/main.c
+++ b/FreeRTOS/Demo/CORTEX_STM32F100_Atollic/Simple_Demo_Source/main.c
@@ -151,7 +151,7 @@ int main(void)
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                             /* A text name, purely to help debugging. */\r
                                                                        ( 5000 / portTICK_PERIOD_MS ),/* The timer period, in this case 5000ms (5s). */\r
                this file. */\r
                xLEDTimer = xTimerCreate(       "LEDTimer",                             /* A text name, purely to help debugging. */\r
                                                                        ( 5000 / portTICK_PERIOD_MS ),/* The timer period, in this case 5000ms (5s). */\r

-                                                                       pdFALSE,                                        /* This is a one shot timer, so xAutoReload is set to pdFALSE. */\r
+                                                                       pdFALSE,                                        /* This is a one-shot timer, so xAutoReload is set to pdFALSE. */\r

                                                                        ( void * ) 0,                           /* The ID is not used, so can be set to anything. */\r
                                                                        vLEDTimerCallback                       /* The callback function that switches the LED off. */\r
                                                                );\r
                                                                        ( void * ) 0,                           /* The ID is not used, so can be set to anything. */\r
                                                                        vLEDTimerCallback                       /* The callback function that switches the LED off. */\r
                                                                );\r

diff --git a/FreeRTOS/Demo/Common/Minimal/TimerDemo.c b/FreeRTOS/Demo/Common/Minimal/TimerDemo.c
index 584b63f2c6cd14576737be698220e783f2ac562d..29478819a141747086bcda190d780a01faffdc02 100644 (file)
--- a/FreeRTOS/Demo/Common/Minimal/TimerDemo.c
+++ b/FreeRTOS/Demo/Common/Minimal/TimerDemo.c
@@ -70,7 +70,7 @@ static void prvISRAutoReloadTimerCallback( TimerHandle_t pxExpiredTimer );
 static void prvISROneShotTimerCallback( TimerHandle_t pxExpiredTimer );\r
 \r
 /* The test functions used by the timer test task.  These manipulate the auto\r
 static void prvISROneShotTimerCallback( TimerHandle_t pxExpiredTimer );\r
 \r
 /* The test functions used by the timer test task.  These manipulate the auto\r

-reload and one shot timers in various ways, then delay, then inspect the timers\r
+reload and one-shot timers in various ways, then delay, then inspect the timers\r

 to ensure they have behaved as expected. */\r
 static void prvTest1_CreateTimersWithoutSchedulerRunning( void );\r
 static void prvTest2_CheckTaskAndTimersInitialState( void );\r
 to ensure they have behaved as expected. */\r
 static void prvTest1_CreateTimersWithoutSchedulerRunning( void );\r
 static void prvTest2_CheckTaskAndTimersInitialState( void );\r


@@ -90,14 +90,14 @@ static volatile BaseType_t xTestStatus = pdPASS;
 detect a stalled task - a test that is no longer running. */\r
 static volatile uint32_t ulLoopCounter = 0;\r
 \r
 detect a stalled task - a test that is no longer running. */\r
 static volatile uint32_t ulLoopCounter = 0;\r
 \r

-/* A set of auto reload timers - each of which use the same callback function.\r
+/* A set of auto-reload timers - each of which use the same callback function.\r

 The callback function uses the timer ID to index into, and then increment, a\r
 The callback function uses the timer ID to index into, and then increment, a\r

-counter in the ucAutoReloadTimerCounters[] array.  The auto reload timers\r
+counter in the ucAutoReloadTimerCounters[] array.  The auto-reload timers\r

 referenced from xAutoReloadTimers[] are used by the prvTimerTestTask task. */\r
 static TimerHandle_t xAutoReloadTimers[ configTIMER_QUEUE_LENGTH + 1 ] = { 0 };\r
 static uint8_t ucAutoReloadTimerCounters[ configTIMER_QUEUE_LENGTH + 1 ] = { 0 };\r
 \r
 referenced from xAutoReloadTimers[] are used by the prvTimerTestTask task. */\r
 static TimerHandle_t xAutoReloadTimers[ configTIMER_QUEUE_LENGTH + 1 ] = { 0 };\r
 static uint8_t ucAutoReloadTimerCounters[ configTIMER_QUEUE_LENGTH + 1 ] = { 0 };\r
 \r

-/* The one shot timer is configured to use a callback function that increments\r
+/* The one-shot timer is configured to use a callback function that increments\r

 ucOneShotTimerCounter each time it gets called. */\r
 static TimerHandle_t xOneShotTimer = NULL;\r
 static uint8_t ucOneShotTimerCounter = ( uint8_t ) 0;\r
 ucOneShotTimerCounter each time it gets called. */\r
 static TimerHandle_t xOneShotTimer = NULL;\r
 static uint8_t ucOneShotTimerCounter = ( uint8_t ) 0;\r


@@ -108,7 +108,7 @@ ucISRReloadTimerCounter each time its callback function is executed. */
 static TimerHandle_t xISRAutoReloadTimer = NULL;\r
 static uint8_t ucISRAutoReloadTimerCounter = ( uint8_t ) 0;\r
 \r
 static TimerHandle_t xISRAutoReloadTimer = NULL;\r
 static uint8_t ucISRAutoReloadTimerCounter = ( uint8_t ) 0;\r
 \r

-/* The ISR one shot timer is controlled from the tick hook to exercise the timer\r
+/* The ISR one-shot timer is controlled from the tick hook to exercise the timer\r

 API functions that can be used from an ISR.  It is configured to increment\r
 ucISRReloadTimerCounter each time its callback function is executed. */\r
 static TimerHandle_t xISROneShotTimer = NULL;\r
 API functions that can be used from an ISR.  It is configured to increment\r
 ucISRReloadTimerCounter each time its callback function is executed. */\r
 static TimerHandle_t xISROneShotTimer = NULL;\r


@@ -150,10 +150,11 @@ static void prvTimerTestTask( void *pvParameters )
 {\r
        ( void ) pvParameters;\r
 \r
 {\r
        ( void ) pvParameters;\r
 \r

-       /* Create a one-shot timer for use later on in this test. */\r
+       /* Create a one-shot timer for use later on in this test.  For test purposes it\r
+       is created as an auto-reload timer then converted to a one-shot timer. */\r

        xOneShotTimer = xTimerCreate(   "Oneshot Timer",                                /* Text name to facilitate debugging.  The kernel does not use this itself. */\r
                                                                        tmrdemoONE_SHOT_TIMER_PERIOD,   /* The period for the timer. */\r
        xOneShotTimer = xTimerCreate(   "Oneshot Timer",                                /* Text name to facilitate debugging.  The kernel does not use this itself. */\r
                                                                        tmrdemoONE_SHOT_TIMER_PERIOD,   /* The period for the timer. */\r

-                                                                       pdFALSE,                                                /* Don't auto-reload - hence a one shot timer. */\r
+                                                                       pdFALSE,                                                /* Autorealod is false, so created as a one-shot timer. */\r

                                                                        ( void * ) 0,                                   /* The timer identifier.  Initialise to 0, then increment each time it is called. */\r
                                                                        prvOneShotTimerCallback );              /* The callback to be called when the timer expires. */\r
 \r
                                                                        ( void * ) 0,                                   /* The timer identifier.  Initialise to 0, then increment each time it is called. */\r
                                                                        prvOneShotTimerCallback );              /* The callback to be called when the timer expires. */\r
 \r


@@ -163,6 +164,20 @@ static void prvTimerTestTask( void *pvParameters )
                configASSERT( xTestStatus );\r
        }\r
 \r
                configASSERT( xTestStatus );\r
        }\r
 \r

+       /* Purely for test coverage purposes - change and query the reload mode to\r
+       auto-reload then back to one-shot. */\r
+\r
+       /* Change timer to auto-reload. */\r
+       vTimerSetReloadMode( xOneShotTimer, pdTRUE );\r
+\r
+       /* Timer should now be auto-reload. */\r
+       configASSERT( uxTimerGetReloadMode( xOneShotTimer ) == pdTRUE );\r
+\r
+       /* Change timer to one-shot, which is what is needed for this test. */\r
+       vTimerSetReloadMode( xOneShotTimer, pdFALSE );\r
+\r
+       /* Check change to one-shot was successful. */\r
+       configASSERT( uxTimerGetReloadMode( xOneShotTimer ) == pdFALSE );\r

 \r
        /* Ensure all the timers are in their expected initial state.  This\r
        depends on the timer service task having a higher priority than this task. */\r
 \r
        /* Ensure all the timers are in their expected initial state.  This\r
        depends on the timer service task having a higher priority than this task. */\r


@@ -170,14 +185,14 @@ static void prvTimerTestTask( void *pvParameters )
 \r
        for( ;; )\r
        {\r
 \r
        for( ;; )\r
        {\r

-               /* Check the auto reload timers expire at the expected/correct rates. */\r
+               /* Check the auto-reload timers expire at the expected/correct rates. */\r

                prvTest3_CheckAutoReloadExpireRates();\r
 \r
                prvTest3_CheckAutoReloadExpireRates();\r
 \r

-               /* Check the auto reload timers can be stopped correctly, and correctly\r
+               /* Check the auto-reload timers can be stopped correctly, and correctly\r

                report their state. */\r
                prvTest4_CheckAutoReloadTimersCanBeStopped();\r
 \r
                report their state. */\r
                prvTest4_CheckAutoReloadTimersCanBeStopped();\r
 \r

-               /* Check the one shot timer only calls its callback once after it has been\r
+               /* Check the one-shot timer only calls its callback once after it has been\r

                started, and that it reports its state correctly. */\r
                prvTest5_CheckBasicOneShotTimerBehaviour();\r
 \r
                started, and that it reports its state correctly. */\r
                prvTest5_CheckBasicOneShotTimerBehaviour();\r
 \r


@@ -253,7 +268,7 @@ TickType_t xTimer;
                xAutoReloadTimers[ xTimer ] = xTimerCreate( "FR Timer",                                                 /* Text name to facilitate debugging.  The kernel does not use this itself. */\r
                                                                                                        ( ( xTimer + ( TickType_t ) 1 ) * xBasePeriod ),/* The period for the timer.  The plus 1 ensures a period of zero is not specified. */\r
                                                                                                        pdTRUE,                                                         /* Auto-reload is set to true. */\r
                xAutoReloadTimers[ xTimer ] = xTimerCreate( "FR Timer",                                                 /* Text name to facilitate debugging.  The kernel does not use this itself. */\r
                                                                                                        ( ( xTimer + ( TickType_t ) 1 ) * xBasePeriod ),/* The period for the timer.  The plus 1 ensures a period of zero is not specified. */\r
                                                                                                        pdTRUE,                                                         /* Auto-reload is set to true. */\r

-                                                                                                       ( void * ) xTimer,                                      /* An identifier for the timer as all the auto reload timers use the same callback. */\r
+                                                                                                       ( void * ) xTimer,                                      /* An identifier for the timer as all the auto-reload timers use the same callback. */\r

                                                                                                        prvAutoReloadTimerCallback );           /* The callback to be called when the timer expires. */\r
 \r
                if( xAutoReloadTimers[ xTimer ] == NULL )\r
                                                                                                        prvAutoReloadTimerCallback );           /* The callback to be called when the timer expires. */\r
 \r
                if( xAutoReloadTimers[ xTimer ] == NULL )\r


@@ -283,7 +298,7 @@ TickType_t xTimer;
        xAutoReloadTimers[ configTIMER_QUEUE_LENGTH ] = xTimerCreate( "FR Timer",                                       /* Text name to facilitate debugging.  The kernel does not use this itself. */\r
                                                                                                        ( configTIMER_QUEUE_LENGTH * xBasePeriod ),     /* The period for the timer. */\r
                                                                                                        pdTRUE,                                                                         /* Auto-reload is set to true. */\r
        xAutoReloadTimers[ configTIMER_QUEUE_LENGTH ] = xTimerCreate( "FR Timer",                                       /* Text name to facilitate debugging.  The kernel does not use this itself. */\r
                                                                                                        ( configTIMER_QUEUE_LENGTH * xBasePeriod ),     /* The period for the timer. */\r
                                                                                                        pdTRUE,                                                                         /* Auto-reload is set to true. */\r

-                                                                                                       ( void * ) xTimer,                                                      /* An identifier for the timer as all the auto reload timers use the same callback. */\r
+                                                                                                       ( void * ) xTimer,                                                      /* An identifier for the timer as all the auto-reload timers use the same callback. */\r

                                                                                                        prvAutoReloadTimerCallback );                           /* The callback executed when the timer expires. */\r
 \r
        if( xAutoReloadTimers[ configTIMER_QUEUE_LENGTH ] == NULL )\r
                                                                                                        prvAutoReloadTimerCallback );                           /* The callback executed when the timer expires. */\r
 \r
        if( xAutoReloadTimers[ configTIMER_QUEUE_LENGTH ] == NULL )\r


@@ -306,13 +321,13 @@ TickType_t xTimer;
        API functions that can be called from an ISR. */\r
        xISRAutoReloadTimer = xTimerCreate( "ISR AR",                                                   /* The text name given to the timer. */\r
                                                                                0xffff,                                                         /* The timer is not given a period yet - this will be done from the tick hook, but a period of 0 is invalid. */\r
        API functions that can be called from an ISR. */\r
        xISRAutoReloadTimer = xTimerCreate( "ISR AR",                                                   /* The text name given to the timer. */\r
                                                                                0xffff,                                                         /* The timer is not given a period yet - this will be done from the tick hook, but a period of 0 is invalid. */\r

-                                                                               pdTRUE,                                                         /* This is an auto reload timer. */\r
+                                                                               pdTRUE,                                                         /* This is an auto-reload timer. */\r

                                                                                ( void * ) NULL,                                        /* The identifier is not required. */\r
                                                                                prvISRAutoReloadTimerCallback );        /* The callback that is executed when the timer expires. */\r
 \r
        xISROneShotTimer = xTimerCreate(        "ISR OS",                                                       /* The text name given to the timer. */\r
                                                                                0xffff,                                                         /* The timer is not given a period yet - this will be done from the tick hook, but a period of 0 is invalid. */\r
                                                                                ( void * ) NULL,                                        /* The identifier is not required. */\r
                                                                                prvISRAutoReloadTimerCallback );        /* The callback that is executed when the timer expires. */\r
 \r
        xISROneShotTimer = xTimerCreate(        "ISR OS",                                                       /* The text name given to the timer. */\r
                                                                                0xffff,                                                         /* The timer is not given a period yet - this will be done from the tick hook, but a period of 0 is invalid. */\r

-                                                                               pdFALSE,                                                        /* This is a one shot timer. */\r
+                                                                               pdFALSE,                                                        /* This is a one-shot timer. */\r

                                                                                ( void * ) NULL,                                        /* The identifier is not required. */\r
                                                                                prvISROneShotTimerCallback );           /* The callback that is executed when the timer expires. */\r
 \r
                                                                                ( void * ) NULL,                                        /* The identifier is not required. */\r
                                                                                prvISROneShotTimerCallback );           /* The callback that is executed when the timer expires. */\r
 \r


@@ -331,8 +346,8 @@ uint8_t ucTimer;
        /* Ensure all the timers are in their expected initial state.  This     depends\r
        on the timer service task having a higher priority than this task.\r
 \r
        /* Ensure all the timers are in their expected initial state.  This     depends\r
        on the timer service task having a higher priority than this task.\r
 \r

-       auto reload timers 0 to ( configTIMER_QUEUE_LENGTH - 1 ) should now be active,\r
-       and auto reload timer configTIMER_QUEUE_LENGTH should not yet be active (it\r
+       auto-reload timers 0 to ( configTIMER_QUEUE_LENGTH - 1 ) should now be active,\r
+       and auto-reload timer configTIMER_QUEUE_LENGTH should not yet be active (it\r

        could not be started prior to the scheduler being started when it was\r
        created). */\r
        for( ucTimer = 0; ucTimer < ( uint8_t ) configTIMER_QUEUE_LENGTH; ucTimer++ )\r
        could not be started prior to the scheduler being started when it was\r
        created). */\r
        for( ucTimer = 0; ucTimer < ( uint8_t ) configTIMER_QUEUE_LENGTH; ucTimer++ )\r


@@ -358,18 +373,18 @@ uint8_t ucMaxAllowableValue, ucMinAllowableValue, ucTimer;
 TickType_t xBlockPeriod, xTimerPeriod, xExpectedNumber;\r
 UBaseType_t uxOriginalPriority;\r
 \r
 TickType_t xBlockPeriod, xTimerPeriod, xExpectedNumber;\r
 UBaseType_t uxOriginalPriority;\r
 \r

-       /* Check the auto reload timers expire at the expected rates.  Do this at a\r
+       /* Check the auto-reload timers expire at the expected rates.  Do this at a\r

        high priority for maximum accuracy.  This is ok as most of the time is spent\r
        in the Blocked state. */\r
        uxOriginalPriority = uxTaskPriorityGet( NULL );\r
        vTaskPrioritySet( NULL, ( configMAX_PRIORITIES - 1 ) );\r
 \r
        /* Delaying for configTIMER_QUEUE_LENGTH * xBasePeriod ticks should allow\r
        high priority for maximum accuracy.  This is ok as most of the time is spent\r
        in the Blocked state. */\r
        uxOriginalPriority = uxTaskPriorityGet( NULL );\r
        vTaskPrioritySet( NULL, ( configMAX_PRIORITIES - 1 ) );\r
 \r
        /* Delaying for configTIMER_QUEUE_LENGTH * xBasePeriod ticks should allow\r

-       all the auto reload timers to expire at least once. */\r
+       all the auto-reload timers to expire at least once. */\r

        xBlockPeriod = ( ( TickType_t ) configTIMER_QUEUE_LENGTH ) * xBasePeriod;\r
        vTaskDelay( xBlockPeriod );\r
 \r
        xBlockPeriod = ( ( TickType_t ) configTIMER_QUEUE_LENGTH ) * xBasePeriod;\r
        vTaskDelay( xBlockPeriod );\r
 \r

-       /* Check that all the auto reload timers have called their callback\r
+       /* Check that all the auto-reload timers have called their callback\r

        function the expected number of times. */\r
        for( ucTimer = 0; ucTimer < ( uint8_t ) configTIMER_QUEUE_LENGTH; ucTimer++ )\r
        {\r
        function the expected number of times. */\r
        for( ucTimer = 0; ucTimer < ( uint8_t ) configTIMER_QUEUE_LENGTH; ucTimer++ )\r
        {\r


@@ -406,7 +421,7 @@ static void prvTest4_CheckAutoReloadTimersCanBeStopped( void )
 {\r
 uint8_t ucTimer;\r
 \r
 {\r
 uint8_t ucTimer;\r
 \r

-       /* Check the auto reload timers can be stopped correctly, and correctly\r
+       /* Check the auto-reload timers can be stopped correctly, and correctly\r

        report their state. */\r
 \r
        /* Stop all the active timers. */\r
        report their state. */\r
 \r
        /* Stop all the active timers. */\r


@@ -472,10 +487,10 @@ uint8_t ucTimer;
 \r
 static void prvTest5_CheckBasicOneShotTimerBehaviour( void )\r
 {\r
 \r
 static void prvTest5_CheckBasicOneShotTimerBehaviour( void )\r
 {\r

-       /* Check the one shot timer only calls its callback once after it has been\r
+       /* Check the one-shot timer only calls its callback once after it has been\r

        started, and that it reports its state correctly. */\r
 \r
        started, and that it reports its state correctly. */\r
 \r

-       /* The one shot timer should not be active yet. */\r
+       /* The one-shot timer should not be active yet. */\r

        if( xTimerIsTimerActive( xOneShotTimer ) != pdFALSE )\r
        {\r
                xTestStatus = pdFAIL;\r
        if( xTimerIsTimerActive( xOneShotTimer ) != pdFALSE )\r
        {\r
                xTestStatus = pdFAIL;\r


@@ -488,7 +503,7 @@ static void prvTest5_CheckBasicOneShotTimerBehaviour( void )
                configASSERT( xTestStatus );\r
        }\r
 \r
                configASSERT( xTestStatus );\r
        }\r
 \r

-       /* Start the one shot timer and check that it reports its state correctly. */\r
+       /* Start the one-shot timer and check that it reports its state correctly. */\r

        xTimerStart( xOneShotTimer, tmrdemoDONT_BLOCK );\r
        if( xTimerIsTimerActive( xOneShotTimer ) == pdFALSE )\r
        {\r
        xTimerStart( xOneShotTimer, tmrdemoDONT_BLOCK );\r
        if( xTimerIsTimerActive( xOneShotTimer ) == pdFALSE )\r
        {\r


@@ -496,7 +511,7 @@ static void prvTest5_CheckBasicOneShotTimerBehaviour( void )
                configASSERT( xTestStatus );\r
        }\r
 \r
                configASSERT( xTestStatus );\r
        }\r
 \r

-       /* Delay for three times as long as the one shot timer period, then check\r
+       /* Delay for three times as long as the one-shot timer period, then check\r

        to ensure it has only called its callback once, and is now not in the\r
        active state. */\r
        vTaskDelay( tmrdemoONE_SHOT_TIMER_PERIOD * ( TickType_t ) 3 );\r
        to ensure it has only called its callback once, and is now not in the\r
        active state. */\r
        vTaskDelay( tmrdemoONE_SHOT_TIMER_PERIOD * ( TickType_t ) 3 );\r


@@ -514,7 +529,7 @@ static void prvTest5_CheckBasicOneShotTimerBehaviour( void )
        }\r
        else\r
        {\r
        }\r
        else\r
        {\r

-               /* Reset the one shot timer callback count. */\r
+               /* Reset the one-shot timer callback count. */\r

                ucOneShotTimerCounter = ( uint8_t ) 0;\r
        }\r
 \r
                ucOneShotTimerCounter = ( uint8_t ) 0;\r
        }\r
 \r


@@ -533,7 +548,7 @@ uint8_t ucTimer;
 \r
        /* Check timer reset behaviour. */\r
 \r
 \r
        /* Check timer reset behaviour. */\r
 \r

-       /* Restart the one shot timer and check it reports its status correctly. */\r
+       /* Restart the one-shot timer and check it reports its status correctly. */\r

        xTimerStart( xOneShotTimer, tmrdemoDONT_BLOCK );\r
        if( xTimerIsTimerActive( xOneShotTimer ) == pdFALSE )\r
        {\r
        xTimerStart( xOneShotTimer, tmrdemoDONT_BLOCK );\r
        if( xTimerIsTimerActive( xOneShotTimer ) == pdFALSE )\r
        {\r


@@ -541,7 +556,7 @@ uint8_t ucTimer;
                configASSERT( xTestStatus );\r
        }\r
 \r
                configASSERT( xTestStatus );\r
        }\r
 \r

-       /* Restart one of the auto reload timers and check that it reports its\r
+       /* Restart one of the auto-reload timers and check that it reports its\r

        status correctly. */\r
        xTimerStart( xAutoReloadTimers[ configTIMER_QUEUE_LENGTH - 1 ], tmrdemoDONT_BLOCK );\r
        if( xTimerIsTimerActive( xAutoReloadTimers[ configTIMER_QUEUE_LENGTH - 1 ] ) == pdFALSE )\r
        status correctly. */\r
        xTimerStart( xAutoReloadTimers[ configTIMER_QUEUE_LENGTH - 1 ], tmrdemoDONT_BLOCK );\r
        if( xTimerIsTimerActive( xAutoReloadTimers[ configTIMER_QUEUE_LENGTH - 1 ] ) == pdFALSE )\r


@@ -552,7 +567,7 @@ uint8_t ucTimer;
 \r
        for( ucTimer = 0; ucTimer < tmrdemoNUM_TIMER_RESETS; ucTimer++ )\r
        {\r
 \r
        for( ucTimer = 0; ucTimer < tmrdemoNUM_TIMER_RESETS; ucTimer++ )\r
        {\r

-               /* Delay for half as long as the one shot timer period, then reset it.\r
+               /* Delay for half as long as the one-shot timer period, then reset it.\r

                It should never expire while this is done, so its callback count should\r
                never increment. */\r
                vTaskDelay( tmrdemoONE_SHOT_TIMER_PERIOD / 2 );\r
                It should never expire while this is done, so its callback count should\r
                never increment. */\r
                vTaskDelay( tmrdemoONE_SHOT_TIMER_PERIOD / 2 );\r


@@ -612,7 +627,7 @@ uint8_t ucTimer;
                configASSERT( xTestStatus );\r
        }\r
 \r
                configASSERT( xTestStatus );\r
        }\r
 \r

-       /* The one shot timer should no longer be active, while the auto reload\r
+       /* The one-shot timer should no longer be active, while the auto-reload\r

        timer should still be active. */\r
        if( xTimerIsTimerActive( xAutoReloadTimers[ configTIMER_QUEUE_LENGTH - 1 ] ) == pdFALSE )\r
        {\r
        timer should still be active. */\r
        if( xTimerIsTimerActive( xAutoReloadTimers[ configTIMER_QUEUE_LENGTH - 1 ] ) == pdFALSE )\r
        {\r


@@ -626,7 +641,7 @@ uint8_t ucTimer;
                configASSERT( xTestStatus );\r
        }\r
 \r
                configASSERT( xTestStatus );\r
        }\r
 \r

-       /* Stop the auto reload timer again. */\r
+       /* Stop the auto-reload timer again. */\r

        xTimerStop( xAutoReloadTimers[ configTIMER_QUEUE_LENGTH - 1 ], tmrdemoDONT_BLOCK );\r
 \r
        if( xTimerIsTimerActive( xAutoReloadTimers[ configTIMER_QUEUE_LENGTH - 1 ] ) != pdFALSE )\r
        xTimerStop( xAutoReloadTimers[ configTIMER_QUEUE_LENGTH - 1 ], tmrdemoDONT_BLOCK );\r
 \r
        if( xTimerIsTimerActive( xAutoReloadTimers[ configTIMER_QUEUE_LENGTH - 1 ] ) != pdFALSE )\r


@@ -770,8 +785,8 @@ static TickType_t uxTick = ( TickType_t ) -1;
        }\r
        else if( uxTick == ( xBasePeriod + xMargin ) )\r
        {\r
        }\r
        else if( uxTick == ( xBasePeriod + xMargin ) )\r
        {\r

-               /* Both timers should now have expired once.  The auto reload timer will\r
-               still be active, but the one shot timer should now have stopped. */\r
+               /* Both timers should now have expired once.  The auto-reload timer will\r
+               still be active, but the one-shot timer should now have stopped. */\r

                if( ( ucISRAutoReloadTimerCounter != 1 ) || ( ucISROneShotTimerCounter != 1 ) )\r
                {\r
                        xTestStatus = pdFAIL;\r
                if( ( ucISRAutoReloadTimerCounter != 1 ) || ( ucISROneShotTimerCounter != 1 ) )\r
                {\r
                        xTestStatus = pdFAIL;\r


@@ -780,7 +795,7 @@ static TickType_t uxTick = ( TickType_t ) -1;
        }\r
        else if( uxTick == ( ( 2 * xBasePeriod ) - xMargin ) )\r
        {\r
        }\r
        else if( uxTick == ( ( 2 * xBasePeriod ) - xMargin ) )\r
        {\r

-               /* The auto reload timer will still be active, but the one shot timer\r
+               /* The auto-reload timer will still be active, but the one-shot timer\r

                should now have stopped - however, at this time neither of the timers\r
                should have expired again since the last test. */\r
                if( ( ucISRAutoReloadTimerCounter != 1 ) || ( ucISROneShotTimerCounter != 1 ) )\r
                should now have stopped - however, at this time neither of the timers\r
                should have expired again since the last test. */\r
                if( ( ucISRAutoReloadTimerCounter != 1 ) || ( ucISROneShotTimerCounter != 1 ) )\r


@@ -791,9 +806,9 @@ static TickType_t uxTick = ( TickType_t ) -1;
        }\r
        else if( uxTick == ( ( 2 * xBasePeriod ) + xMargin ) )\r
        {\r
        }\r
        else if( uxTick == ( ( 2 * xBasePeriod ) + xMargin ) )\r
        {\r

-               /* The auto reload timer will still be active, but the one shot timer\r
-               should now have stopped.  At this time the auto reload timer should have\r
-               expired again, but the one shot timer count should not have changed. */\r
+               /* The auto-reload timer will still be active, but the one-shot timer\r
+               should now have stopped.  At this time the auto-reload timer should have\r
+               expired again, but the one-shot timer count should not have changed. */\r

                if( ucISRAutoReloadTimerCounter != 2 )\r
                {\r
                        xTestStatus = pdFAIL;\r
                if( ucISRAutoReloadTimerCounter != 2 )\r
                {\r
                        xTestStatus = pdFAIL;\r


@@ -808,7 +823,7 @@ static TickType_t uxTick = ( TickType_t ) -1;
        }\r
        else if( uxTick == ( ( 2 * xBasePeriod ) + ( xBasePeriod >> ( TickType_t ) 2U ) ) )\r
        {\r
        }\r
        else if( uxTick == ( ( 2 * xBasePeriod ) + ( xBasePeriod >> ( TickType_t ) 2U ) ) )\r
        {\r

-               /* The auto reload timer will still be active, but the one shot timer\r
+               /* The auto-reload timer will still be active, but the one-shot timer\r

                should now have stopped.  Again though, at this time, neither timer call\r
                back should have been called since the last test. */\r
                if( ucISRAutoReloadTimerCounter != 2 )\r
                should now have stopped.  Again though, at this time, neither timer call\r
                back should have been called since the last test. */\r
                if( ucISRAutoReloadTimerCounter != 2 )\r


@@ -825,13 +840,13 @@ static TickType_t uxTick = ( TickType_t ) -1;
        }\r
        else if( uxTick == ( 3 * xBasePeriod ) )\r
        {\r
        }\r
        else if( uxTick == ( 3 * xBasePeriod ) )\r
        {\r

-               /* Start the one shot timer again. */\r
+               /* Start the one-shot timer again. */\r

                xTimerStartFromISR( xISROneShotTimer, NULL );\r
        }\r
        else if( uxTick == ( ( 3 * xBasePeriod ) + xMargin ) )\r
        {\r
                xTimerStartFromISR( xISROneShotTimer, NULL );\r
        }\r
        else if( uxTick == ( ( 3 * xBasePeriod ) + xMargin ) )\r
        {\r

-               /* The auto reload timer and one shot timer will be active.  At\r
-               this time the auto reload timer should have     expired again, but the one\r
+               /* The auto-reload timer and one-shot timer will be active.  At\r
+               this time the auto-reload timer should have     expired again, but the one\r

                shot timer count should not have changed yet. */\r
                if( ucISRAutoReloadTimerCounter != 3 )\r
                {\r
                shot timer count should not have changed yet. */\r
                if( ucISRAutoReloadTimerCounter != 3 )\r
                {\r


@@ -845,13 +860,13 @@ static TickType_t uxTick = ( TickType_t ) -1;
                        configASSERT( xTestStatus );\r
                }\r
 \r
                        configASSERT( xTestStatus );\r
                }\r
 \r

-               /* Now stop the auto reload timer.  The one shot timer was started\r
+               /* Now stop the auto-reload timer.  The one-shot timer was started\r

                a few ticks ago. */\r
                xTimerStopFromISR( xISRAutoReloadTimer, NULL );\r
        }\r
        else if( uxTick == ( 4 * ( xBasePeriod - xMargin ) ) )\r
        {\r
                a few ticks ago. */\r
                xTimerStopFromISR( xISRAutoReloadTimer, NULL );\r
        }\r
        else if( uxTick == ( 4 * ( xBasePeriod - xMargin ) ) )\r
        {\r

-               /* The auto reload timer is now stopped, and the one shot timer is\r
+               /* The auto-reload timer is now stopped, and the one-shot timer is\r

                active, but at this time neither timer should have expired since the\r
                last test. */\r
                if( ucISRAutoReloadTimerCounter != 3 )\r
                active, but at this time neither timer should have expired since the\r
                last test. */\r
                if( ucISRAutoReloadTimerCounter != 3 )\r


@@ -868,8 +883,8 @@ static TickType_t uxTick = ( TickType_t ) -1;
        }\r
        else if( uxTick == ( ( 4 * xBasePeriod ) + xMargin ) )\r
        {\r
        }\r
        else if( uxTick == ( ( 4 * xBasePeriod ) + xMargin ) )\r
        {\r

-               /* The auto reload timer is now stopped, and the one shot timer is\r
-               active.  The one shot timer should have expired again, but the auto\r
+               /* The auto-reload timer is now stopped, and the one-shot timer is\r
+               active.  The one-shot timer should have expired again, but the auto\r

                reload timer should not have executed its callback. */\r
                if( ucISRAutoReloadTimerCounter != 3 )\r
                {\r
                reload timer should not have executed its callback. */\r
                if( ucISRAutoReloadTimerCounter != 3 )\r
                {\r


@@ -885,7 +900,7 @@ static TickType_t uxTick = ( TickType_t ) -1;
        }\r
        else if( uxTick == ( 8 * xBasePeriod ) )\r
        {\r
        }\r
        else if( uxTick == ( 8 * xBasePeriod ) )\r
        {\r

-               /* The auto reload timer is now stopped, and the one shot timer has\r
+               /* The auto-reload timer is now stopped, and the one-shot timer has\r

                already expired and then stopped itself.  Both callback counters should\r
                not have incremented since the last test. */\r
                if( ucISRAutoReloadTimerCounter != 3 )\r
                already expired and then stopped itself.  Both callback counters should\r
                not have incremented since the last test. */\r
                if( ucISRAutoReloadTimerCounter != 3 )\r


@@ -900,14 +915,14 @@ static TickType_t uxTick = ( TickType_t ) -1;
                        configASSERT( xTestStatus );\r
                }\r
 \r
                        configASSERT( xTestStatus );\r
                }\r
 \r

-               /* Now reset the one shot timer. */\r
+               /* Now reset the one-shot timer. */\r

                xTimerResetFromISR( xISROneShotTimer, NULL );\r
        }\r
        else if( uxTick == ( ( 9 * xBasePeriod ) - xMargin ) )\r
        {\r
                xTimerResetFromISR( xISROneShotTimer, NULL );\r
        }\r
        else if( uxTick == ( ( 9 * xBasePeriod ) - xMargin ) )\r
        {\r

-               /* Only the one shot timer should be running, but it should not have\r
+               /* Only the one-shot timer should be running, but it should not have\r

                expired since the last test.  Check the callback counters have not\r
                expired since the last test.  Check the callback counters have not\r

-               incremented, then reset the one shot timer again. */\r
+               incremented, then reset the one-shot timer again. */\r

                if( ucISRAutoReloadTimerCounter != 3 )\r
                {\r
                        xTestStatus = pdFAIL;\r
                if( ucISRAutoReloadTimerCounter != 3 )\r
                {\r
                        xTestStatus = pdFAIL;\r


@@ -924,9 +939,9 @@ static TickType_t uxTick = ( TickType_t ) -1;
        }\r
        else if( uxTick == ( ( 10 * xBasePeriod ) - ( 2 * xMargin ) ) )\r
        {\r
        }\r
        else if( uxTick == ( ( 10 * xBasePeriod ) - ( 2 * xMargin ) ) )\r
        {\r

-               /* Only the one shot timer should be running, but it should not have\r
+               /* Only the one-shot timer should be running, but it should not have\r

                expired since the last test.  Check the callback counters have not\r
                expired since the last test.  Check the callback counters have not\r

-               incremented, then reset the one shot timer again. */\r
+               incremented, then reset the one-shot timer again. */\r

                if( ucISRAutoReloadTimerCounter != 3 )\r
                {\r
                        xTestStatus = pdFAIL;\r
                if( ucISRAutoReloadTimerCounter != 3 )\r
                {\r
                        xTestStatus = pdFAIL;\r


@@ -943,9 +958,9 @@ static TickType_t uxTick = ( TickType_t ) -1;
        }\r
        else if( uxTick == ( ( 11 * xBasePeriod ) - ( 3 * xMargin ) ) )\r
        {\r
        }\r
        else if( uxTick == ( ( 11 * xBasePeriod ) - ( 3 * xMargin ) ) )\r
        {\r

-               /* Only the one shot timer should be running, but it should not have\r
+               /* Only the one-shot timer should be running, but it should not have\r

                expired since the last test.  Check the callback counters have not\r
                expired since the last test.  Check the callback counters have not\r

-               incremented, then reset the one shot timer once again. */\r
+               incremented, then reset the one-shot timer once again. */\r

                if( ucISRAutoReloadTimerCounter != 3 )\r
                {\r
                        xTestStatus = pdFAIL;\r
                if( ucISRAutoReloadTimerCounter != 3 )\r
                {\r
                        xTestStatus = pdFAIL;\r


@@ -962,10 +977,10 @@ static TickType_t uxTick = ( TickType_t ) -1;
        }\r
        else if( uxTick == ( ( 12 * xBasePeriod ) - ( 2 * xMargin ) ) )\r
        {\r
        }\r
        else if( uxTick == ( ( 12 * xBasePeriod ) - ( 2 * xMargin ) ) )\r
        {\r

-               /* Only the one shot timer should have been running and this time it\r
+               /* Only the one-shot timer should have been running and this time it\r

                should have     expired.  Check its callback count has been incremented.\r
                should have     expired.  Check its callback count has been incremented.\r

-               The auto reload timer is still not running so should still have the same\r
-               count value.  This time the one shot timer is not reset so should not\r
+               The auto-reload timer is still not running so should still have the same\r
+               count value.  This time the one-shot timer is not reset so should not\r

                restart from its expiry period again. */\r
                if( ucISRAutoReloadTimerCounter != 3 )\r
                {\r
                restart from its expiry period again. */\r
                if( ucISRAutoReloadTimerCounter != 3 )\r
                {\r

diff --git a/FreeRTOS/Demo/PIC32MEC14xx_MPLAB/src/Full_Demo/main_full.c b/FreeRTOS/Demo/PIC32MEC14xx_MPLAB/src/Full_Demo/main_full.c
index 13c7e21e1f9b24df52153f170bf8e7d71a8c3c7f..7c14a22a2d2f3d7af5e031835862c6add66e811b 100644 (file)
--- a/FreeRTOS/Demo/PIC32MEC14xx_MPLAB/src/Full_Demo/main_full.c
+++ b/FreeRTOS/Demo/PIC32MEC14xx_MPLAB/src/Full_Demo/main_full.c
@@ -188,7 +188,7 @@ TimerHandle_t xTimer = NULL;
 \r
        /* A software timer is also used to start the high frequency timer test.\r
        This is to ensure the test does not start before the kernel.  This time a\r
 \r
        /* A software timer is also used to start the high frequency timer test.\r
        This is to ensure the test does not start before the kernel.  This time a\r

-       one shot software timer is used. */\r
+       one-shot software timer is used. */\r

        xTimer = xTimerCreate( "HighHzTimerSetup", 1, pdFALSE, ( void * ) 0, prvSetupHighFrequencyTimerTest );\r
        if( xTimer != NULL )\r
        {\r
        xTimer = xTimerCreate( "HighHzTimerSetup", 1, pdFALSE, ( void * ) 0, prvSetupHighFrequencyTimerTest );\r
        if( xTimer != NULL )\r
        {\r


@@ -328,7 +328,7 @@ void vSetupTimerTest( unsigned short usFrequencyHz );
 \r
        /* Setup the high frequency, high priority, timer test.  It is setup in this\r
        software timer callback to ensure it does not start before the kernel does.\r
 \r
        /* Setup the high frequency, high priority, timer test.  It is setup in this\r
        software timer callback to ensure it does not start before the kernel does.\r

-       This is a one shot timer - so the setup routine will only be executed once. */\r
+       This is a one-shot timer - so the setup routine will only be executed once. */\r

 \r
        vSetupTimerTest( mainTEST_INTERRUPT_FREQUENCY );\r
 }\r
 \r
        vSetupTimerTest( mainTEST_INTERRUPT_FREQUENCY );\r
 }\r

diff --git a/FreeRTOS/Demo/PIC32MX_MPLAB/main_full.c b/FreeRTOS/Demo/PIC32MX_MPLAB/main_full.c
index 0d2aa8c89d7a9ce2b75c9b3bda5bb2049fa04f51..25ecbfc47654eeb1b6ae6901a7701b73683c0d9d 100644 (file)
--- a/FreeRTOS/Demo/PIC32MX_MPLAB/main_full.c
+++ b/FreeRTOS/Demo/PIC32MX_MPLAB/main_full.c
@@ -236,7 +236,7 @@ TimerHandle_t xTimer = NULL;
 \r
        /* A software timer is also used to start the high frequency timer test.\r
        This is to ensure the test does not start before the kernel.  This time a\r
 \r
        /* A software timer is also used to start the high frequency timer test.\r
        This is to ensure the test does not start before the kernel.  This time a\r

-       one shot software timer is used. */\r
+       one-shot software timer is used. */\r

        xTimer = xTimerCreate( "HighHzTimerSetup", 1, pdFALSE, ( void * ) 0, prvSetupHighFrequencyTimerTest );\r
        if( xTimer != NULL )\r
        {\r
        xTimer = xTimerCreate( "HighHzTimerSetup", 1, pdFALSE, ( void * ) 0, prvSetupHighFrequencyTimerTest );\r
        if( xTimer != NULL )\r
        {\r


@@ -369,7 +369,7 @@ static void prvSetupHighFrequencyTimerTest( TimerHandle_t xTimer )
 {\r
        /* Setup the high frequency, high priority, timer test.  It is setup in this\r
        software timer callback to ensure it does not start before the kernel does.\r
 {\r
        /* Setup the high frequency, high priority, timer test.  It is setup in this\r
        software timer callback to ensure it does not start before the kernel does.\r

-       This is a one shot timer - so the setup routine will only be executed once. */\r
+       This is a one-shot timer - so the setup routine will only be executed once. */\r

        vSetupTimerTest( mainTEST_INTERRUPT_FREQUENCY );\r
 }\r
 \r
        vSetupTimerTest( mainTEST_INTERRUPT_FREQUENCY );\r
 }\r
 \r

diff --git a/FreeRTOS/Demo/PIC32MZ_MPLAB/main_full.c b/FreeRTOS/Demo/PIC32MZ_MPLAB/main_full.c
index f5a4ad88e686b6d5322e4fa3e3f411c43f7e5c71..1e9c67f2d8418e7160faf76daf59ef71f395df39 100644 (file)
--- a/FreeRTOS/Demo/PIC32MZ_MPLAB/main_full.c
+++ b/FreeRTOS/Demo/PIC32MZ_MPLAB/main_full.c
@@ -229,7 +229,7 @@ TimerHandle_t xTimer = NULL;
 \r
        /* A software timer is also used to start the high frequency timer test.\r
        This is to ensure the test does not start before the kernel.  This time a\r
 \r
        /* A software timer is also used to start the high frequency timer test.\r
        This is to ensure the test does not start before the kernel.  This time a\r

-       one shot software timer is used. */\r
+       one-shot software timer is used. */\r

        xTimer = xTimerCreate( "HighHzTimerSetup", 1, pdFALSE, ( void * ) 0, prvSetupHighFrequencyTimerTest );\r
        if( xTimer != NULL )\r
        {\r
        xTimer = xTimerCreate( "HighHzTimerSetup", 1, pdFALSE, ( void * ) 0, prvSetupHighFrequencyTimerTest );\r
        if( xTimer != NULL )\r
        {\r


@@ -409,7 +409,7 @@ void vSetupTimerTest( unsigned short usFrequencyHz );
 \r
        /* Setup the high frequency, high priority, timer test.  It is setup in this\r
        software timer callback to ensure it does not start before the kernel does.\r
 \r
        /* Setup the high frequency, high priority, timer test.  It is setup in this\r
        software timer callback to ensure it does not start before the kernel does.\r

-       This is a one shot timer - so the setup routine will only be executed once. */\r
+       This is a one-shot timer - so the setup routine will only be executed once. */\r

        vSetupTimerTest( mainTEST_INTERRUPT_FREQUENCY );\r
 }\r
 /*-----------------------------------------------------------*/\r
        vSetupTimerTest( mainTEST_INTERRUPT_FREQUENCY );\r
 }\r
 /*-----------------------------------------------------------*/\r

diff --git a/FreeRTOS/Demo/WIN32-MSVC/main_blinky.c b/FreeRTOS/Demo/WIN32-MSVC/main_blinky.c
index 065561b9ee959a8ef918cdd7b01c34213097d655..e9ef5fb307bde514fb3d35644ef24aa9025c1173 100644 (file)
--- a/FreeRTOS/Demo/WIN32-MSVC/main_blinky.c
+++ b/FreeRTOS/Demo/WIN32-MSVC/main_blinky.c
@@ -156,7 +156,7 @@ const TickType_t xTimerPeriod = mainTIMER_SEND_FREQUENCY_MS;
                /* Create the software timer, but don't start it yet. */\r
                xTimer = xTimerCreate( "Timer",                         /* The text name assigned to the software timer - for debug only as it is not used by the kernel. */\r
                                                                xTimerPeriod,           /* The period of the software timer in ticks. */\r
                /* Create the software timer, but don't start it yet. */\r
                xTimer = xTimerCreate( "Timer",                         /* The text name assigned to the software timer - for debug only as it is not used by the kernel. */\r
                                                                xTimerPeriod,           /* The period of the software timer in ticks. */\r

-                                                               pdFALSE,                        /* xAutoReload is set to pdFALSE, so this is a one shot timer. */\r
+                                                               pdFALSE,                        /* xAutoReload is set to pdFALSE, so this is a one-shot timer. */\r

                                                                NULL,                           /* The timer's ID is not used. */\r
                                                                prvQueueSendTimerCallback );/* The function executed when the timer expires. */\r
 \r
                                                                NULL,                           /* The timer's ID is not used. */\r
                                                                prvQueueSendTimerCallback );/* The function executed when the timer expires. */\r
 \r

diff --git a/FreeRTOS/Demo/WIN32-MingW/main_full.c b/FreeRTOS/Demo/WIN32-MingW/main_full.c
index 84ae4074e3c7711e7400dc532527a1d3f7a82887..718c1e1b0a86edcc052fc646f43a7855cdecd2ce 100644 (file)
--- a/FreeRTOS/Demo/WIN32-MingW/main_full.c
+++ b/FreeRTOS/Demo/WIN32-MingW/main_full.c
@@ -173,7 +173,7 @@ static void prvPermanentlyBlockingNotificationTask( void *pvParameters );
 \r
 /*\r
  * The test function and callback function used when exercising the timer AP\r
 \r
 /*\r
  * The test function and callback function used when exercising the timer AP\r

- * function that changes the timer's autoreload mode.\r
+ * function that changes the timer's auto-reload mode.\r

  */\r
 static void prvDemonstrateChangingTimerReloadMode( void *pvParameters );\r
 static void prvReloadModeTestTimerCallback( TimerHandle_t xTimer );\r
  */\r
 static void prvDemonstrateChangingTimerReloadMode( void *pvParameters );\r
 static void prvReloadModeTestTimerCallback( TimerHandle_t xTimer );\r


@@ -866,7 +866,7 @@ const TickType_t x100ms = pdMS_TO_TICKS( 100UL );
 \r
        xTimer = xTimerCreate(  pcTimerName,\r
                                                        x100ms,\r
 \r
        xTimer = xTimerCreate(  pcTimerName,\r
                                                        x100ms,\r

-                                                       pdFALSE, /* Created as a one shot timer. */\r
+                                                       pdFALSE, /* Created as a one-shot timer. */\r

                                                        0,\r
                                                        prvReloadModeTestTimerCallback );\r
        configASSERT( xTimer );\r
                                                        0,\r
                                                        prvReloadModeTestTimerCallback );\r
        configASSERT( xTimer );\r


@@ -875,7 +875,7 @@ const TickType_t x100ms = pdMS_TO_TICKS( 100UL );
        configASSERT( strcmp( pcTimerName, pcTimerGetName( xTimer ) ) == 0 );\r
        configASSERT( xTimerGetPeriod( xTimer ) == x100ms );\r
 \r
        configASSERT( strcmp( pcTimerName, pcTimerGetName( xTimer ) ) == 0 );\r
        configASSERT( xTimerGetPeriod( xTimer ) == x100ms );\r
 \r

-       /* Timer was created as a one shot timer.  Its callback just increments the\r
+       /* Timer was created as a one-shot timer.  Its callback just increments the\r

        timer's ID - so set the ID to 0, let the timer run for a number of timeout\r
        periods, then check the timer has only executed once. */\r
        vTimerSetTimerID( xTimer, ( void * ) 0 );\r
        timer's ID - so set the ID to 0, let the timer run for a number of timeout\r
        periods, then check the timer has only executed once. */\r
        vTimerSetTimerID( xTimer, ( void * ) 0 );\r


@@ -883,7 +883,7 @@ const TickType_t x100ms = pdMS_TO_TICKS( 100UL );
        vTaskDelay( 3UL * x100ms );\r
        configASSERT( ( ( uint32_t ) ( pvTimerGetTimerID( xTimer ) ) ) == 1UL );\r
 \r
        vTaskDelay( 3UL * x100ms );\r
        configASSERT( ( ( uint32_t ) ( pvTimerGetTimerID( xTimer ) ) ) == 1UL );\r
 \r

-       /* Now change the timer to be an autoreload timer and check it executes\r
+       /* Now change the timer to be an auto-reload timer and check it executes\r

        the expected number of times. */\r
        vTimerSetReloadMode( xTimer, pdTRUE );\r
        vTimerSetTimerID( xTimer, ( void * ) 0 );\r
        the expected number of times. */\r
        vTimerSetReloadMode( xTimer, pdTRUE );\r
        vTimerSetTimerID( xTimer, ( void * ) 0 );\r


@@ -892,7 +892,7 @@ const TickType_t x100ms = pdMS_TO_TICKS( 100UL );
        configASSERT( ( uint32_t ) ( pvTimerGetTimerID( xTimer ) ) == 3UL );\r
        configASSERT( xTimerStop( xTimer, 0 ) != pdFAIL );\r
 \r
        configASSERT( ( uint32_t ) ( pvTimerGetTimerID( xTimer ) ) == 3UL );\r
        configASSERT( xTimerStop( xTimer, 0 ) != pdFAIL );\r
 \r

-       /* Now change the timer back to be a one shot timer and check it only\r
+       /* Now change the timer back to be a one-shot timer and check it only\r

        executes once. */\r
        vTimerSetReloadMode( xTimer, pdFALSE );\r
        vTimerSetTimerID( xTimer, ( void * ) 0 );\r
        executes once. */\r
        vTimerSetReloadMode( xTimer, pdFALSE );\r
        vTimerSetTimerID( xTimer, ( void * ) 0 );\r

diff --git a/FreeRTOS/History.txt b/FreeRTOS/History.txt
index 35080124eb8832a3888dd0ffbcbb49d3e0941cba..0c932dc9eec0a6a4028fee7d15a3261ef924a362 100644 (file)
--- a/FreeRTOS/History.txt
+++ b/FreeRTOS/History.txt
@@ -32,6 +32,12 @@ Changes since the last release:
        + Added CORTEX_MPU_STM32L4_Discovery_Keil_STM32Cube demo.\r
        + Added xTaskAbortDelayFromISR() API function.\r
        + Added xTaskNotifyValueClear() API function.\r
        + Added CORTEX_MPU_STM32L4_Discovery_Keil_STM32Cube demo.\r
        + Added xTaskAbortDelayFromISR() API function.\r
        + Added xTaskNotifyValueClear() API function.\r

+       + Improve timing accuracy (reduce clock slippage when compared to real time)\r
+         in the Windows simulator port by using a waitable timer to determine the\r
+         next time slice in place of calls to sleep().\r
+       + Added T-Head demo.\r
+       + Added LPC54018 MPU demo.\r
+       + Added uxTimerGetReloadMode() API function.\r

 \r
 \r
 Changes between FreeRTOS V10.2.1 and FreeRTOS V10.2.0 released May 13 2019:\r
 \r
 \r
 Changes between FreeRTOS V10.2.1 and FreeRTOS V10.2.0 released May 13 2019:\r

diff --git a/FreeRTOS/Source/include/timers.h b/FreeRTOS/Source/include/timers.h
index 4d77665f8e9c453de60d0a5ceb91fcdf8e5640ef..831f389ee78070f6ad597b3b27a922d799c1c916 100644 (file)
--- a/FreeRTOS/Source/include/timers.h
+++ b/FreeRTOS/Source/include/timers.h
@@ -1235,7 +1235,7 @@ const char * pcTimerGetName( TimerHandle_t xTimer ) PRIVILEGED_FUNCTION; /*lint
  * void vTimerSetReloadMode( TimerHandle_t xTimer, const UBaseType_t uxAutoReload );\r
  *\r
  * Updates a timer to be either an auto-reload timer, in which case the timer\r
  * void vTimerSetReloadMode( TimerHandle_t xTimer, const UBaseType_t uxAutoReload );\r
  *\r
  * Updates a timer to be either an auto-reload timer, in which case the timer\r

- * automatically resets itself each time it expires, or a one shot timer, in\r
+ * automatically resets itself each time it expires, or a one-shot timer, in\r

  * which case the timer will only expire once unless it is manually restarted.\r
  *\r
  * @param xTimer The handle of the timer being updated.\r
  * which case the timer will only expire once unless it is manually restarted.\r
  *\r
  * @param xTimer The handle of the timer being updated.\r


@@ -1252,7 +1252,7 @@ void vTimerSetReloadMode( TimerHandle_t xTimer, const UBaseType_t uxAutoReload )
 * UBaseType_t uxTimerGetReloadMode( TimerHandle_t xTimer );\r
 *\r
 * Queries a timer to determine if it is an auto-reload timer, in which case the timer\r
 * UBaseType_t uxTimerGetReloadMode( TimerHandle_t xTimer );\r
 *\r
 * Queries a timer to determine if it is an auto-reload timer, in which case the timer\r

-* automatically resets itself each time it expires, or a one shot timer, in\r
+* automatically resets itself each time it expires, or a one-shot timer, in\r

 * which case the timer will only expire once unless it is manually restarted.\r
 *\r
 * @param xTimer The handle of the timer being queried.\r
 * which case the timer will only expire once unless it is manually restarted.\r
 *\r
 * @param xTimer The handle of the timer being queried.\r