git.sur5r.net Git - freertos/blob - FreeRTOS-Labs/Demo/FreeRTOS_IoT_Libraries/mqtt/common/main.c

   1 /*\r
   2  * FreeRTOS Kernel V10.2.1\r
   3  * Copyright (C) 2019 Amazon.com, Inc. or its affiliates.  All Rights Reserved.\r
   4  *\r
   5  * Permission is hereby granted, free of charge, to any person obtaining a copy of\r
   6  * this software and associated documentation files (the "Software"), to deal in\r
   7  * the Software without restriction, including without limitation the rights to\r
   8  * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of\r
   9  * the Software, and to permit persons to whom the Software is furnished to do so,\r
  10  * subject to the following conditions:\r
  11  *\r
  12  * The above copyright notice and this permission notice shall be included in all\r
  13  * copies or substantial portions of the Software.\r
  14  *\r
  15  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  16  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS\r
  17  * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR\r
  18  * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER\r
  19  * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN\r
  20  * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.\r
  21  *\r
  22  * http://www.FreeRTOS.org\r
  23  * http://aws.amazon.com/freertos\r
  24  *\r
  25  * 1 tab == 4 spaces!\r
  26  */\r
  27 \r
  28 /***\r
  29  * See https://www.FreeRTOS.org/mqtt/index.html for configuration and usage instructions.\r
  30  ***/\r
  31 \r
  32 /* Standard includes. */\r
  33 #include <stdio.h>\r
  34 #include <time.h>\r
  35 \r
  36 /* Visual studio intrinsics used so the __debugbreak() function is available\r
  37 should an assert get hit. */\r
  38 #include <intrin.h>\r
  39 \r
  40 /* FreeRTOS includes. */\r
  41 #include <FreeRTOS.h>\r
  42 #include "task.h"\r
  43 \r
  44 /* TCP/IP stack includes. */\r
  45 #include "FreeRTOS_IP.h"\r
  46 #include "FreeRTOS_Sockets.h"\r
  47 \r
  48 /* Demo app includes. */\r
  49 #include "demo_logging.h"\r
  50 \r
  51 /*\r
  52  * Prototypes for the demos that can be started from this project.  Note the\r
  53  * MQTT demo is not actually started until the network is already, which is\r
  54  * indicated by vApplicationIPNetworkEventHook() executing - hence\r
  55  * prvStartSimpleMQTTDemo() is called from inside vApplicationIPNetworkEventHook().\r
  56  */\r
  57 extern void vStartSimpleMQTTDemo( void );\r
  58 \r
  59 /*\r
  60  * Task for Light Weight MQTT Serializer API Proof of Concept.\r
  61  * To run the proof of concept instead of the demo replace\r
  62  * vStartSimpleMQTTDemo() with vApplicationIPNetworkEventHook()\r
  63  * in function vApplicationIPNetworkEventHook().\r
  64  */\r
  65 extern void vStartLightWeightMQTTDemo( void );\r
  66 \r
  67 /*\r
  68  * Just seeds the simple pseudo random number generator.\r
  69  *\r
  70  * !!! NOTE !!!\r
  71  * This is not a secure method of generating random numbers and production\r
  72  * devices should use a true random number generator (TRNG).\r
  73  */\r
  74 static void prvSRand( UBaseType_t ulSeed );\r
  75 \r
  76 /*\r
  77  * Miscellaneous initialization including preparing the logging and seeding the\r
  78  * random number generator.\r
  79  */\r
  80 static void prvMiscInitialisation( void );\r
  81 \r
  82 /* The default IP and MAC address used by the demo.  The address configuration\r
  83 defined here will be used if ipconfigUSE_DHCP is 0, or if ipconfigUSE_DHCP is\r
  84 1 but a DHCP server could not be contacted.  See the online documentation for\r
  85 more information. */\r
  86 static const uint8_t ucIPAddress[ 4 ] = { configIP_ADDR0, configIP_ADDR1, configIP_ADDR2, configIP_ADDR3 };\r
  87 static const uint8_t ucNetMask[ 4 ] = { configNET_MASK0, configNET_MASK1, configNET_MASK2, configNET_MASK3 };\r
  88 static const uint8_t ucGatewayAddress[ 4 ] = { configGATEWAY_ADDR0, configGATEWAY_ADDR1, configGATEWAY_ADDR2, configGATEWAY_ADDR3 };\r
  89 static const uint8_t ucDNSServerAddress[ 4 ] = { configDNS_SERVER_ADDR0, configDNS_SERVER_ADDR1, configDNS_SERVER_ADDR2, configDNS_SERVER_ADDR3 };\r
  90 \r
  91 /* Set the following constant to pdTRUE to log using the method indicated by the\r
  92 name of the constant, or pdFALSE to not log using the method indicated by the\r
  93 name of the constant.  Options include to standard out (xLogToStdout), to a disk\r
  94 file (xLogToFile), and to a UDP port (xLogToUDP).  If xLogToUDP is set to pdTRUE\r
  95 then UDP messages are sent to the IP address configured as the echo server\r
  96 address (see the configECHO_SERVER_ADDR0 definitions in FreeRTOSConfig.h) and\r
  97 the port number set by configPRINT_PORT in FreeRTOSConfig.h. */\r
  98 const BaseType_t xLogToStdout = pdTRUE, xLogToFile = pdFALSE, xLogToUDP = pdFALSE;\r
  99 \r
 100 /* Default MAC address configuration.  The demo creates a virtual network\r
 101 connection that uses this MAC address by accessing the raw Ethernet data\r
 102 to and from a real network connection on the host PC.  See the\r
 103 configNETWORK_INTERFACE_TO_USE definition for information on how to configure\r
 104 the real network connection to use. */\r
 105 const uint8_t ucMACAddress[ 6 ] = { configMAC_ADDR0, configMAC_ADDR1, configMAC_ADDR2, configMAC_ADDR3, configMAC_ADDR4, configMAC_ADDR5 };\r
 106 \r
 107 /* Use by the pseudo random number generator. */\r
 108 static UBaseType_t ulNextRand;\r
 109 /*-----------------------------------------------------------*/\r
 110 \r
 111 int main( void )\r
 112 {\r
 113         /***\r
 114          * See https://www.FreeRTOS.org/mqtt/index.html for configuration and usage instructions.\r
 115          ***/\r
 116 \r
 117         /* Miscellaneous initialization including preparing the logging and seeding\r
 118         the random number generator. */\r
 119         prvMiscInitialisation();\r
 120 \r
 121         /* Initialize the network interface.\r
 122 \r
 123         ***NOTE*** Tasks that use the network are created in the network event hook\r
 124         when the network is connected and ready for use (see the implementation of\r
 125         vApplicationIPNetworkEventHook() below).  The address values passed in here\r
 126         are used if ipconfigUSE_DHCP is set to 0, or if ipconfigUSE_DHCP is set to 1\r
 127         but a DHCP server cannot be contacted. */\r
 128         FreeRTOS_IPInit( ucIPAddress, ucNetMask, ucGatewayAddress, ucDNSServerAddress, ucMACAddress );\r
 129 \r
 130         /* Start the RTOS scheduler. */\r
 131         vTaskStartScheduler();\r
 132 \r
 133         /* If all is well, the scheduler will now be running, and the following\r
 134         line will never be reached.  If the following line does execute, then\r
 135         there was insufficient FreeRTOS heap memory available for the idle and/or\r
 136         timer tasks to be created.  See the memory management section on the\r
 137         FreeRTOS web site for more details (this is standard text that is not\r
 138         really applicable to the Win32 simulator port). */\r
 139         for( ; ; )\r
 140         {\r
 141                 __debugbreak();\r
 142         }\r
 143 }\r
 144 /*-----------------------------------------------------------*/\r
 145 \r
 146 /* Called by FreeRTOS+TCP when the network connects or disconnects.  Disconnect\r
 147 events are only received if implemented in the MAC driver. */\r
 148 void vApplicationIPNetworkEventHook( eIPCallbackEvent_t eNetworkEvent )\r
 149 {\r
 150 uint32_t ulIPAddress, ulNetMask, ulGatewayAddress, ulDNSServerAddress;\r
 151 char cBuffer[ 16 ];\r
 152 static BaseType_t xTasksAlreadyCreated = pdFALSE;\r
 153 \r
 154         /* If the network has just come up...*/\r
 155         if( eNetworkEvent == eNetworkUp )\r
 156         {\r
 157                 /* Create the tasks that use the IP stack if they have not already been\r
 158                 created. */\r
 159                 if( xTasksAlreadyCreated == pdFALSE )\r
 160                 {\r
 161                         /* Demos that use the network are created after the network is\r
 162                         up. */\r
 163                         configPRINTF( ( "---------STARTING DEMO---------\r\n" ) );\r
 164                         vStartSimpleMQTTDemo();\r
 165                         xTasksAlreadyCreated = pdTRUE;\r
 166                 }\r
 167 \r
 168                 /* Print out the network configuration, which may have come from a DHCP\r
 169                 server. */\r
 170                 FreeRTOS_GetAddressConfiguration( &ulIPAddress, &ulNetMask, &ulGatewayAddress, &ulDNSServerAddress );\r
 171                 FreeRTOS_inet_ntoa( ulIPAddress, cBuffer );\r
 172                 FreeRTOS_printf( ( "\r\n\r\nIP Address: %s\r\n", cBuffer ) ); /*_RB_ Should use IoT libraries logging. */\r
 173 \r
 174                 FreeRTOS_inet_ntoa( ulNetMask, cBuffer );\r
 175                 FreeRTOS_printf( ( "Subnet Mask: %s\r\n", cBuffer ) );\r
 176 \r
 177                 FreeRTOS_inet_ntoa( ulGatewayAddress, cBuffer );\r
 178                 FreeRTOS_printf( ( "Gateway Address: %s\r\n", cBuffer ) );\r
 179 \r
 180                 FreeRTOS_inet_ntoa( ulDNSServerAddress, cBuffer );\r
 181                 FreeRTOS_printf( ( "DNS Server Address: %s\r\n\r\n\r\n", cBuffer ) );\r
 182         }\r
 183 }\r
 184 /*-----------------------------------------------------------*/\r
 185 \r
 186 void vAssertCalled( const char *pcFile,\r
 187                                         uint32_t ulLine )\r
 188 {\r
 189 volatile uint32_t ulBlockVariable = 0UL;\r
 190 volatile char *pcFileName = ( volatile char * ) pcFile;\r
 191 volatile uint32_t ulLineNumber = ulLine;\r
 192 \r
 193         ( void ) pcFileName;\r
 194         ( void ) ulLineNumber;\r
 195 \r
 196         printf( "vAssertCalled( %s, %u\n", pcFile, ulLine );\r
 197 \r
 198         /* Setting ulBlockVariable to a non-zero value in the debugger will allow\r
 199         this function to be exited. */\r
 200         taskDISABLE_INTERRUPTS();\r
 201         {\r
 202                 while( ulBlockVariable == 0UL )\r
 203                 {\r
 204                         __debugbreak();\r
 205                 }\r
 206         }\r
 207         taskENABLE_INTERRUPTS();\r
 208 }\r
 209 /*-----------------------------------------------------------*/\r
 210 \r
 211 UBaseType_t uxRand( void )\r
 212 {\r
 213 const uint32_t ulMultiplier = 0x015a4e35UL, ulIncrement = 1UL;\r
 214 \r
 215         /*\r
 216          * Utility function to generate a pseudo random number.\r
 217          *\r
 218          * !!!NOTE!!!\r
 219          * This is not a secure method of generating a random number.  Production\r
 220          * devices should use a True Random Number Generator (TRNG).\r
 221          */\r
 222         ulNextRand = ( ulMultiplier * ulNextRand ) + ulIncrement;\r
 223         return( ( int ) ( ulNextRand >> 16UL ) & 0x7fffUL );\r
 224 }\r
 225 /*-----------------------------------------------------------*/\r
 226 \r
 227 static void prvSRand( UBaseType_t ulSeed )\r
 228 {\r
 229         /* Utility function to seed the pseudo random number generator. */\r
 230         ulNextRand = ulSeed;\r
 231 }\r
 232 /*-----------------------------------------------------------*/\r
 233 \r
 234 static void prvMiscInitialisation( void )\r
 235 {\r
 236 time_t xTimeNow;\r
 237 uint32_t ulLoggingIPAddress;\r
 238 \r
 239         ulLoggingIPAddress = FreeRTOS_inet_addr_quick( configECHO_SERVER_ADDR0, configECHO_SERVER_ADDR1, configECHO_SERVER_ADDR2, configECHO_SERVER_ADDR3 );\r
 240         vLoggingInit( xLogToStdout, xLogToFile, xLogToUDP, ulLoggingIPAddress, configPRINT_PORT );\r
 241 \r
 242         /*\r
 243         * Seed random number generator.\r
 244         *\r
 245         * !!!NOTE!!!\r
 246         * This is not a secure method of generating a random number.  Production\r
 247         * devices should use a True Random Number Generator (TRNG).\r
 248         */\r
 249         time( &xTimeNow );\r
 250         FreeRTOS_debug_printf( ( "Seed for randomizer: %lu\n", xTimeNow ) );\r
 251         prvSRand( ( uint32_t ) xTimeNow );\r
 252         FreeRTOS_debug_printf( ( "Random numbers: %08X %08X %08X %08X\n", ipconfigRAND32(), ipconfigRAND32(), ipconfigRAND32(), ipconfigRAND32() ) );\r
 253 }\r
 254 /*-----------------------------------------------------------*/\r
 255 \r
 256 #if ( ipconfigUSE_LLMNR != 0 ) || ( ipconfigUSE_NBNS != 0 ) || ( ipconfigDHCP_REGISTER_HOSTNAME == 1 )\r
 257 \r
 258         const char * pcApplicationHostnameHook( void )\r
 259         {\r
 260                 /* Assign the name "FreeRTOS" to this network node.  This function will\r
 261                 be called during the DHCP: the machine will be registered with an IP\r
 262                 address plus this name. */\r
 263                 return mainHOST_NAME;\r
 264         }\r
 265 \r
 266 #endif\r
 267 /*-----------------------------------------------------------*/\r
 268 \r
 269 #if ( ipconfigUSE_LLMNR != 0 ) || ( ipconfigUSE_NBNS != 0 )\r
 270 \r
 271         BaseType_t xApplicationDNSQueryHook( const char *pcName )\r
 272         {\r
 273         BaseType_t xReturn;\r
 274 \r
 275                 /* Determine if a name lookup is for this node.  Two names are given\r
 276                 to this node: that returned by pcApplicationHostnameHook() and that set\r
 277                 by mainDEVICE_NICK_NAME. */\r
 278                 if( _stricmp( pcName, pcApplicationHostnameHook() ) == 0 )\r
 279                 {\r
 280                         xReturn = pdPASS;\r
 281                 }\r
 282                 else if( _stricmp( pcName, mainDEVICE_NICK_NAME ) == 0 )\r
 283                 {\r
 284                         xReturn = pdPASS;\r
 285                 }\r
 286                 else\r
 287                 {\r
 288                         xReturn = pdFAIL;\r
 289                 }\r
 290 \r
 291                 return xReturn;\r
 292         }\r
 293 \r
 294 #endif /* if ( ipconfigUSE_LLMNR != 0 ) || ( ipconfigUSE_NBNS != 0 ) */\r
 295 /*-----------------------------------------------------------*/\r
 296 \r
 297 /*\r
 298  * Callback that provides the inputs necessary to generate a randomized TCP\r
 299  * Initial Sequence Number per RFC 6528.  THIS IS ONLY A DUMMY IMPLEMENTATION\r
 300  * THAT RETURNS A PSEUDO RANDOM NUMBER SO IS NOT INTENDED FOR USE IN PRODUCTION\r
 301  * SYSTEMS.\r
 302  */\r
 303 extern uint32_t ulApplicationGetNextSequenceNumber( uint32_t ulSourceAddress,\r
 304                                                                                                         uint16_t usSourcePort,\r
 305                                                                                                         uint32_t ulDestinationAddress,\r
 306                                                                                                         uint16_t usDestinationPort )\r
 307 {\r
 308         ( void ) ulSourceAddress;\r
 309         ( void ) usSourcePort;\r
 310         ( void ) ulDestinationAddress;\r
 311         ( void ) usDestinationPort;\r
 312 \r
 313         return uxRand();\r
 314 }\r
 315 /*-----------------------------------------------------------*/\r
 316 \r
 317 /* configUSE_STATIC_ALLOCATION is set to 1, so the application must provide an\r
 318 implementation of vApplicationGetIdleTaskMemory() to provide the memory that is\r
 319 used by the Idle task. */\r
 320 void vApplicationGetIdleTaskMemory( StaticTask_t ** ppxIdleTaskTCBBuffer,\r
 321                                                                         StackType_t ** ppxIdleTaskStackBuffer,\r
 322                                                                         uint32_t * pulIdleTaskStackSize )\r
 323 {\r
 324         /* If the buffers to be provided to the Idle task are declared inside this\r
 325         function then they must be declared static - otherwise they will be allocated on\r
 326         the stack and so not exists after this function exits. */\r
 327         static StaticTask_t xIdleTaskTCB;\r
 328         static StackType_t uxIdleTaskStack[ configMINIMAL_STACK_SIZE ];\r
 329 \r
 330         /* Pass out a pointer to the StaticTask_t structure in which the Idle task's\r
 331         state will be stored. */\r
 332         *ppxIdleTaskTCBBuffer = &xIdleTaskTCB;\r
 333 \r
 334         /* Pass out the array that will be used as the Idle task's stack. */\r
 335         *ppxIdleTaskStackBuffer = uxIdleTaskStack;\r
 336 \r
 337         /* Pass out the size of the array pointed to by *ppxIdleTaskStackBuffer.\r
 338         Note that, as the array is necessarily of type StackType_t,\r
 339         configMINIMAL_STACK_SIZE is specified in words, not bytes. */\r
 340         *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;\r
 341 }\r
 342 /*-----------------------------------------------------------*/\r
 343 \r
 344 /* configUSE_STATIC_ALLOCATION and configUSE_TIMERS are both set to 1, so the\r
 345 application must provide an implementation of vApplicationGetTimerTaskMemory()\r
 346 to provide the memory that is used by the Timer service task. */\r
 347 void vApplicationGetTimerTaskMemory( StaticTask_t ** ppxTimerTaskTCBBuffer,\r
 348                                                                          StackType_t ** ppxTimerTaskStackBuffer,\r
 349                                                                          uint32_t * pulTimerTaskStackSize )\r
 350 {\r
 351         /* If the buffers to be provided to the Timer task are declared inside this\r
 352         function then they must be declared static - otherwise they will be allocated on\r
 353         the stack and so not exists after this function exits. */\r
 354         static StaticTask_t xTimerTaskTCB;\r
 355         static StackType_t uxTimerTaskStack[ configTIMER_TASK_STACK_DEPTH ];\r
 356 \r
 357         /* Pass out a pointer to the StaticTask_t structure in which the Timer\r
 358         task's state will be stored. */\r
 359         *ppxTimerTaskTCBBuffer = &xTimerTaskTCB;\r
 360 \r
 361         /* Pass out the array that will be used as the Timer task's stack. */\r
 362         *ppxTimerTaskStackBuffer = uxTimerTaskStack;\r
 363 \r
 364         /* Pass out the size of the array pointed to by *ppxTimerTaskStackBuffer.\r
 365         Note that, as the array is necessarily of type StackType_t,\r
 366         configMINIMAL_STACK_SIZE is specified in words, not bytes. */\r
 367         *pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;\r
 368 }\r
 369 /*-----------------------------------------------------------*/\r