6-FreeRTOS流缓冲区

1/*
  2* FreeRTOS V202112.00
  3* Copyright (C) 2020 Amazon.com, Inc. or its affiliates. All Rights Reserved.
  4*
  5* Permission is hereby granted, free of charge, to any person obtaining a copy of
  6* this software and associated documentation files (the "Software"), to deal in
  7* the Software without restriction, including without limitation the rights to
  8* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
  9* the Software, and to permit persons to whom the Software is furnished to do so,
 10* subject to the following conditions:
 11*
 12* The above copyright notice and this permission notice shall be included in all
 13* copies or substantial portions of the Software.
 14*
 15* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
 16* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
 17* FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 18* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
 19* IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
 20* CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 21*
 22* http://www.FreeRTOS.org
 23* http://aws.amazon.com/freertos
 24*
 25* 1 tab == 4 spaces!
 26*/
 27
 28/*
 29* A simple example that shows a stream buffer being used to pass data from an
 30* interrupt to a task.
 31*
 32* There are two strings, pcStringToSend and pcStringToReceive, where
 33* pcStringToReceive is a substring of pcStringToSend. The interrupt sends
 34* a few bytes of pcStringToSend to a stream buffer ever few times that it
 35* executes. A task reads the bytes from the stream buffer, looking for the
 36* substring, and flagging an error if the received data is invalid.
 37*/
 38
 39/* Standard includes. */
 40#include "stdio.h"
 41#include "string.h"
 42
 43/* FreeRTOS includes. */
 44#include "FreeRTOS.h"
 45#include "task.h"
 46#include "stream_buffer.h"
 47
 48/* Demo app includes. */
 49#include "StreamBufferInterrupt.h"
 50
 51#define sbiSTREAM_BUFFER_LENGTH_BYTES ( ( size_t ) 100 )
 52#define sbiSTREAM_BUFFER_TRIGGER_LEVEL_10 ( ( BaseType_t ) 10 )
 53
 54/*-----------------------------------------------------------*/
 55
 56/* Implements the task that receives a stream of bytes from the interrupt. */
 57static void prvReceivingTask( void * pvParameters );
 58
 59/*-----------------------------------------------------------*/
 60
 61/* The stream buffer that is used to send data from an interrupt to the task. */
 62static StreamBufferHandle_t xStreamBuffer = NULL;
 63
 64/* The string that is sent from the interrupt to the task four bytes at a
 65* time. Must be multiple of 4 bytes long as the ISR sends 4 bytes at a time*/
 66static const char * pcStringToSend = "_____Hello FreeRTOS_____";
 67
 68/* The string to task is looking for, which must be a substring of
 69* pcStringToSend. */
 70static const char * pcStringToReceive = "Hello FreeRTOS";
 71
 72/* Set to pdFAIL if anything unexpected happens. */
 73static BaseType_t xDemoStatus = pdPASS;
 74
 75/* Incremented each time pcStringToReceive is correctly received, provided no
 76* errors have occurred. Used so the check task can check this task is still
 77* running as expected. */
 78static uint32_t ulCycleCount = 0;
 79
 80/*-----------------------------------------------------------*/
 81
 82void vStartStreamBufferInterruptDemo( void )
 83{
 84/* Create the stream buffer that sends data from the interrupt to the
 85* task, and create the task. */
 86xStreamBuffer = xStreamBufferCreate( /* The buffer length in bytes. */
 87sbiSTREAM_BUFFER_LENGTH_BYTES,
 88/* The stream buffer's trigger level. */
 89sbiSTREAM_BUFFER_TRIGGER_LEVEL_10 );
 90
 91xTaskCreate( prvReceivingTask, /* The function that implements the task. */
 92"StrIntRx", /* Human readable name for the task. */
 93configMINIMAL_STACK_SIZE, /* Stack size (in words!). */
 94NULL, /* Task parameter is not used. */
 95tskIDLE_PRIORITY + 2, /* The priority at which the task is created. */
 96NULL ); /* No use for the task handle. */
 97}
 98/*-----------------------------------------------------------*/
 99
