/* | |
* 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! | |
*/ | |
/*** | |
* See https://www.FreeRTOS.org/task-pool/ for configuration and usage instructions. | |
***/ | |
/* Standard includes. */ | |
#include <stdio.h> | |
#include <time.h> | |
/* Visual studio intrinsics used so the __debugbreak() function is available | |
should an assert get hit. */ | |
#include <intrin.h> | |
/* FreeRTOS includes. */ | |
#include <FreeRTOS.h> | |
#include "task.h" | |
/* TCP/IP stack includes. */ | |
#include "FreeRTOS_IP.h" | |
/* | |
* Prototypes for the demos that can be started from this project. | |
*/ | |
extern void vStartSimpleTaskPoolDemo( void ); | |
/* This example is the first in a sequence that adds IoT functionality into | |
an existing TCP/IP project. In this first project the TCP/IP stack is not | |
actually used, but it is still built, which requires this array to be | |
present. */ | |
const uint8_t ucMACAddress[ 6 ] = { configMAC_ADDR0, configMAC_ADDR1, configMAC_ADDR2, configMAC_ADDR3, configMAC_ADDR4, configMAC_ADDR5 }; | |
/*-----------------------------------------------------------*/ | |
int main( void ) | |
{ | |
/*** | |
* See https://www.FreeRTOS.org/task-pool/ for configuration and usage instructions. | |
***/ | |
/* Create the example that demonstrates task pool functionality. Examples | |
that demonstrate networking connectivity will be added in future projects | |
and get started after the network has connected (from within the | |
vApplicationIPNetworkEventHook() function).*/ | |
vStartSimpleTaskPoolDemo(); | |
/* Start the scheduler - if all is well from this point on only FreeRTOS | |
tasks will execute. */ | |
vTaskStartScheduler(); | |
/* If all is well, the scheduler will now be running, and the following | |
line will never be reached. If the following line does execute, then | |
there was insufficient FreeRTOS heap memory available for the idle and/or | |
timer tasks to be created. See the memory management section on the | |
FreeRTOS web site for more details (this is standard text that is not | |
really applicable to the Win32 simulator port). */ | |
for( ;; ) | |
{ | |
__debugbreak(); | |
} | |
} | |
/*-----------------------------------------------------------*/ | |
void vAssertCalled( const char *pcFile, uint32_t ulLine ) | |
{ | |
volatile uint32_t ulBlockVariable = 0UL; | |
volatile char *pcFileName = ( volatile char * ) pcFile; | |
volatile uint32_t ulLineNumber = ulLine; | |
( void ) pcFileName; | |
( void ) ulLineNumber; | |
printf( "vAssertCalled( %s, %u\n", pcFile, ulLine ); | |
/* Setting ulBlockVariable to a non-zero value in the debugger will allow | |
this function to be exited. */ | |
taskDISABLE_INTERRUPTS(); | |
{ | |
while( ulBlockVariable == 0UL ) | |
{ | |
__debugbreak(); | |
} | |
} | |
taskENABLE_INTERRUPTS(); | |
} | |
/*-----------------------------------------------------------*/ | |
/* Called by FreeRTOS+TCP when the network connects or disconnects. Disconnect | |
events are only received if implemented in the MAC driver. */ | |
void vApplicationIPNetworkEventHook( eIPCallbackEvent_t eNetworkEvent ) | |
{ | |
/* This example is the first in a sequence that adds IoT functionality into | |
an existing TCP/IP project. In this first project the TCP/IP stack is not | |
actually used, but it is still built, which requires this function to be | |
present. For now this function does not need to do anything, so just ensure | |
the unused parameters don't cause compiler warnings and that calls to this | |
function are trapped by the debugger. */ | |
__debugbreak(); | |
( void ) eNetworkEvent; | |
} | |
/*-----------------------------------------------------------*/ | |
extern uint32_t ulApplicationGetNextSequenceNumber( uint32_t ulSourceAddress, | |
uint16_t usSourcePort, | |
uint32_t ulDestinationAddress, | |
uint16_t usDestinationPort ) | |
{ | |
/* This example is the first in a sequence that adds IoT functionality into | |
an existing TCP/IP project. In this first project the TCP/IP stack is not | |
actually used, but it is still built, which requires this function to be | |
present. For now this function does not need to do anything, so just ensure | |
the unused parameters don't cause compiler warnings and that calls to this | |
function are trapped by the debugger. */ | |
( void ) ulSourceAddress; | |
( void ) usSourcePort; | |
( void ) ulDestinationAddress; | |
( void ) usDestinationPort; | |
__debugbreak(); | |
return 0; | |
} | |
/*-----------------------------------------------------------*/ | |
/* | |
* Supply a random number to FreeRTOS+TCP stack. | |
* THIS IS ONLY A DUMMY IMPLEMENTATION THAT RETURNS A PSEUDO RANDOM NUMBER | |
* SO IS NOT INTENDED FOR USE IN PRODUCTION SYSTEMS. | |
*/ | |
BaseType_t xApplicationGetRandomNumber(uint32_t* pulNumber) | |
{ | |
/* This example is the first in a sequence that adds IoT functionality into | |
an existing TCP / IP project.In this first project the TCP / IP stack is not | |
actually used, but it is still built, which requires this function to be | |
present.For now this function does not need to do anything. */ | |
__debugbreak(); | |
*(pulNumber) = 0; | |
return pdFALSE; | |
} | |
/*-----------------------------------------------------------*/ | |
UBaseType_t uxRand( void ) | |
{ | |
/* This example is the first in a sequence that adds IoT functionality into | |
an existing TCP/IP project. In this first project the TCP/IP stack is not | |
actually used, but it is still built, which requires this function to be | |
present. For now this function does not need to do anything, so just ensure | |
the calls to the function are trapped by the debugger. */ | |
__debugbreak(); | |
return 0; | |
} | |
/*-----------------------------------------------------------*/ | |
/* configUSE_STATIC_ALLOCATION is set to 1, so the application must provide an | |
implementation of vApplicationGetIdleTaskMemory() to provide the memory that is | |
used by the Idle task. */ | |
void vApplicationGetIdleTaskMemory( StaticTask_t** ppxIdleTaskTCBBuffer, StackType_t** ppxIdleTaskStackBuffer, uint32_t* pulIdleTaskStackSize ) | |
{ | |
/* If the buffers to be provided to the Idle task are declared inside this | |
function then they must be declared static - otherwise they will be allocated on | |
the stack and so not exists after this function exits. */ | |
static StaticTask_t xIdleTaskTCB; | |
static StackType_t uxIdleTaskStack[configMINIMAL_STACK_SIZE]; | |
/* Pass out a pointer to the StaticTask_t structure in which the Idle task's | |
state will be stored. */ | |
*ppxIdleTaskTCBBuffer = &xIdleTaskTCB; | |
/* Pass out the array that will be used as the Idle task's stack. */ | |
*ppxIdleTaskStackBuffer = uxIdleTaskStack; | |
/* Pass out the size of the array pointed to by *ppxIdleTaskStackBuffer. | |
Note that, as the array is necessarily of type StackType_t, | |
configMINIMAL_STACK_SIZE is specified in words, not bytes. */ | |
*pulIdleTaskStackSize = configMINIMAL_STACK_SIZE; | |
} | |
/*-----------------------------------------------------------*/ | |
/* configUSE_STATIC_ALLOCATION and configUSE_TIMERS are both set to 1, so the | |
application must provide an implementation of vApplicationGetTimerTaskMemory() | |
to provide the memory that is used by the Timer service task. */ | |
void vApplicationGetTimerTaskMemory( StaticTask_t** ppxTimerTaskTCBBuffer, StackType_t** ppxTimerTaskStackBuffer, uint32_t* pulTimerTaskStackSize ) | |
{ | |
/* If the buffers to be provided to the Timer task are declared inside this | |
function then they must be declared static - otherwise they will be allocated on | |
the stack and so not exists after this function exits. */ | |
static StaticTask_t xTimerTaskTCB; | |
static StackType_t uxTimerTaskStack[configTIMER_TASK_STACK_DEPTH]; | |
/* Pass out a pointer to the StaticTask_t structure in which the Timer | |
task's state will be stored. */ | |
*ppxTimerTaskTCBBuffer = &xTimerTaskTCB; | |
/* Pass out the array that will be used as the Timer task's stack. */ | |
*ppxTimerTaskStackBuffer = uxTimerTaskStack; | |
/* Pass out the size of the array pointed to by *ppxTimerTaskStackBuffer. | |
Note that, as the array is necessarily of type StackType_t, | |
configMINIMAL_STACK_SIZE is specified in words, not bytes. */ | |
*pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH; | |
} | |