Demo/Linux_Drivers
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[freertos] add freertos firmware

Browse Source 
Change-Id: I4158d66d9b5fc444e28287f55e79ac24e0a1666f
This commit is contained in:
sam.xiang
2023-02-23 11:39:27 +08:00
parent 1cf39ecdd5
commit cbb030f19f
398 changed files with 151104 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

224
freertos/cvitek/task/demo/Common/Minimal/crhook.c Normal file
View File

@ -0,0 +1,224 @@
/*
* FreeRTOS Kernel V10.3.0
* 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.
*
* http://www.FreeRTOS.org
* http://aws.amazon.com/freertos
*
* 1 tab == 4 spaces!
*/
/*
* This demo file demonstrates how to send data between an ISR and a
* co-routine. A tick hook function is used to periodically pass data between
* the RTOS tick and a set of 'hook' co-routines.
*
* hookNUM_HOOK_CO_ROUTINES co-routines are created. Each co-routine blocks
* to wait for a character to be received on a queue from the tick ISR, checks
* to ensure the character received was that expected, then sends the number
* back to the tick ISR on a different queue.
*
* The tick ISR checks the numbers received back from the 'hook' co-routines
* matches the number previously sent.
*
* If at any time a queue function returns unexpectedly, or an incorrect value
* is received either by the tick hook or a co-routine then an error is
* latched.
*
* This demo relies on each 'hook' co-routine to execute between each
* hookTICK_CALLS_BEFORE_POST tick interrupts. This and the heavy use of
* queues from within an interrupt may result in an error being detected on
* slower targets simply due to timing.
*/
/* Scheduler includes. */
#include "FreeRTOS.h"
#include "croutine.h"
#include "queue.h"
/* Demo application includes. */
#include "crhook.h"
/* The number of 'hook' co-routines that are to be created. */
#define hookNUM_HOOK_CO_ROUTINES (4)
/* The number of times the tick hook should be called before a character is
posted to the 'hook' co-routines. */
#define hookTICK_CALLS_BEFORE_POST (500)
/* There should never be more than one item in any queue at any time. */
#define hookHOOK_QUEUE_LENGTH (1)
/* Don't block when initially posting to the queue. */
#define hookNO_BLOCK_TIME (0)
/* The priority relative to other co-routines (rather than tasks) that the
'hook' co-routines should take. */
#define mainHOOK_CR_PRIORITY (1)
/*-----------------------------------------------------------*/
/*
* The co-routine function itself.
*/
static void prvHookCoRoutine(CoRoutineHandle_t xHandle, UBaseType_t uxIndex);
/*
* The tick hook function. This receives a number from each 'hook' co-routine
* then sends a number to each co-routine. An error is flagged if a send or
* receive fails, or an unexpected number is received.
*/
void vApplicationTickHook(void);
/*-----------------------------------------------------------*/
/* Queues used to send data FROM a co-routine TO the tick hook function.
The hook functions received (Rx's) on these queues. One queue per
'hook' co-routine. */
static QueueHandle_t xHookRxQueues[hookNUM_HOOK_CO_ROUTINES];
/* Queues used to send data FROM the tick hook TO a co-routine function.
The hood function transmits (Tx's) on these queues. One queue per
'hook' co-routine. */
static QueueHandle_t xHookTxQueues[hookNUM_HOOK_CO_ROUTINES];
/* Set to true if an error is detected at any time. */
static BaseType_t xCoRoutineErrorDetected = pdFALSE;
/*-----------------------------------------------------------*/
void vStartHookCoRoutines(void)
{
UBaseType_t uxIndex, uxValueToPost = 0;
for (uxIndex = 0; uxIndex < hookNUM_HOOK_CO_ROUTINES; uxIndex++) {
/* Create a queue to transmit to and receive from each 'hook'
co-routine. */
xHookRxQueues[uxIndex] = xQueueCreate(hookHOOK_QUEUE_LENGTH,
sizeof(UBaseType_t));
xHookTxQueues[uxIndex] = xQueueCreate(hookHOOK_QUEUE_LENGTH,
sizeof(UBaseType_t));
/* To start things off the tick hook function expects the queue it
uses to receive data to contain a value. */
xQueueSend(xHookRxQueues[uxIndex], &uxValueToPost,
hookNO_BLOCK_TIME);
/* Create the 'hook' co-routine itself. */
xCoRoutineCreate(prvHookCoRoutine, mainHOOK_CR_PRIORITY,
uxIndex);
}
}
/*-----------------------------------------------------------*/
static UBaseType_t uxCallCounter = 0, uxNumberToPost = 0;
void vApplicationTickHook(void)
{
UBaseType_t uxReceivedNumber;
BaseType_t xIndex, xCoRoutineWoken;
/* Is it time to talk to the 'hook' co-routines again? */
uxCallCounter++;
if (uxCallCounter >= hookTICK_CALLS_BEFORE_POST) {
uxCallCounter = 0;
for (xIndex = 0; xIndex < hookNUM_HOOK_CO_ROUTINES; xIndex++) {
xCoRoutineWoken = pdFALSE;
if (crQUEUE_RECEIVE_FROM_ISR(
xHookRxQueues[xIndex], &uxReceivedNumber,
&xCoRoutineWoken) != pdPASS) {
/* There is no reason why we would not expect the queue to
contain a value. */
xCoRoutineErrorDetected = pdTRUE;
} else {
/* Each queue used to receive data from the 'hook' co-routines
should contain the number we last posted to the same co-routine. */
if (uxReceivedNumber != uxNumberToPost) {
xCoRoutineErrorDetected = pdTRUE;
}
/* Nothing should be blocked waiting to post to the queue. */
if (xCoRoutineWoken != pdFALSE) {
xCoRoutineErrorDetected = pdTRUE;
}
}
}
/* Start the next cycle by posting the next number onto each Tx queue. */
uxNumberToPost++;
for (xIndex = 0; xIndex < hookNUM_HOOK_CO_ROUTINES; xIndex++) {
if (crQUEUE_SEND_FROM_ISR(xHookTxQueues[xIndex],
&uxNumberToPost,
pdFALSE) != pdTRUE) {
/* Posting to the queue should have woken the co-routine that
was blocked on the queue. */
xCoRoutineErrorDetected = pdTRUE;
}
}
}
}
/*-----------------------------------------------------------*/
static void prvHookCoRoutine(CoRoutineHandle_t xHandle, UBaseType_t uxIndex)
{
static UBaseType_t uxReceivedValue[hookNUM_HOOK_CO_ROUTINES];
BaseType_t xResult;
/* Each co-routine MUST start with a call to crSTART(); */
crSTART(xHandle);
for (;;) {
/* Wait to receive a value from the tick hook. */
xResult = pdFAIL;
crQUEUE_RECEIVE(xHandle, xHookTxQueues[uxIndex],
&(uxReceivedValue[uxIndex]), portMAX_DELAY,
&xResult);
/* There is no reason why we should not have received something on
the queue. */
if (xResult != pdPASS) {
xCoRoutineErrorDetected = pdTRUE;
}
/* Send the same number back to the idle hook so it can verify it. */
xResult = pdFAIL;
crQUEUE_SEND(xHandle, xHookRxQueues[uxIndex],
&(uxReceivedValue[uxIndex]), hookNO_BLOCK_TIME,
&xResult);
if (xResult != pdPASS) {
/* There is no reason why we should not have been able to post to
the queue. */
xCoRoutineErrorDetected = pdTRUE;
}
}
/* Each co-routine MUST end with a call to crEND(). */
crEND();
}
/*-----------------------------------------------------------*/
BaseType_t xAreHookCoRoutinesStillRunning(void)
{
if (xCoRoutineErrorDetected) {
return pdFALSE;
} else {
return pdTRUE;
}
}