text: /*
   * 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
   */
  
  /* Standard includes. */
  #include <time.h>
  
  /* FreeRTOS includes. */
  #include "FreeRTOS.h"
  #include "task.h"
  #include "FreeRTOS_IP.h"
  #include "FreeRTOS_Sockets.h"
  #include "task.h"
  
  /* AWS System includes. */
  #include "aws_application_version.h"
  #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"
  #include "sys_module.h"
  
  /* Application version info. */
  #include "aws_application_version.h"
  
  /* Sleep on this platform */
  #define Sleep( nMs )    vTaskDelay( pdMS_TO_TICKS( nMs ) );
  
  #define mainDEVICE_NICK_NAME                "Microchip_Demo"
  
  #define mainLOGGING_TASK_STACK_SIZE         ( configMINIMAL_STACK_SIZE * 5 )
  #define mainLOGGING_MESSAGE_QUEUE_LENGTH    ( 128 )
  
  
  /**
   * @brief Application task startup hook.
   */
  void vApplicationDaemonTaskStartupHook( void );
  
  /**
   * @brief Initializes the board.
   */
  static void prvMiscInitialization( void );
  
  /*-----------------------------------------------------------*/
  
  /**
   * @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 WiFi initialization, is performed in the RTOS daemon task
       * startup hook. */
      vTaskStartScheduler();
  
      return 0;
  }
  /*-----------------------------------------------------------*/
  
  static void prvMiscInitialization( void )
  {
      /* Start logging task. */
      xLoggingTaskInitialize( mainLOGGING_TASK_STACK_SIZE,
                              tskIDLE_PRIORITY,
                              mainLOGGING_MESSAGE_QUEUE_LENGTH );
  
      SYS_Initialize( NULL );
      SYS_Tasks();
  }
  /*-----------------------------------------------------------*/
  
  void vApplicationIPNetworkEventHook( eIPCallbackEvent_t eNetworkEvent )
  {
      uint32_t ulIPAddress, ulNetMask, ulGatewayAddress, ulDNSServerAddress;
      char cBuffer[ 16 ];
      static BaseType_t xTasksAlreadyCreated = pdFALSE;
  
      /* If the network has just come up...*/
      if( eNetworkEvent == eNetworkUp )
      {
          /* The network is up so we can run. */
          if( ( SYSTEM_Init() == pdPASS ) && ( xTasksAlreadyCreated == pdFALSE ) )
          {
              /* A simple example to demonstrate key and certificate provisioning in
               * microcontroller flash using PKCS#11 interface. This should be replaced
               * by production ready key provisioning mechanism. */
              vDevModeKeyProvisioning();
  
              /* Run all demos. */
              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 ) );
      }
  }
  /*-----------------------------------------------------------*/
  
  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 ) );
  
      /* Setting ulBlockVariable to a non-zero value in the debugger will allow
       * this function to be exited. */
      taskDISABLE_INTERRUPTS();
      {
          while( ulBlockVariable == 0UL )
          {
              Sleep( ulLongSleep );
          }
      }
      taskENABLE_INTERRUPTS();
  }
  /*-----------------------------------------------------------*/
  
  #if ( ipconfigUSE_LLMNR != 0 ) || ( ipconfigUSE_NBNS != 0 )
  
      BaseType_t xApplicationDNSQueryHook( const char * 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 ) */
  /*-----------------------------------------------------------*/
  
  
  void vApplicationIdleHook( void )
  {
      const uint32_t ulMSToSleep = 1;
      const TickType_t xIdleCheckPeriod = pdMS_TO_TICKS( 1000UL );
      static TickType_t xTimeNow, xLastTimeCheck = 0;
  
      /* vApplicationIdleHook() will only be called if configUSE_IDLE_HOOK is set
       * to 1 in FreeRTOSConfig.h.  It will be called on each iteration of the idle
       * task.  It is essential that code added to this hook function never attempts
       * to block in any way (for example, call xQueueReceive() with a block time
       * specified, or call vTaskDelay()).  If application tasks make use of the
       * vTaskDelete() API function to delete themselves then it is also important
       * that vApplicationIdleHook() is permitted to return to its calling function,
       * because it is the responsibility of the idle task to clean up memory
       * allocated by the kernel to any task that has since deleted itself. */
  
      xTimeNow = xTaskGetTickCount();
  
      if( ( xTimeNow - xLastTimeCheck ) > xIdleCheckPeriod )
      {
          /* do something in the idle task */
          xLastTimeCheck = xTimeNow;
      }
  
      /* This is just a trivial example of an idle hook.  It is called on each
       * cycle of the idle task if configUSE_IDLE_HOOK is set to 1 in
       * FreeRTOSConfig.h.  It must *NOT* attempt to block.  In this case the
       * idle task just sleeps to lower the CPU usage. */
      Sleep( ulMSToSleep );
  }
  /*-----------------------------------------------------------*/
  
  
  