100static void prvReceivingTask( void * pvParameters )
101{
102char cRxBuffer[ 20 ];
103BaseType_t xNextByte = 0;
104
105/* Remove warning about unused parameters. */
106( void ) pvParameters;
107
108/* Make sure the string will fit in the Rx buffer, including the NULL
109* terminator. */
110configASSERT( sizeof( cRxBuffer ) > strlen( pcStringToReceive ) );
111
112/* Make sure the stream buffer has been created. */
113configASSERT( xStreamBuffer != NULL );
114
115/* Start with the Rx buffer in a known state. */
116memset( cRxBuffer, 0x00, sizeof( cRxBuffer ) );
117
118for( ; ; )
119{
120/* Keep receiving characters until the end of the string is received.
121* Note: An infinite block time is used to simplify the example. Infinite
122* block times are not recommended in production code as they do not allow
123* for error recovery. */
124xStreamBufferReceive( /* The stream buffer data is being received from. */
125xStreamBuffer,
126/* Where to place received data. */
127( void * ) &( cRxBuffer[ xNextByte ] ),
128/* The number of bytes to receive. */
129sizeof( char ),
130
131/* The time to wait for the next data if the buffer
132* is empty. */
133portMAX_DELAY );
134
135/* If xNextByte is 0 then this task is looking for the start of the
136* string, which is 'H'. */
137if( xNextByte == 0 )
138{
139if( cRxBuffer[ xNextByte ] == 'H' )
140{
141/* The start of the string has been found. Now receive
142* characters until the end of the string is found. */
143xNextByte++;
144}
145}
146else
147{
148/* Receiving characters while looking for the end of the string,
149* which is an 'S'. */
150if( cRxBuffer[ xNextByte ] == 'S' )
151{
152/* The string has now been received. Check its validity. */
153if( strcmp( cRxBuffer, pcStringToReceive ) != 0 )
154{
155xDemoStatus = pdFAIL;
156}
157
158/* Return to start looking for the beginning of the string
159* again. */
160memset( cRxBuffer, 0x00, sizeof( cRxBuffer ) );
161xNextByte = 0;
162
163/* Increment the cycle count as an indication to the check task
164* that this demo is still running. */
165if( xDemoStatus == pdPASS )
166{
167ulCycleCount++;
168}
169}
170else
171{
172/* Receive the next character the next time around, while
173* continuing to look for the end of the string. */
174xNextByte++;
175
176configASSERT( ( size_t ) xNextByte < sizeof( cRxBuffer ) );
177}
178}
179}
180}
181/*-----------------------------------------------------------*/
182
183void vBasicStreamBufferSendFromISR( void )
184{
185static size_t xNextByteToSend = 0;
186const BaseType_t xCallsBetweenSends = 100, xBytesToSend = 4;
187static BaseType_t xCallCount = 0;
188
189/* Is it time to write to the stream buffer again? */
190xCallCount++;
191
192if( xCallCount > xCallsBetweenSends )
193{
194xCallCount = 0;
195
196/* Send the next four bytes to the stream buffer. */
197xStreamBufferSendFromISR( xStreamBuffer,
198( const void * ) ( pcStringToSend + xNextByteToSend ),
199xBytesToSend,
200NULL );
201
202/* Send the next four bytes the next time around, wrapping to the start
203* of the string if necessary. */
204xNextByteToSend += xBytesToSend;
205
206if( xNextByteToSend >= strlen( pcStringToSend ) )
207{
208xNextByteToSend = 0;
209}
210}
211}
212/*-----------------------------------------------------------*/
213
214BaseType_t xIsInterruptStreamBufferDemoStillRunning( void )
215{
216uint32_t ulLastCycleCount = 0;
217
218/* Check the demo is still running. */
219if( ulLastCycleCount == ulCycleCount )
220{
221xDemoStatus = pdFAIL;
222}
223else
224{
225ulLastCycleCount = ulCycleCount;
226}
227
228return xDemoStatus;
229}

1//1-xStreamBufferReceive（）
 2void vAFunction( StreamBuffer_t xStreamBuffer )
 3{
 4uint8_t ucRxData[ 20 ];
 5size_t xReceivedBytes;
 6const TickType_t xBlockTime = pdMS_TO_TICKS( 20 );
 7
 8/* Receive up to another sizeof( ucRxData ) bytes from the stream buffer.
 9Wait in the Blocked state (so not using any CPU processing time) for a
10maximum of 100ms for the full sizeof( ucRxData ) number of bytes to be
11available. */
12xReceivedBytes = xStreamBufferReceive( xStreamBuffer,
13( void * ) ucRxData,
14sizeof( ucRxData ),
15xBlockTime );
16
17if( xReceivedBytes > 0 )
18{
19/* A ucRxData contains another xRecievedBytes bytes of data, which can
20be processed here.... */
21}
22}
23
242--xStreamBufferReceiveFromISR（）
25
26/* A stream buffer that has already been created. */
27StreamBuffer_t xStreamBuffer;
28
29void vAnInterruptServiceRoutine( void )
30{
31uint8_t ucRxData[ 20 ];
32size_t xReceivedBytes;
33BaseType_t xHigherPriorityTaskWoken = pdFALSE; /* Initialised to pdFALSE. */
34
35/* Receive the next stream from the stream buffer. */
36xReceivedBytes = xStreamBufferReceiveFromISR( xStreamBuffer,
37( void * ) ucRxData,
38sizeof( ucRxData ),
39&xHigherPriorityTaskWoken );
40
41if( xReceivedBytes > 0 )
42{
43/* ucRxData contains xReceivedBytes read from the stream buffer.
44Process the stream here.... */
45}
46
47/* If xHigherPriorityTaskWoken was set to pdTRUE inside
48xStreamBufferReceiveFromISR() then a task that has a priority above the
49priority of the currently executing task was unblocked and a context
50switch should be performed to ensure the ISR returns to the unblocked
51task. In most FreeRTOS ports this is done by simply passing
52xHigherPriorityTaskWoken into taskYIELD_FROM_ISR(), which will test the
53variables value, and perform the context switch if necessary. Check the
54documentation for the port in use for port specific instructions. */
55taskYIELD_FROM_ISR( xHigherPriorityTaskWoken );
56}