/* * Copyright (C) 2018 Xilinx, Inc. * FreeRTOS V1.4.7 * 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://aws.amazon.com/freertos * http://www.FreeRTOS.org */ #include #include /* FreeRTOS includes. */ #include "FreeRTOS.h" #include "task.h" #include "FreeRTOS_IP.h" #include "FreeRTOS_Sockets.h" #include "FreeRTOS_DHCP.h" /* Demo includes */ #include "aws_demo.h" /* AWS System includes. */ #include "iot_system_init.h" #include "aws_clientcredential.h" #include "aws_dev_mode_key_provisioning.h" /* Demo application includes. */ #include "aws_demo_config.h" #include "aws_demo.h" #include "iot_logging_task.h" /* Logging Task Defines. */ #define mainLOGGING_MESSAGE_QUEUE_LENGTH ( 128 ) #define mainLOGGING_TASK_STACK_SIZE ( configMINIMAL_STACK_SIZE * 8 ) /* Unit test defines. */ #define mainTEST_RUNNER_TASK_STACK_SIZE ( configMINIMAL_STACK_SIZE * 16 ) /* The name of the devices for xApplicationDNSQueryHook. */ #define mainDEVICE_NICK_NAME "XilinxDemo" /** * @brief Application task startup hook for applications using Wi-Fi. If you are not * using Wi-Fi, then start network dependent applications in the vApplicationIPNetorkEventHook * function. If you are not using Wi-Fi, this hook can be disabled by setting * configUSE_DAEMON_TASK_STARTUP_HOOK to 0. */ void vApplicationDaemonTaskStartupHook( void ); /** * @brief Application IP network event hook called by the FreeRTOS+TCP stack for * applications using Ethernet. If you are not using Ethernet and the FreeRTOS+TCP stack, * start network dependent applications in vApplicationDaemonTaskStartupHook after the * network status is up. */ void vApplicationIPNetworkEventHook( eIPCallbackEvent_t eNetworkEvent ); /* * Just seeds the simple pseudo random number generator. */ static void prvSRand( UBaseType_t ulSeed ); /** * @brief Initializes the board. */ static void prvMiscInitialization( void ); /* Use by the pseudo random number generator. */ static UBaseType_t ulNextRand; /*-----------------------------------------------------------*/ /** * @brief Application runtime entry point. */ extern void vApplicationIPInit( void ); int main( void ) { /* Perform any hardware initialization that does not require the RTOS to be * running. */ prvMiscInitialization(); vApplicationIPInit(); /* Start the scheduler. Initialization that requires the OS to be running, * including the Wi-Fi initialization, is performed in the RTOS daemon task * startup hook. */ vTaskStartScheduler(); configPRINTF( ("vTaskStartScheduler complete - should not reach here \n\r") ); return 0; } /*-----------------------------------------------------------*/ UBaseType_t uxRand( void ) { const uint32_t ulMultiplier = 0x015a4e35UL, ulIncrement = 1UL; /* Utility function to generate a pseudo random number. */ ulNextRand = ( ulMultiplier * ulNextRand ) + ulIncrement; return( ( int ) ( ulNextRand >> 16UL ) & 0x7fffUL ); } /*-----------------------------------------------------------*/ static void prvSRand( UBaseType_t ulSeed ) { /* Utility function to seed the pseudo random number generator. */ ulNextRand = ulSeed; } extern int platform_init_fs(); static void prvMiscInitialization( void ) { time_t xTimeNow; /* Perform any hardware initializations, that don't require the RTOS to be * running, here. */ /* Start logging task. */ xLoggingTaskInitialize( mainLOGGING_TASK_STACK_SIZE, tskIDLE_PRIORITY, mainLOGGING_MESSAGE_QUEUE_LENGTH ); /* Seed the random number generator. */ time( &xTimeNow ); xil_printf("Seed for randomiser: %lu \n\r", xTimeNow); prvSRand( ( uint32_t ) xTimeNow ); xil_printf("Random numbers: %08X %08X %08X %08X\n\r", ipconfigRAND32(), ipconfigRAND32(), ipconfigRAND32(), ipconfigRAND32()); vPortInstallFreeRTOSVectorTable(); platform_init_fs(); } /*-----------------------------------------------------------*/ void vApplicationIPNetworkEventHook( eIPCallbackEvent_t eNetworkEvent ) { static BaseType_t xTasksAlreadyCreated = pdFALSE; uint32_t ulIPAddress, ulNetMask, ulGatewayAddress, ulDNSServerAddress; char cBuffer[ 16 ]; /* If the network has just come up...*/ if( eNetworkEvent == eNetworkUp ) { configPRINTF( ("Network connection successful.\n\r") ); if( ( xTasksAlreadyCreated == pdFALSE ) && ( SYSTEM_Init() == pdPASS ) ) { vDevModeKeyProvisioning(); DEMO_RUNNER_RunDemos(); xTasksAlreadyCreated = pdTRUE; } /* Print out the network configuration, which may have come from a DHCP * server. */ FreeRTOS_GetAddressConfiguration( &ulIPAddress, &ulNetMask, &ulGatewayAddress, &ulDNSServerAddress ); FreeRTOS_inet_ntoa( ulIPAddress, cBuffer ); FreeRTOS_printf( ( "\r\n\r\nIP Address: %s\r\n", cBuffer ) ); FreeRTOS_inet_ntoa( ulNetMask, cBuffer ); FreeRTOS_printf( ( "Subnet Mask: %s\r\n", cBuffer ) ); FreeRTOS_inet_ntoa( ulGatewayAddress, cBuffer ); FreeRTOS_printf( ( "Gateway Address: %s\r\n", cBuffer ) ); FreeRTOS_inet_ntoa( ulDNSServerAddress, cBuffer ); FreeRTOS_printf( ( "DNS Server Address: %s\r\n\r\n\r\n", cBuffer ) ); } } /*-----------------------------------------------------------*/ /** * @brief User defined Idle task function. * * @note Do not make any blocking operations in this function. */ void vApplicationIdleHook( void ) { static TickType_t xLastPrint = 0; TickType_t xTimeNow; const TickType_t xPrintFrequency = pdMS_TO_TICKS( 5000 ); xTimeNow = xTaskGetTickCount(); if( ( xTimeNow - xLastPrint ) > xPrintFrequency ) { configPRINT( "." ); xLastPrint = xTimeNow; } } struct tm *gmtime_r( const time_t *pxTime, struct tm *tmStruct ) { /* Dummy time functions to keep the file system happy in the absence of target support. */ memcpy( tmStruct, gmtime( pxTime ), sizeof( * tmStruct ) ); return tmStruct; } /*-----------------------------------------------------------*/ time_t FreeRTOS_time( time_t *pxTime ) { time_t xReturn; xReturn = time( &xReturn ); if( pxTime != NULL ) { *pxTime = xReturn; } return xReturn; } /*-----------------------------------------------------------*/ /** * @brief User defined application hook to process names returned by the DNS server. */ #if ( ipconfigUSE_LLMNR != 0 ) || ( ipconfigUSE_NBNS != 0 ) BaseType_t xApplicationDNSQueryHook( const char * pcName ) { FreeRTOS_debug_printf( ( "xApplicationDNSQueryHook: %s \n\r", pcName ) ); BaseType_t xReturn; /* Determine if a name lookup is for this node. Two names are given * to this node: that returned by pcApplicationHostnameHook() and that set * by mainDEVICE_NICK_NAME. */ if( strcmp( pcName, pcApplicationHostnameHook() ) == 0 ) { xReturn = pdPASS; } else if( strcmp( pcName, mainDEVICE_NICK_NAME ) == 0 ) { xReturn = pdPASS; } else { xReturn = pdFAIL; } return xReturn; } #endif /* if ( ipconfigUSE_LLMNR != 0 ) || ( ipconfigUSE_NBNS != 0 ) */ /*-----------------------------------------------------------*/ struct timezone; struct timeval; int _gettimeofday_r(struct _reent * x, struct timeval *y , struct timezone * ptimezone ) { ( void ) x; ( void ) y; ( void ) ptimezone; return 0; } /*-----------------------------------------------------------*/ /* Called automatically when a reply to an outgoing ping is received. */ void vApplicationPingReplyHook( ePingReplyStatus_t eStatus, uint16_t usIdentifier ) { static const char *pcSuccess = "Ping reply received - "; static const char *pcInvalidChecksum = "Ping reply received with invalid checksum - "; static const char *pcInvalidData = "Ping reply received with invalid data - "; configPRINTF( ("vApplicationPingReplyHook \n\r") ); switch( eStatus ) { case eSuccess : FreeRTOS_printf( ( pcSuccess ) ); break; case eInvalidChecksum : FreeRTOS_printf( ( pcInvalidChecksum ) ); break; case eInvalidData : FreeRTOS_printf( ( pcInvalidData ) ); break; default : /* It is not possible to get here as all enums have their own case. */ break; } FreeRTOS_debug_printf( ( "identifier %d\r\n", ( int ) usIdentifier ) ); /* Prevent compiler warnings in case FreeRTOS_debug_printf() is not defined. */ ( void ) usIdentifier; } /** * @brief User defined assertion call. This function is plugged into configASSERT. * See FreeRTOSConfig.h to define configASSERT to something different. */ void vAssertCalled(const char * pcFile, uint32_t ulLine) { const uint32_t ulLongSleep = 1000UL; volatile uint32_t ulBlockVariable = 0UL; volatile char * pcFileName = (volatile char *)pcFile; volatile uint32_t ulLineNumber = ulLine; (void)pcFileName; (void)ulLineNumber; configPRINTF( ("vAssertCalled %s, %ld\n", pcFile, (long)ulLine) ); fflush(stdout); /* Setting ulBlockVariable to a non-zero value in the debugger will allow * this function to be exited. */ taskDISABLE_INTERRUPTS(); { while (ulBlockVariable == 0UL) { vTaskDelay( pdMS_TO_TICKS( ulLongSleep ) ); } } taskENABLE_INTERRUPTS(); } /*-----------------------------------------------------------*/ void vApplicationDaemonTaskStartupHook( void ) { }