1248 lines
58 KiB
C
1248 lines
58 KiB
C
/*
|
|
* FreeRTOS V202212.00
|
|
* Copyright (C) 2020 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.
|
|
*
|
|
* https://www.FreeRTOS.org
|
|
* https://github.com/FreeRTOS
|
|
*
|
|
*/
|
|
|
|
/* Standard includes. */
|
|
#include "stdio.h"
|
|
#include "string.h"
|
|
|
|
/* FreeRTOS includes. */
|
|
#include "FreeRTOS.h"
|
|
#include "task.h"
|
|
#include "stream_buffer.h"
|
|
|
|
/* Demo app includes. */
|
|
#include "StreamBufferDemo.h"
|
|
|
|
/* The number of bytes of storage in the stream buffers used in this test. */
|
|
#define sbSTREAM_BUFFER_LENGTH_BYTES ( ( size_t ) 30 )
|
|
|
|
/* Stream buffer length one. */
|
|
#define sbSTREAM_BUFFER_LENGTH_ONE ( ( size_t ) 1 )
|
|
|
|
/* Start and end ASCII characters used in data sent to the buffers. */
|
|
#define sbASCII_SPACE 32
|
|
#define sbASCII_TILDA 126
|
|
|
|
/* Defines the number of tasks to create in this test and demo. */
|
|
#define sbNUMBER_OF_ECHO_CLIENTS ( 2 )
|
|
#define sbNUMBER_OF_SENDER_TASKS ( 2 )
|
|
|
|
/* Priority of the test tasks. The send and receive go from low to high
|
|
* priority tasks, and from high to low priority tasks. */
|
|
#define sbLOWER_PRIORITY ( tskIDLE_PRIORITY )
|
|
#define sbHIGHER_PRIORITY ( tskIDLE_PRIORITY + 1 )
|
|
|
|
/* Block times used when sending and receiving from the stream buffers. */
|
|
#define sbRX_TX_BLOCK_TIME pdMS_TO_TICKS( 125UL )
|
|
|
|
/* A block time of 0 means "don't block". */
|
|
#define sbDONT_BLOCK ( 0 )
|
|
|
|
/* The trigger level sets the number of bytes that must be present in the
|
|
* stream buffer before a task that is blocked on the stream buffer is moved out of
|
|
* the Blocked state so it can read the bytes. */
|
|
#define sbTRIGGER_LEVEL_1 ( 1 )
|
|
|
|
/* The size of the stack allocated to the tasks that run as part of this demo/
|
|
* test. The stack size is over generous in most cases. */
|
|
#ifndef configSTREAM_BUFFER_SENDER_TASK_STACK_SIZE
|
|
#define sbSTACK_SIZE ( configMINIMAL_STACK_SIZE + ( configMINIMAL_STACK_SIZE >> 1 ) )
|
|
#else
|
|
#define sbSTACK_SIZE configSTREAM_BUFFER_SENDER_TASK_STACK_SIZE
|
|
#endif
|
|
|
|
#ifndef configSTREAM_BUFFER_SMALLER_TASK_STACK_SIZE
|
|
#define sbSMALLER_STACK_SIZE sbSTACK_SIZE
|
|
#else
|
|
#define sbSMALLER_STACK_SIZE configSTREAM_BUFFER_SMALLER_TASK_STACK_SIZE
|
|
#endif
|
|
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/*
|
|
* Performs various tests that do not require multiple tasks to interact.
|
|
*/
|
|
static void prvSingleTaskTests( StreamBufferHandle_t xStreamBuffer );
|
|
|
|
/*
|
|
* Tests sending and receiving various lengths of data via a stream buffer.
|
|
* The echo client sends the data to the echo server, which then sends the
|
|
* data back to the echo client, which checks it receives exactly what it
|
|
* sent.
|
|
*/
|
|
static void prvEchoClient( void * pvParameters );
|
|
static void prvEchoServer( void * pvParameters );
|
|
|
|
/*
|
|
* Tasks that send and receive to a stream buffer at a low priority and without
|
|
* blocking, so the send and receive functions interleave in time as the tasks
|
|
* are switched in and out.
|
|
*/
|
|
static void prvNonBlockingReceiverTask( void * pvParameters );
|
|
static void prvNonBlockingSenderTask( void * pvParameters );
|
|
|
|
/* Performs an assert() like check in a way that won't get removed when
|
|
* performing a code coverage analysis. */
|
|
static void prvCheckExpectedState( BaseType_t xState );
|
|
|
|
/*
|
|
* A task that creates a stream buffer with a specific trigger level, then
|
|
* receives a string from an interrupt (the RTOS tick hook) byte by byte to
|
|
* check it is only unblocked when the specified trigger level is reached.
|
|
*/
|
|
static void prvInterruptTriggerLevelTest( void * pvParameters );
|
|
|
|
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
|
|
|
|
/* This file tests both statically and dynamically allocated stream buffers.
|
|
* Allocate the structures and buffers to be used by the statically allocated
|
|
* objects, which get used in the echo tests. */
|
|
static void prvReceiverTask( void * pvParameters );
|
|
static void prvSenderTask( void * pvParameters );
|
|
|
|
static StaticStreamBuffer_t xStaticStreamBuffers[ sbNUMBER_OF_ECHO_CLIENTS ];
|
|
static uint32_t ulSenderLoopCounters[ sbNUMBER_OF_SENDER_TASKS ] = { 0 };
|
|
#endif /* configSUPPORT_STATIC_ALLOCATION */
|
|
|
|
/* The +1 is to make the test logic easier as the function that calculates the
|
|
* free space will return one less than the actual free space - adding a 1 to the
|
|
* actual length makes it appear to the tests as if the free space is returned as
|
|
* it might logically be expected. Returning 1 less than the actual free space is
|
|
* fine as it can never result in an overrun. */
|
|
static uint8_t ucBufferStorage[ sbNUMBER_OF_SENDER_TASKS ][ sbSTREAM_BUFFER_LENGTH_BYTES + 1 ];
|
|
|
|
/*-----------------------------------------------------------*/
|
|
|
|
/* The buffers used by the echo client and server tasks. */
|
|
typedef struct ECHO_STREAM_BUFFERS
|
|
{
|
|
/* Handles to the data structures that describe the stream buffers. */
|
|
StreamBufferHandle_t xEchoClientBuffer;
|
|
StreamBufferHandle_t xEchoServerBuffer;
|
|
} EchoStreamBuffers_t;
|
|
static volatile uint32_t ulEchoLoopCounters[ sbNUMBER_OF_ECHO_CLIENTS ] = { 0 };
|
|
|
|
/* The non-blocking tasks monitor their operation, and if no errors have been
|
|
* found, increment ulNonBlockingRxCounter. xAreStreamBufferTasksStillRunning()
|
|
* then checks ulNonBlockingRxCounter and only returns pdPASS if
|
|
* ulNonBlockingRxCounter is still incrementing. */
|
|
static volatile uint32_t ulNonBlockingRxCounter = 0;
|
|
|
|
/* The task that receives characters from the tick interrupt in order to test
|
|
* different trigger levels monitors its own behaviour. If it has not detected any
|
|
* error then it increments ulInterruptTriggerCounter to indicate to the check task
|
|
* that it is still operating correctly. */
|
|
static volatile uint32_t ulInterruptTriggerCounter = 0UL;
|
|
|
|
/* The stream buffer used from the tick interrupt. This sends one byte at a time
|
|
* to a test task to test the trigger level operation. The variable is set to NULL
|
|
* in between test runs. */
|
|
static volatile StreamBufferHandle_t xInterruptStreamBuffer = NULL;
|
|
|
|
/* The data sent from the tick interrupt to the task that tests the trigger
|
|
* level functionality. */
|
|
static const char * pcDataSentFromInterrupt = "0123456789";
|
|
|
|
/* Data that is longer than the buffer that is sent to the buffers as a stream
|
|
* of bytes. Parts of which are written to the stream buffer to test writing
|
|
* different lengths at different offsets, to many bytes, part streams, streams
|
|
* that wrap, etc.. Two messages are defined to ensure left over data is not
|
|
* accidentally read out of the buffer. */
|
|
static const char * pc55ByteString = "One two three four five six seven eight nine ten eleven";
|
|
static const char * pc54ByteString = "01234567891abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQ";
|
|
|
|
/* Used to log the status of the tests contained within this file for reporting
|
|
* to a monitoring task ('check' task). */
|
|
static BaseType_t xErrorStatus = pdPASS;
|
|
|
|
/*-----------------------------------------------------------*/
|
|
|
|
void vStartStreamBufferTasks( void )
|
|
{
|
|
StreamBufferHandle_t xStreamBuffer;
|
|
|
|
/* The echo servers sets up the stream buffers before creating the echo
|
|
* client tasks. One set of tasks has the server as the higher priority, and
|
|
* the other has the client as the higher priority. */
|
|
xTaskCreate( prvEchoServer, "1StrEchoServer", sbSMALLER_STACK_SIZE, NULL, sbHIGHER_PRIORITY, NULL );
|
|
xTaskCreate( prvEchoServer, "2StrEchoServer", sbSMALLER_STACK_SIZE, NULL, sbLOWER_PRIORITY, NULL );
|
|
|
|
/* The non blocking tasks run continuously and will interleave with each
|
|
* other, so must be created at the lowest priority. The stream buffer they
|
|
* use is created and passed in using the task's parameter. */
|
|
xStreamBuffer = xStreamBufferCreate( sbSTREAM_BUFFER_LENGTH_BYTES, sbTRIGGER_LEVEL_1 );
|
|
xTaskCreate( prvNonBlockingReceiverTask, "StrNonBlkRx", configMINIMAL_STACK_SIZE, ( void * ) xStreamBuffer, tskIDLE_PRIORITY, NULL );
|
|
xTaskCreate( prvNonBlockingSenderTask, "StrNonBlkTx", configMINIMAL_STACK_SIZE, ( void * ) xStreamBuffer, tskIDLE_PRIORITY, NULL );
|
|
|
|
/* The task that receives bytes from an interrupt to test that it unblocks
|
|
* at a specific trigger level must run at a high priority to minimise the risk
|
|
* of it receiving more characters before it can execute again after being
|
|
* unblocked. */
|
|
xTaskCreate( prvInterruptTriggerLevelTest, "StrTrig", configMINIMAL_STACK_SIZE, NULL, configMAX_PRIORITIES - 1, NULL );
|
|
|
|
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
|
|
{
|
|
/* The sender tasks set up the stream buffers before creating the
|
|
* receiver tasks. Priorities must be 0 and 1 as the priority is used to
|
|
* index into the xStaticStreamBuffers and ucBufferStorage arrays. */
|
|
xTaskCreate( prvSenderTask, "Str1Sender", sbSMALLER_STACK_SIZE, NULL, sbHIGHER_PRIORITY, NULL );
|
|
xTaskCreate( prvSenderTask, "Str2Sender", sbSMALLER_STACK_SIZE, NULL, sbLOWER_PRIORITY, NULL );
|
|
}
|
|
#endif /* configSUPPORT_STATIC_ALLOCATION */
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
static void prvCheckExpectedState( BaseType_t xState )
|
|
{
|
|
configASSERT( xState );
|
|
|
|
if( xState == pdFAIL )
|
|
{
|
|
xErrorStatus = pdFAIL;
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
static void prvSingleTaskTests( StreamBufferHandle_t xStreamBuffer )
|
|
{
|
|
size_t xReturned, xItem, xExpected, xExpectedSpaces, xExpectedBytes;
|
|
const size_t xMax6ByteMessages = sbSTREAM_BUFFER_LENGTH_BYTES / 6;
|
|
const size_t xTrueSize = ( sizeof( ucBufferStorage ) / sbNUMBER_OF_SENDER_TASKS );
|
|
const size_t x6ByteLength = 6, x17ByteLength = 17, xFullBufferSize = sbSTREAM_BUFFER_LENGTH_BYTES * ( size_t ) 2;
|
|
uint8_t * pucFullBuffer, * pucData, * pucReadData;
|
|
TickType_t xTimeBeforeCall, xTimeAfterCall;
|
|
const TickType_t xBlockTime = pdMS_TO_TICKS( 15 ), xAllowableMargin = pdMS_TO_TICKS( 3 ), xMinimalBlockTime = 2;
|
|
UBaseType_t uxOriginalPriority;
|
|
|
|
/* Remove warning in case configASSERT() is not defined. */
|
|
( void ) xAllowableMargin;
|
|
|
|
/* To minimise stack and heap usage a full size buffer is allocated from the
|
|
* heap, then buffers which hold smaller amounts of data are overlayed with the
|
|
* larger buffer - just make sure not to use both at once! */
|
|
pucFullBuffer = pvPortMalloc( xFullBufferSize );
|
|
configASSERT( pucFullBuffer );
|
|
|
|
pucData = pucFullBuffer;
|
|
pucReadData = pucData + x17ByteLength;
|
|
|
|
/* Nothing has been added or removed yet, so expect the free space to be
|
|
* exactly as created. Head and tail are both at 0. */
|
|
xExpectedSpaces = sbSTREAM_BUFFER_LENGTH_BYTES;
|
|
xExpectedBytes = 0;
|
|
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == xExpectedSpaces );
|
|
xExpected = xStreamBufferBytesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == xExpectedBytes );
|
|
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
|
|
|
|
/* Add a single item - number of bytes available should go up by one and spaces
|
|
* available down by one. Head is in front of tail. */
|
|
xExpectedSpaces--;
|
|
xExpectedBytes++;
|
|
xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, sizeof( *pucData ), ( TickType_t ) 0 );
|
|
prvCheckExpectedState( xReturned == sizeof( *pucData ) );
|
|
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == xExpectedSpaces );
|
|
xExpected = xStreamBufferBytesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == xExpectedBytes );
|
|
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
|
|
|
|
/* Now fill the buffer by adding another 29 bytes. Head is 30 tail is at 0. */
|
|
xExpectedSpaces -= 29;
|
|
xExpectedBytes += 29;
|
|
xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, ( sbSTREAM_BUFFER_LENGTH_BYTES - 1 ), ( TickType_t ) 0 );
|
|
prvCheckExpectedState( xReturned == ( sbSTREAM_BUFFER_LENGTH_BYTES - 1 ) );
|
|
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == xExpectedSpaces );
|
|
xExpected = xStreamBufferBytesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == xExpectedBytes );
|
|
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
|
|
|
|
/* Should not be able to add another byte now. */
|
|
xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, sizeof( *pucData ), ( TickType_t ) 0 );
|
|
prvCheckExpectedState( xReturned == ( size_t ) 0 );
|
|
|
|
/* Remove a byte so the tail pointer moves off 0. Head pointer remains at the
|
|
* end of the buffer. */
|
|
xExpectedSpaces += 1;
|
|
xExpectedBytes -= 1;
|
|
xReturned = xStreamBufferReceive( xStreamBuffer, ( void * ) pucData, sizeof( *pucData ), ( TickType_t ) 0 );
|
|
prvCheckExpectedState( xReturned == sizeof( *pucData ) );
|
|
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == xExpectedSpaces );
|
|
xExpected = xStreamBufferBytesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == xExpectedBytes );
|
|
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
|
|
|
|
/* Should be able to add another byte to fill the buffer again now. */
|
|
xExpectedSpaces -= 1;
|
|
xExpectedBytes += 1;
|
|
xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, sizeof( *pucData ), ( TickType_t ) 0 );
|
|
prvCheckExpectedState( xReturned == sizeof( *pucData ) );
|
|
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == xExpectedSpaces );
|
|
xExpected = xStreamBufferBytesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == xExpectedBytes );
|
|
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
|
|
|
|
/* Now the head pointer is behind the tail pointer. Read another 29 bytes so
|
|
* the tail pointer moves to the end of the buffer. */
|
|
xExpectedSpaces += 29;
|
|
xExpectedBytes -= 29;
|
|
xReturned = xStreamBufferReceive( xStreamBuffer, ( void * ) pucData, ( size_t ) 29, ( TickType_t ) 0 );
|
|
prvCheckExpectedState( xReturned == ( size_t ) 29 );
|
|
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == xExpectedSpaces );
|
|
xExpected = xStreamBufferBytesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == xExpectedBytes );
|
|
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
|
|
|
|
/* Read out one more byte to wrap the tail back around to the start, to get back
|
|
* to where we started. */
|
|
xExpectedSpaces += 1;
|
|
xExpectedBytes -= 1;
|
|
xReturned = xStreamBufferReceive( xStreamBuffer, ( void * ) pucData, sizeof( *pucData ), ( TickType_t ) 0 );
|
|
prvCheckExpectedState( xReturned == sizeof( *pucData ) );
|
|
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == xExpectedSpaces );
|
|
xExpected = xStreamBufferBytesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == xExpectedBytes );
|
|
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
|
|
|
|
/* Try filling the message buffer in one write, blocking indefinitely. Expect to
|
|
* have written one byte less. */
|
|
xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, xTrueSize, portMAX_DELAY );
|
|
xExpectedSpaces = ( size_t ) 0;
|
|
prvCheckExpectedState( xReturned == ( xTrueSize - ( size_t ) 1 ) );
|
|
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == xExpectedSpaces );
|
|
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
|
|
|
|
/* Empty the buffer again ready for the rest of the tests. Again block
|
|
* indefinitely to ensure reading more than there can possible be won't lock this
|
|
* task up, so expect to actually receive one byte less than requested. */
|
|
xReturned = xStreamBufferReceive( xStreamBuffer, ( void * ) pucData, xTrueSize, portMAX_DELAY );
|
|
prvCheckExpectedState( xReturned == ( xTrueSize - ( size_t ) 1 ) );
|
|
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == sbSTREAM_BUFFER_LENGTH_BYTES );
|
|
xExpected = xStreamBufferBytesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == ( size_t ) 0 );
|
|
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
|
|
|
|
|
|
/* The buffer is 30 bytes long. 6 5 byte messages should fit before the
|
|
* buffer is completely full. */
|
|
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
|
|
|
|
for( xItem = 0; xItem < xMax6ByteMessages; xItem++ )
|
|
{
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
|
|
|
|
/* Generate recognizable data to write to the buffer. This is just
|
|
* ascii characters that shows which loop iteration the data was written
|
|
* in. The 'FromISR' version is used to give it some exercise as a block
|
|
* time is not used, so the call must be inside a critical section so it
|
|
* runs with ports that don't support interrupt nesting (and therefore
|
|
* don't have interrupt safe critical sections). */
|
|
memset( ( void * ) pucData, ( ( int ) '0' ) + ( int ) xItem, x6ByteLength );
|
|
taskENTER_CRITICAL();
|
|
{
|
|
xReturned = xStreamBufferSendFromISR( xStreamBuffer, ( void * ) pucData, x6ByteLength, NULL );
|
|
}
|
|
taskEXIT_CRITICAL();
|
|
prvCheckExpectedState( xReturned == x6ByteLength );
|
|
|
|
/* The space in the buffer will have reduced by the amount of user data
|
|
* written into the buffer. */
|
|
xExpected -= x6ByteLength;
|
|
xReturned = xStreamBufferSpacesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xReturned == xExpected );
|
|
xReturned = xStreamBufferBytesAvailable( xStreamBuffer );
|
|
/* +1 as it is zero indexed. */
|
|
prvCheckExpectedState( xReturned == ( ( xItem + 1 ) * x6ByteLength ) );
|
|
}
|
|
|
|
/* Now the buffer should be full, and attempting to add anything should fail. */
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
|
|
xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, sizeof( pucData[ 0 ] ), sbDONT_BLOCK );
|
|
prvCheckExpectedState( xReturned == 0 );
|
|
|
|
/* Adding with a timeout should also fail after the appropriate time. The
|
|
* priority is temporarily boosted in this part of the test to keep the
|
|
* allowable margin to a minimum. */
|
|
uxOriginalPriority = uxTaskPriorityGet( NULL );
|
|
vTaskPrioritySet( NULL, configMAX_PRIORITIES - 1 );
|
|
xTimeBeforeCall = xTaskGetTickCount();
|
|
xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, sizeof( pucData[ 0 ] ), xBlockTime );
|
|
xTimeAfterCall = xTaskGetTickCount();
|
|
vTaskPrioritySet( NULL, uxOriginalPriority );
|
|
prvCheckExpectedState( ( ( TickType_t ) ( xTimeAfterCall - xTimeBeforeCall ) ) >= xBlockTime );
|
|
prvCheckExpectedState( ( ( TickType_t ) ( xTimeAfterCall - xTimeBeforeCall ) ) < ( xBlockTime + xAllowableMargin ) );
|
|
prvCheckExpectedState( xReturned == 0 );
|
|
|
|
/* The buffer is now full of data in the form "000000", "111111", etc. Make
|
|
* sure the data is read out as expected. */
|
|
for( xItem = 0; xItem < xMax6ByteMessages; xItem++ )
|
|
{
|
|
/* Generate the data that is expected to be read out for this loop
|
|
* iteration. */
|
|
memset( ( void * ) pucData, ( ( int ) '0' ) + ( int ) xItem, x6ByteLength );
|
|
|
|
/* Read the next 6 bytes out. The 'FromISR' version is used to give it
|
|
* some exercise as a block time is not used, so a it must be called from
|
|
* a critical section so this will work on ports that don't support
|
|
* interrupt nesting (so don't have interrupt safe critical sections). */
|
|
taskENTER_CRITICAL();
|
|
{
|
|
xReturned = xStreamBufferReceiveFromISR( xStreamBuffer, ( void * ) pucReadData, x6ByteLength, NULL );
|
|
}
|
|
taskEXIT_CRITICAL();
|
|
prvCheckExpectedState( xReturned == x6ByteLength );
|
|
|
|
/* Does the data read out match that expected? */
|
|
prvCheckExpectedState( memcmp( ( void * ) pucData, ( void * ) pucReadData, x6ByteLength ) == 0 );
|
|
|
|
/* The space in the buffer will have increased by the amount of user
|
|
* data removed from the buffer. */
|
|
xExpected += x6ByteLength;
|
|
xReturned = xStreamBufferSpacesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xReturned == xExpected );
|
|
xReturned = xStreamBufferBytesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xReturned == ( sbSTREAM_BUFFER_LENGTH_BYTES - xExpected ) );
|
|
}
|
|
|
|
/* The buffer should be empty again. */
|
|
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
|
|
xExpected = xStreamBufferSpacesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xExpected == sbSTREAM_BUFFER_LENGTH_BYTES );
|
|
|
|
/* Reading with a timeout should also fail after the appropriate time. The
|
|
* priority is temporarily boosted in this part of the test to keep the
|
|
* allowable margin to a minimum. */
|
|
vTaskPrioritySet( NULL, configMAX_PRIORITIES - 1 );
|
|
xTimeBeforeCall = xTaskGetTickCount();
|
|
xReturned = xStreamBufferReceive( xStreamBuffer, ( void * ) pucReadData, x6ByteLength, xBlockTime );
|
|
xTimeAfterCall = xTaskGetTickCount();
|
|
vTaskPrioritySet( NULL, uxOriginalPriority );
|
|
prvCheckExpectedState( ( ( TickType_t ) ( xTimeAfterCall - xTimeBeforeCall ) ) >= xBlockTime );
|
|
prvCheckExpectedState( ( ( TickType_t ) ( xTimeAfterCall - xTimeBeforeCall ) ) < ( xBlockTime + xAllowableMargin ) );
|
|
prvCheckExpectedState( xReturned == 0 );
|
|
|
|
|
|
/* In the next loop 17 bytes are written to then read out on each
|
|
* iteration. As 30 is not divisible by 17 the data will wrap around. */
|
|
xExpected = sbSTREAM_BUFFER_LENGTH_BYTES - x17ByteLength;
|
|
|
|
for( xItem = 0; xItem < 100; xItem++ )
|
|
{
|
|
/* Generate recognizable data to write to the queue. This is just
|
|
* ascii characters that shows which loop iteration the data was written
|
|
* in. */
|
|
memset( ( void * ) pucData, ( ( int ) '0' ) + ( int ) xItem, x17ByteLength );
|
|
xReturned = xStreamBufferSend( xStreamBuffer, ( void * ) pucData, x17ByteLength, sbDONT_BLOCK );
|
|
prvCheckExpectedState( xReturned == x17ByteLength );
|
|
|
|
/* The space in the buffer will have reduced by the amount of user data
|
|
* written into the buffer. */
|
|
xReturned = xStreamBufferSpacesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xReturned == xExpected );
|
|
xReturned = xStreamBufferBytesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xReturned == x17ByteLength );
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
|
|
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
|
|
|
|
/* Read the 17 bytes out again. */
|
|
xReturned = xStreamBufferReceive( xStreamBuffer, ( void * ) pucReadData, x17ByteLength, sbDONT_BLOCK );
|
|
prvCheckExpectedState( xReturned == x17ByteLength );
|
|
|
|
/* Does the data read out match that expected? */
|
|
prvCheckExpectedState( memcmp( ( void * ) pucData, ( void * ) pucReadData, x17ByteLength ) == 0 );
|
|
|
|
/* Full buffer space available again. */
|
|
xReturned = xStreamBufferSpacesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xReturned == sbSTREAM_BUFFER_LENGTH_BYTES );
|
|
xReturned = xStreamBufferBytesAvailable( xStreamBuffer );
|
|
prvCheckExpectedState( xReturned == 0 );
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
|
|
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
|
|
}
|
|
|
|
/* Fill the buffer with one message, check it is full, then read it back
|
|
* again and check the correct data is received. */
|
|
xStreamBufferSend( xStreamBuffer, ( const void * ) pc55ByteString, sbSTREAM_BUFFER_LENGTH_BYTES, sbDONT_BLOCK );
|
|
xStreamBufferReceive( xStreamBuffer, ( void * ) pucFullBuffer, sbSTREAM_BUFFER_LENGTH_BYTES, sbDONT_BLOCK );
|
|
prvCheckExpectedState( memcmp( pc55ByteString, pucFullBuffer, sbSTREAM_BUFFER_LENGTH_BYTES ) == 0 );
|
|
|
|
/* Fill the buffer one bytes at a time. */
|
|
for( xItem = 0; xItem < sbSTREAM_BUFFER_LENGTH_BYTES; xItem++ )
|
|
{
|
|
/* Block time is only for test coverage, the task should never actually
|
|
* block here. */
|
|
xStreamBufferSend( xStreamBuffer, ( const void * ) &( pc54ByteString[ xItem ] ), sizeof( char ), sbRX_TX_BLOCK_TIME );
|
|
}
|
|
|
|
/* The buffer should now be full. */
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
|
|
|
|
/* Read the message out in one go, even though it was written in individual
|
|
* bytes. Try reading much more data than is actually available to ensure only
|
|
* the available bytes are returned (otherwise this read will write outside of
|
|
* the memory allocated anyway!). */
|
|
xReturned = xStreamBufferReceive( xStreamBuffer, pucFullBuffer, sbSTREAM_BUFFER_LENGTH_BYTES * ( size_t ) 2, sbRX_TX_BLOCK_TIME );
|
|
prvCheckExpectedState( xReturned == sbSTREAM_BUFFER_LENGTH_BYTES );
|
|
prvCheckExpectedState( memcmp( ( const void * ) pc54ByteString, ( const void * ) pucFullBuffer, sbSTREAM_BUFFER_LENGTH_BYTES ) == 0 );
|
|
|
|
/* Now do the opposite, write in one go and read out in single bytes. */
|
|
xReturned = xStreamBufferSend( xStreamBuffer, ( const void * ) pc55ByteString, sbSTREAM_BUFFER_LENGTH_BYTES, sbRX_TX_BLOCK_TIME );
|
|
prvCheckExpectedState( xReturned == sbSTREAM_BUFFER_LENGTH_BYTES );
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
|
|
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
|
|
prvCheckExpectedState( xStreamBufferBytesAvailable( xStreamBuffer ) == sbSTREAM_BUFFER_LENGTH_BYTES );
|
|
prvCheckExpectedState( xStreamBufferSpacesAvailable( xStreamBuffer ) == 0 );
|
|
|
|
/* Read from the buffer one byte at a time. */
|
|
for( xItem = 0; xItem < sbSTREAM_BUFFER_LENGTH_BYTES; xItem++ )
|
|
{
|
|
/* Block time is only for test coverage, the task should never actually
|
|
* block here. */
|
|
xStreamBufferReceive( xStreamBuffer, ( void * ) pucFullBuffer, sizeof( char ), sbRX_TX_BLOCK_TIME );
|
|
prvCheckExpectedState( pc55ByteString[ xItem ] == pucFullBuffer[ 0 ] );
|
|
}
|
|
|
|
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
|
|
|
|
/* Try writing more bytes than there is space. */
|
|
vTaskPrioritySet( NULL, configMAX_PRIORITIES - 1 );
|
|
xReturned = xStreamBufferSend( xStreamBuffer, ( const void * ) pc54ByteString, sbSTREAM_BUFFER_LENGTH_BYTES * ( size_t ) 2, xMinimalBlockTime );
|
|
vTaskPrioritySet( NULL, uxOriginalPriority );
|
|
prvCheckExpectedState( xReturned == sbSTREAM_BUFFER_LENGTH_BYTES );
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdTRUE );
|
|
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdFALSE );
|
|
|
|
/* No space now though. */
|
|
xReturned = xStreamBufferSend( xStreamBuffer, ( const void * ) pc54ByteString, sbSTREAM_BUFFER_LENGTH_BYTES * ( size_t ) 2, xMinimalBlockTime );
|
|
prvCheckExpectedState( xReturned == 0 );
|
|
|
|
/* Ensure data was written as expected even when there was an attempt to
|
|
* write more than was available. This also tries to read more bytes than are
|
|
* available. */
|
|
xReturned = xStreamBufferReceive( xStreamBuffer, ( void * ) pucFullBuffer, xFullBufferSize, xMinimalBlockTime );
|
|
prvCheckExpectedState( memcmp( ( const void * ) pucFullBuffer, ( const void * ) pc54ByteString, sbSTREAM_BUFFER_LENGTH_BYTES ) == 0 );
|
|
prvCheckExpectedState( xStreamBufferIsFull( xStreamBuffer ) == pdFALSE );
|
|
prvCheckExpectedState( xStreamBufferIsEmpty( xStreamBuffer ) == pdTRUE );
|
|
|
|
/* Clean up with data in the buffer to ensure the tests that follow don't
|
|
* see the data (the data should be discarded). */
|
|
( void ) xStreamBufferSend( xStreamBuffer, ( const void * ) pc55ByteString, sbSTREAM_BUFFER_LENGTH_BYTES / ( size_t ) 2, sbDONT_BLOCK );
|
|
vPortFree( pucFullBuffer );
|
|
xStreamBufferReset( xStreamBuffer );
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
static void prvNonBlockingSenderTask( void * pvParameters )
|
|
{
|
|
StreamBufferHandle_t xStreamBuffer;
|
|
size_t xNextChar = 0, xBytesToSend, xBytesActuallySent;
|
|
const size_t xStringLength = strlen( pc54ByteString );
|
|
|
|
/* In this case the stream buffer has already been created and is passed
|
|
* into the task using the task's parameter. */
|
|
xStreamBuffer = ( StreamBufferHandle_t ) pvParameters;
|
|
|
|
/* Keep sending the string to the stream buffer as many bytes as possible in
|
|
* each go. Doesn't block so calls can interleave with the non-blocking
|
|
* receives performed by prvNonBlockingReceiverTask(). */
|
|
for( ; ; )
|
|
{
|
|
/* The whole string cannot be sent at once, so xNextChar is an index to
|
|
* the position within the string that has been sent so far. How many
|
|
* bytes are there left to send before the end of the string? */
|
|
xBytesToSend = xStringLength - xNextChar;
|
|
|
|
/* Attempt to send right up to the end of the string. */
|
|
xBytesActuallySent = xStreamBufferSend( xStreamBuffer, ( const void * ) &( pc54ByteString[ xNextChar ] ), xBytesToSend, sbDONT_BLOCK );
|
|
prvCheckExpectedState( xBytesActuallySent <= xBytesToSend );
|
|
|
|
/* Move the index up the string to the next character to be sent,
|
|
* wrapping if the end of the string has been reached. */
|
|
xNextChar += xBytesActuallySent;
|
|
prvCheckExpectedState( xNextChar <= xStringLength );
|
|
|
|
if( xNextChar == xStringLength )
|
|
{
|
|
xNextChar = 0;
|
|
}
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
static void prvNonBlockingReceiverTask( void * pvParameters )
|
|
{
|
|
StreamBufferHandle_t xStreamBuffer;
|
|
size_t xNextChar = 0, xReceiveLength, xBytesToTest, xStartIndex;
|
|
const size_t xStringLength = strlen( pc54ByteString );
|
|
char cRxString[ 12 ]; /* Holds received characters. */
|
|
BaseType_t xNonBlockingReceiveError = pdFALSE;
|
|
|
|
/* In this case the stream buffer has already been created and is passed
|
|
* into the task using the task's parameter. */
|
|
xStreamBuffer = ( StreamBufferHandle_t ) pvParameters;
|
|
|
|
/* Expects to receive the pc54ByteString over and over again. Sends and
|
|
* receives are not blocking so will interleave. */
|
|
for( ; ; )
|
|
{
|
|
/* Attempt to receive as many bytes as possible, up to the limit of the
|
|
* Rx buffer size. */
|
|
xReceiveLength = xStreamBufferReceive( xStreamBuffer, ( void * ) cRxString, sizeof( cRxString ), sbDONT_BLOCK );
|
|
|
|
if( xReceiveLength > 0 )
|
|
{
|
|
/* xNextChar is the index into pc54ByteString that has been received
|
|
* already. If xReceiveLength bytes are added to that, will it go off
|
|
* the end of the string? If so, then first test up to the end of the
|
|
* string, then go back to the start of pc54ByteString to test the
|
|
* remains of the received data. */
|
|
xBytesToTest = xReceiveLength;
|
|
|
|
if( ( xNextChar + xBytesToTest ) > xStringLength )
|
|
{
|
|
/* Cap to test the received data to the end of the string. */
|
|
xBytesToTest = xStringLength - xNextChar;
|
|
|
|
if( memcmp( ( const void * ) &( pc54ByteString[ xNextChar ] ), ( const void * ) cRxString, xBytesToTest ) != 0 )
|
|
{
|
|
xNonBlockingReceiveError = pdTRUE;
|
|
}
|
|
|
|
/* Then move back to the start of the string to test the
|
|
* remaining received bytes. */
|
|
xNextChar = 0;
|
|
xStartIndex = xBytesToTest;
|
|
xBytesToTest = xReceiveLength - xBytesToTest;
|
|
}
|
|
else
|
|
{
|
|
/* The string didn't wrap in the buffer, so start comparing from
|
|
* the start of the received data. */
|
|
xStartIndex = 0;
|
|
}
|
|
|
|
/* Test the received bytes are as expected, then move the index
|
|
* along the string to the next expected char to receive. */
|
|
if( memcmp( ( const void * ) &( pc54ByteString[ xNextChar ] ), ( const void * ) &( cRxString[ xStartIndex ] ), xBytesToTest ) != 0 )
|
|
{
|
|
xNonBlockingReceiveError = pdTRUE;
|
|
}
|
|
|
|
if( xNonBlockingReceiveError == pdFALSE )
|
|
{
|
|
/* No errors detected so increment the counter that lets the
|
|
* check task know this test is still functioning correctly. */
|
|
ulNonBlockingRxCounter++;
|
|
}
|
|
|
|
xNextChar += xBytesToTest;
|
|
|
|
if( xNextChar >= xStringLength )
|
|
{
|
|
xNextChar = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
|
|
|
|
static void prvSenderTask( void * pvParameters )
|
|
{
|
|
StreamBufferHandle_t xStreamBuffer, xTempStreamBuffer;
|
|
static uint8_t ucTempBuffer[ 10 ]; /* Just used to exercise stream buffer creating and deletion. */
|
|
const TickType_t xTicksToWait = sbRX_TX_BLOCK_TIME, xShortDelay = pdMS_TO_TICKS( 50 );
|
|
StaticStreamBuffer_t xStaticStreamBuffer;
|
|
size_t xNextChar = 0, xBytesToSend, xBytesActuallySent;
|
|
const size_t xStringLength = strlen( pc55ByteString );
|
|
|
|
/* The task's priority is used as an index into the loop counters used to
|
|
* indicate this task is still running. */
|
|
UBaseType_t uxIndex = uxTaskPriorityGet( NULL );
|
|
|
|
/* Make sure a change in priority does not inadvertently result in an
|
|
* invalid array index. */
|
|
prvCheckExpectedState( uxIndex < sbNUMBER_OF_ECHO_CLIENTS );
|
|
|
|
/* Avoid compiler warnings about unused parameters. */
|
|
( void ) pvParameters;
|
|
|
|
xStreamBuffer = xStreamBufferCreateStatic( sizeof( ucBufferStorage ) / sbNUMBER_OF_SENDER_TASKS, /* The number of bytes in each buffer in the array. */
|
|
sbTRIGGER_LEVEL_1, /* The number of bytes to be in the buffer before a task blocked to wait for data is unblocked. */
|
|
&( ucBufferStorage[ uxIndex ][ 0 ] ), /* The address of the buffer to use within the array. */
|
|
&( xStaticStreamBuffers[ uxIndex ] ) ); /* The static stream buffer structure to use within the array. */
|
|
|
|
/* Now the stream buffer has been created the receiver task can be
|
|
* created. If this sender task has the higher priority then the receiver
|
|
* task is created at the lower priority - if this sender task has the
|
|
* lower priority then the receiver task is created at the higher
|
|
* priority. */
|
|
if( uxTaskPriorityGet( NULL ) == sbLOWER_PRIORITY )
|
|
{
|
|
/* Here prvSingleTaskTests() performs various tests on a stream buffer
|
|
* that was created statically. */
|
|
prvSingleTaskTests( xStreamBuffer );
|
|
xTaskCreate( prvReceiverTask, "StrReceiver", sbSMALLER_STACK_SIZE, ( void * ) xStreamBuffer, sbHIGHER_PRIORITY, NULL );
|
|
}
|
|
else
|
|
{
|
|
xTaskCreate( prvReceiverTask, "StrReceiver", sbSMALLER_STACK_SIZE, ( void * ) xStreamBuffer, sbLOWER_PRIORITY, NULL );
|
|
}
|
|
|
|
for( ; ; )
|
|
{
|
|
/* The whole string cannot be sent at once, so xNextChar is an index
|
|
* to the position within the string that has been sent so far. How
|
|
* many bytes are there left to send before the end of the string? */
|
|
xBytesToSend = xStringLength - xNextChar;
|
|
|
|
/* Attempt to send right up to the end of the string. */
|
|
xBytesActuallySent = xStreamBufferSend( xStreamBuffer, ( const void * ) &( pc55ByteString[ xNextChar ] ), xBytesToSend, xTicksToWait );
|
|
prvCheckExpectedState( xBytesActuallySent <= xBytesToSend );
|
|
|
|
/* Move the index up the string to the next character to be sent,
|
|
* wrapping if the end of the string has been reached. */
|
|
xNextChar += xBytesActuallySent;
|
|
prvCheckExpectedState( xNextChar <= xStringLength );
|
|
|
|
if( xNextChar == xStringLength )
|
|
{
|
|
xNextChar = 0;
|
|
}
|
|
|
|
/* Increment a loop counter so a check task can tell this task is
|
|
* still running as expected. */
|
|
ulSenderLoopCounters[ uxIndex ]++;
|
|
|
|
if( uxTaskPriorityGet( NULL ) == sbHIGHER_PRIORITY )
|
|
{
|
|
/* Allow other tasks to run. */
|
|
vTaskDelay( xShortDelay );
|
|
}
|
|
|
|
/* This stream buffer is just created and deleted to ensure no
|
|
* issues when attempting to delete a stream buffer that was
|
|
* created using statically allocated memory. To save stack space
|
|
* the buffer is set to point to the pc55ByteString, which is a const
|
|
* string, but no data is written into the buffer so any valid address
|
|
* will do. */
|
|
xTempStreamBuffer = xStreamBufferCreateStatic( sizeof( ucTempBuffer ), sbTRIGGER_LEVEL_1, ucTempBuffer, &xStaticStreamBuffer );
|
|
xStreamBufferReset( xTempStreamBuffer );
|
|
vStreamBufferDelete( xTempStreamBuffer );
|
|
}
|
|
}
|
|
|
|
#endif /* configSUPPORT_STATIC_ALLOCATION */
|
|
/*-----------------------------------------------------------*/
|
|
|
|
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
|
|
|
|
static void prvReceiverTask( void * pvParameters )
|
|
{
|
|
StreamBufferHandle_t const pxStreamBuffer = ( StreamBufferHandle_t ) pvParameters;
|
|
char cRxString[ 12 ]; /* Large enough to hold a 32-bit number in ASCII. */
|
|
const TickType_t xTicksToWait = pdMS_TO_TICKS( 5UL );
|
|
const size_t xStringLength = strlen( pc55ByteString );
|
|
size_t xNextChar = 0, xReceivedLength, xBytesToReceive;
|
|
|
|
for( ; ; )
|
|
{
|
|
/* Attempt to receive the number of bytes to the end of the string,
|
|
* or the number of byte that can be placed into the rx buffer,
|
|
* whichever is smallest. */
|
|
xBytesToReceive = configMIN( ( xStringLength - xNextChar ), sizeof( cRxString ) );
|
|
|
|
do
|
|
{
|
|
xReceivedLength = xStreamBufferReceive( pxStreamBuffer, ( void * ) cRxString, xBytesToReceive, xTicksToWait );
|
|
} while( xReceivedLength == 0 );
|
|
|
|
/* Ensure the received string matches the expected string. */
|
|
prvCheckExpectedState( memcmp( ( void * ) cRxString, ( const void * ) &( pc55ByteString[ xNextChar ] ), xReceivedLength ) == 0 );
|
|
|
|
/* Move the index into the string up to the end of the bytes
|
|
* received so far - wrapping if the end of the string has been
|
|
* reached. */
|
|
xNextChar += xReceivedLength;
|
|
|
|
if( xNextChar >= xStringLength )
|
|
{
|
|
xNextChar = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
#endif /* configSUPPORT_STATIC_ALLOCATION */
|
|
/*-----------------------------------------------------------*/
|
|
|
|
static void prvEchoClient( void * pvParameters )
|
|
{
|
|
size_t xSendLength = 0, ux;
|
|
char * pcStringToSend, * pcStringReceived, cNextChar = sbASCII_SPACE;
|
|
const TickType_t xTicksToWait = pdMS_TO_TICKS( 50 );
|
|
StreamBufferHandle_t xTempStreamBuffer;
|
|
|
|
/* The task's priority is used as an index into the loop counters used to
|
|
* indicate this task is still running. */
|
|
UBaseType_t uxIndex = uxTaskPriorityGet( NULL );
|
|
|
|
/* Pointers to the client and server stream buffers are passed into this task
|
|
* using the task's parameter. */
|
|
EchoStreamBuffers_t * pxStreamBuffers = ( EchoStreamBuffers_t * ) pvParameters;
|
|
|
|
/* Prevent compiler warnings. */
|
|
( void ) pvParameters;
|
|
|
|
/* Create the buffer into which strings to send to the server will be
|
|
* created, and the buffer into which strings echoed back from the server will
|
|
* be copied. */
|
|
pcStringToSend = ( char * ) pvPortMalloc( sbSTREAM_BUFFER_LENGTH_BYTES );
|
|
pcStringReceived = ( char * ) pvPortMalloc( sbSTREAM_BUFFER_LENGTH_BYTES );
|
|
|
|
configASSERT( pcStringToSend );
|
|
configASSERT( pcStringReceived );
|
|
|
|
for( ; ; )
|
|
{
|
|
/* Generate the length of the next string to send. */
|
|
xSendLength++;
|
|
|
|
/* The stream buffer is being used to hold variable length data, so
|
|
* each data item requires sizeof( size_t ) bytes to hold the data's
|
|
* length, hence the sizeof() in the if() condition below. */
|
|
if( xSendLength > ( sbSTREAM_BUFFER_LENGTH_BYTES - sizeof( size_t ) ) )
|
|
{
|
|
/* Back to a string length of 1. */
|
|
xSendLength = sizeof( char );
|
|
}
|
|
|
|
memset( pcStringToSend, 0x00, sbSTREAM_BUFFER_LENGTH_BYTES );
|
|
|
|
for( ux = 0; ux < xSendLength; ux++ )
|
|
{
|
|
pcStringToSend[ ux ] = cNextChar;
|
|
|
|
cNextChar++;
|
|
|
|
if( cNextChar > sbASCII_TILDA )
|
|
{
|
|
cNextChar = sbASCII_SPACE;
|
|
}
|
|
}
|
|
|
|
/* Send the generated string to the buffer. */
|
|
do
|
|
{
|
|
ux = xStreamBufferSend( pxStreamBuffers->xEchoClientBuffer, ( void * ) pcStringToSend, xSendLength, xTicksToWait );
|
|
} while( ux == 0 );
|
|
|
|
/* Wait for the string to be echoed back. */
|
|
memset( pcStringReceived, 0x00, sbSTREAM_BUFFER_LENGTH_BYTES );
|
|
xStreamBufferReceive( pxStreamBuffers->xEchoServerBuffer, ( void * ) pcStringReceived, xSendLength, portMAX_DELAY );
|
|
|
|
prvCheckExpectedState( strcmp( pcStringToSend, pcStringReceived ) == 0 );
|
|
|
|
/* Maintain a count of the number of times this code executes so a
|
|
* check task can determine if this task is still functioning as
|
|
* expected or not. As there are two client tasks, and the priorities
|
|
* used are 0 and 1, the task's priority is used as an index into the
|
|
* loop count array. */
|
|
ulEchoLoopCounters[ uxIndex ]++;
|
|
|
|
/* This stream buffer is just created and deleted to ensure no memory
|
|
* leaks. */
|
|
xTempStreamBuffer = xStreamBufferCreate( sbSTREAM_BUFFER_LENGTH_BYTES, sbTRIGGER_LEVEL_1 );
|
|
vStreamBufferDelete( xTempStreamBuffer );
|
|
|
|
/* The following are tests for a stream buffer of size one. */
|
|
/* Create a buffer of size one. */
|
|
xTempStreamBuffer = xStreamBufferCreate( sbSTREAM_BUFFER_LENGTH_ONE, sbTRIGGER_LEVEL_1 );
|
|
/* Ensure that the buffer was created successfully. */
|
|
configASSERT( xTempStreamBuffer );
|
|
|
|
/* Send one byte to the buffer. */
|
|
ux = xStreamBufferSend( xTempStreamBuffer, ( void * ) pcStringToSend, ( size_t ) 1, sbDONT_BLOCK );
|
|
/* Ensure that the byte was sent successfully. */
|
|
configASSERT( ux == 1 );
|
|
/* Try sending another byte to the buffer. */
|
|
ux = xStreamBufferSend( xTempStreamBuffer, ( void * ) pcStringToSend, ( size_t ) 1, sbDONT_BLOCK );
|
|
/* Make sure that send failed as the buffer is full. */
|
|
configASSERT( ux == 0 );
|
|
|
|
/* Receive one byte from the buffer. */
|
|
memset( pcStringReceived, 0x00, sbSTREAM_BUFFER_LENGTH_BYTES );
|
|
ux = xStreamBufferReceive( xTempStreamBuffer, ( void * ) pcStringReceived, ( size_t ) 1, sbDONT_BLOCK );
|
|
/* Ensure that the receive was successful. */
|
|
configASSERT( ux == 1 );
|
|
/* Ensure that the correct data was received. */
|
|
configASSERT( pcStringToSend[ 0 ] == pcStringReceived[ 0 ] );
|
|
/* Try receiving another byte from the buffer. */
|
|
ux = xStreamBufferReceive( xTempStreamBuffer, ( void * ) pcStringReceived, ( size_t ) 1, sbDONT_BLOCK );
|
|
/* Ensure that the receive failed as the buffer is empty. */
|
|
configASSERT( ux == 0 );
|
|
|
|
/* Try sending two bytes to the buffer. Since the size of the
|
|
* buffer is one, we must not be able to send more than one. */
|
|
ux = xStreamBufferSend( xTempStreamBuffer, ( void * ) pcStringToSend, ( size_t ) 2, sbDONT_BLOCK );
|
|
/* Ensure that only one byte was sent. */
|
|
configASSERT( ux == 1 );
|
|
|
|
/* Try receiving two bytes from the buffer. Since the size of the
|
|
* buffer is one, we must not be able to get more than one. */
|
|
memset( pcStringReceived, 0x00, sbSTREAM_BUFFER_LENGTH_BYTES );
|
|
ux = xStreamBufferReceive( xTempStreamBuffer, ( void * ) pcStringReceived, ( size_t ) 2, sbDONT_BLOCK );
|
|
/* Ensure that only one byte was received. */
|
|
configASSERT( ux == 1 );
|
|
/* Ensure that the correct data was received. */
|
|
configASSERT( pcStringToSend[ 0 ] == pcStringReceived[ 0 ] );
|
|
|
|
/* Delete the buffer. */
|
|
vStreamBufferDelete( xTempStreamBuffer );
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
static void prvEchoServer( void * pvParameters )
|
|
{
|
|
size_t xReceivedLength;
|
|
char * pcReceivedString;
|
|
EchoStreamBuffers_t xStreamBuffers;
|
|
TickType_t xTimeOnEntering;
|
|
const TickType_t xTicksToBlock = pdMS_TO_TICKS( 350UL );
|
|
|
|
/* Prevent compiler warnings about unused parameters. */
|
|
( void ) pvParameters;
|
|
|
|
/* Create the stream buffer used to send data from the client to the server,
|
|
* and the stream buffer used to echo the data from the server back to the
|
|
* client. */
|
|
xStreamBuffers.xEchoClientBuffer = xStreamBufferCreate( sbSTREAM_BUFFER_LENGTH_BYTES, sbTRIGGER_LEVEL_1 );
|
|
xStreamBuffers.xEchoServerBuffer = xStreamBufferCreate( sbSTREAM_BUFFER_LENGTH_BYTES, sbTRIGGER_LEVEL_1 );
|
|
configASSERT( xStreamBuffers.xEchoClientBuffer );
|
|
configASSERT( xStreamBuffers.xEchoServerBuffer );
|
|
|
|
/* Create the buffer into which received strings will be copied. */
|
|
pcReceivedString = ( char * ) pvPortMalloc( sbSTREAM_BUFFER_LENGTH_BYTES );
|
|
configASSERT( pcReceivedString );
|
|
|
|
/* Don't expect to receive anything yet! */
|
|
xTimeOnEntering = xTaskGetTickCount();
|
|
xReceivedLength = xStreamBufferReceive( xStreamBuffers.xEchoClientBuffer, ( void * ) pcReceivedString, sbSTREAM_BUFFER_LENGTH_BYTES, xTicksToBlock );
|
|
prvCheckExpectedState( ( ( TickType_t ) ( xTaskGetTickCount() - xTimeOnEntering ) ) >= xTicksToBlock );
|
|
prvCheckExpectedState( xReceivedLength == 0 );
|
|
|
|
/* Now the stream buffers have been created the echo client task can be
|
|
* created. If this server task has the higher priority then the client task
|
|
* is created at the lower priority - if this server task has the lower
|
|
* priority then the client task is created at the higher priority. */
|
|
if( uxTaskPriorityGet( NULL ) == sbLOWER_PRIORITY )
|
|
{
|
|
xTaskCreate( prvEchoClient, "EchoClient", sbSMALLER_STACK_SIZE, ( void * ) &xStreamBuffers, sbHIGHER_PRIORITY, NULL );
|
|
}
|
|
else
|
|
{
|
|
/* Here prvSingleTaskTests() performs various tests on a stream buffer
|
|
* that was created dynamically. */
|
|
prvSingleTaskTests( xStreamBuffers.xEchoClientBuffer );
|
|
xTaskCreate( prvEchoClient, "EchoClient", sbSMALLER_STACK_SIZE, ( void * ) &xStreamBuffers, sbLOWER_PRIORITY, NULL );
|
|
}
|
|
|
|
for( ; ; )
|
|
{
|
|
memset( pcReceivedString, 0x00, sbSTREAM_BUFFER_LENGTH_BYTES );
|
|
|
|
/* Has any data been sent by the client? */
|
|
xReceivedLength = xStreamBufferReceive( xStreamBuffers.xEchoClientBuffer, ( void * ) pcReceivedString, sbSTREAM_BUFFER_LENGTH_BYTES, portMAX_DELAY );
|
|
|
|
/* Should always receive data as max delay was used. */
|
|
prvCheckExpectedState( xReceivedLength > 0 );
|
|
|
|
/* Echo the received data back to the client. */
|
|
xStreamBufferSend( xStreamBuffers.xEchoServerBuffer, ( void * ) pcReceivedString, xReceivedLength, portMAX_DELAY );
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
void vPeriodicStreamBufferProcessing( void )
|
|
{
|
|
static size_t xNextChar = 0;
|
|
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
|
|
|
|
/* Called from the tick interrupt hook. If the global stream buffer
|
|
* variable is not NULL then the prvInterruptTriggerTest() task expects a byte
|
|
* to be sent to the stream buffer on each tick interrupt. */
|
|
if( xInterruptStreamBuffer != NULL )
|
|
{
|
|
/* One character from the pcDataSentFromInterrupt string is sent on each
|
|
* interrupt. The task blocked on the stream buffer should not be
|
|
* unblocked until the defined trigger level is hit. */
|
|
xStreamBufferSendFromISR( xInterruptStreamBuffer, ( const void * ) &( pcDataSentFromInterrupt[ xNextChar ] ), sizeof( char ), &xHigherPriorityTaskWoken );
|
|
|
|
if( xNextChar < strlen( pcDataSentFromInterrupt ) )
|
|
{
|
|
xNextChar++;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* Start at the beginning of the string being sent again. */
|
|
xNextChar = 0;
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
static void prvInterruptTriggerLevelTest( void * pvParameters )
|
|
{
|
|
StreamBufferHandle_t xStreamBuffer;
|
|
size_t xTriggerLevel = 1, xBytesReceived;
|
|
const size_t xStreamBufferSizeBytes = ( size_t ) 9, xMaxTriggerLevel = ( size_t ) 7, xMinTriggerLevel = ( size_t ) 2;
|
|
const TickType_t xReadBlockTime = 5, xCycleBlockTime = pdMS_TO_TICKS( 100 );
|
|
uint8_t ucRxData[ 9 ];
|
|
BaseType_t xErrorDetected = pdFALSE;
|
|
|
|
#ifndef configSTREAM_BUFFER_TRIGGER_LEVEL_TEST_MARGIN
|
|
const size_t xAllowableMargin = ( size_t ) 0;
|
|
#else
|
|
const size_t xAllowableMargin = ( size_t ) configSTREAM_BUFFER_TRIGGER_LEVEL_TEST_MARGIN;
|
|
#endif
|
|
|
|
/* Remove compiler warning about unused parameter. */
|
|
( void ) pvParameters;
|
|
|
|
for( ; ; )
|
|
{
|
|
for( xTriggerLevel = xMinTriggerLevel; xTriggerLevel < xMaxTriggerLevel; xTriggerLevel++ )
|
|
{
|
|
/* This test is very time sensitive so delay at the beginning to ensure
|
|
* the rest of the system is up and running before starting. Delay between
|
|
* each loop to ensure the interrupt that sends to the stream buffer
|
|
* detects it needs to start sending from the start of the string again.. */
|
|
vTaskDelay( xCycleBlockTime );
|
|
|
|
/* Create the stream buffer that will be used from inside the tick
|
|
* interrupt. */
|
|
memset( ucRxData, 0x00, sizeof( ucRxData ) );
|
|
xStreamBuffer = xStreamBufferCreate( xStreamBufferSizeBytes, xTriggerLevel );
|
|
configASSERT( xStreamBuffer );
|
|
|
|
/* Now the stream buffer has been created it can be assigned to the
|
|
* file scope variable, which will allow the tick interrupt to start
|
|
* using it. */
|
|
taskENTER_CRITICAL();
|
|
{
|
|
xInterruptStreamBuffer = xStreamBuffer;
|
|
}
|
|
taskEXIT_CRITICAL();
|
|
|
|
xBytesReceived = xStreamBufferReceive( xStreamBuffer, ( void * ) ucRxData, sizeof( ucRxData ), xReadBlockTime );
|
|
|
|
/* Set the file scope variable back to NULL so the interrupt doesn't
|
|
* try to use it again. */
|
|
taskENTER_CRITICAL();
|
|
{
|
|
xInterruptStreamBuffer = NULL;
|
|
}
|
|
taskEXIT_CRITICAL();
|
|
|
|
/* Now check the number of bytes received equals the trigger level,
|
|
* except in the case that the read timed out before the trigger level
|
|
* was reached. */
|
|
if( xTriggerLevel > xReadBlockTime )
|
|
{
|
|
/* Trigger level was greater than the block time so expect to
|
|
* time out having received xReadBlockTime bytes. */
|
|
if( xBytesReceived > xReadBlockTime )
|
|
{
|
|
/* Received more bytes than expected. That could happen if
|
|
* this task unblocked at the right time, but an interrupt
|
|
* added another byte to the stream buffer before this task was
|
|
* able to run. */
|
|
if( ( xBytesReceived - xReadBlockTime ) > xAllowableMargin )
|
|
{
|
|
xErrorDetected = pdTRUE;
|
|
}
|
|
}
|
|
else if( xReadBlockTime != xBytesReceived )
|
|
{
|
|
/* It is possible the interrupt placed an item in the stream
|
|
* buffer before this task called xStreamBufferReceive(), but
|
|
* if that is the case then xBytesReceived will only every be
|
|
* 0 as the interrupt will only have executed once. */
|
|
if( xBytesReceived != 1 )
|
|
{
|
|
xErrorDetected = pdTRUE;
|
|
}
|
|
}
|
|
}
|
|
else if( xTriggerLevel < xReadBlockTime )
|
|
{
|
|
/* Trigger level was less than the block time so we expect to
|
|
* have received the trigger level number of bytes - could be more
|
|
* though depending on other activity between the task being
|
|
* unblocked and the task reading the number of bytes received. It
|
|
* could also be less if the interrupt already put something in the
|
|
* stream buffer before this task attempted to read it - in which
|
|
* case the task would have returned the available bytes immediately
|
|
* without ever blocking - in that case the bytes received will
|
|
* only ever be 1 as the interrupt would not have executed more
|
|
* than one in that time unless this task has too low a priority. */
|
|
if( xBytesReceived < xTriggerLevel )
|
|
{
|
|
if( xBytesReceived != 1 )
|
|
{
|
|
xErrorDetected = pdTRUE;
|
|
}
|
|
}
|
|
else if( ( xBytesReceived - xTriggerLevel ) > xAllowableMargin )
|
|
{
|
|
xErrorDetected = pdTRUE;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
/* The trigger level equalled the block time, so expect to
|
|
* receive no greater than the block time. It could also be less
|
|
* if the interrupt already put something in the stream buffer
|
|
* before this task attempted to read it - in which case the task
|
|
* would have returned the available bytes immediately without ever
|
|
* blocking - in that case the bytes received would only ever be 1
|
|
* because the interrupt is not going to execute twice in that time
|
|
* unless this task is running a too low a priority. */
|
|
if( xBytesReceived < xReadBlockTime )
|
|
{
|
|
if( xBytesReceived != 1 )
|
|
{
|
|
xErrorDetected = pdTRUE;
|
|
}
|
|
}
|
|
else if( ( xBytesReceived - xReadBlockTime ) > xAllowableMargin )
|
|
{
|
|
xErrorDetected = pdTRUE;
|
|
}
|
|
}
|
|
|
|
if( xBytesReceived > sizeof( ucRxData ) )
|
|
{
|
|
xErrorDetected = pdTRUE;
|
|
}
|
|
else if( memcmp( ( void * ) ucRxData, ( const void * ) pcDataSentFromInterrupt, xBytesReceived ) != 0 )
|
|
{
|
|
/* Received data didn't match that expected. */
|
|
xErrorDetected = pdTRUE;
|
|
}
|
|
|
|
if( xErrorDetected == pdFALSE )
|
|
{
|
|
/* Increment the cycle counter so the 'check' task knows this test
|
|
* is still running without error. */
|
|
ulInterruptTriggerCounter++;
|
|
}
|
|
|
|
/* Tidy up ready for the next loop. */
|
|
vStreamBufferDelete( xStreamBuffer );
|
|
}
|
|
}
|
|
}
|
|
/*-----------------------------------------------------------*/
|
|
|
|
BaseType_t xAreStreamBufferTasksStillRunning( void )
|
|
{
|
|
static uint32_t ulLastEchoLoopCounters[ sbNUMBER_OF_ECHO_CLIENTS ] = { 0 };
|
|
static uint32_t ulLastNonBlockingRxCounter = 0;
|
|
static uint32_t ulLastInterruptTriggerCounter = 0;
|
|
BaseType_t x;
|
|
|
|
for( x = 0; x < sbNUMBER_OF_ECHO_CLIENTS; x++ )
|
|
{
|
|
if( ulLastEchoLoopCounters[ x ] == ulEchoLoopCounters[ x ] )
|
|
{
|
|
xErrorStatus = pdFAIL;
|
|
}
|
|
else
|
|
{
|
|
ulLastEchoLoopCounters[ x ] = ulEchoLoopCounters[ x ];
|
|
}
|
|
}
|
|
|
|
if( ulNonBlockingRxCounter == ulLastNonBlockingRxCounter )
|
|
{
|
|
xErrorStatus = pdFAIL;
|
|
}
|
|
else
|
|
{
|
|
ulLastNonBlockingRxCounter = ulNonBlockingRxCounter;
|
|
}
|
|
|
|
if( ulLastInterruptTriggerCounter == ulInterruptTriggerCounter )
|
|
{
|
|
xErrorStatus = pdFAIL;
|
|
}
|
|
else
|
|
{
|
|
ulLastInterruptTriggerCounter = ulInterruptTriggerCounter;
|
|
}
|
|
|
|
#if ( configSUPPORT_STATIC_ALLOCATION == 1 )
|
|
{
|
|
static uint32_t ulLastSenderLoopCounters[ sbNUMBER_OF_ECHO_CLIENTS ] = { 0 };
|
|
|
|
for( x = 0; x < sbNUMBER_OF_SENDER_TASKS; x++ )
|
|
{
|
|
if( ulLastSenderLoopCounters[ x ] == ulSenderLoopCounters[ x ] )
|
|
{
|
|
xErrorStatus = pdFAIL;
|
|
}
|
|
else
|
|
{
|
|
ulLastSenderLoopCounters[ x ] = ulSenderLoopCounters[ x ];
|
|
}
|
|
}
|
|
}
|
|
#endif /* configSUPPORT_STATIC_ALLOCATION */
|
|
|
|
return xErrorStatus;
|
|
}
|
|
/*-----------------------------------------------------------*/
|