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

   1 /*\r
   2  * FreeRTOS Kernel V10.2.1\r
   3  * Copyright (C) 2017 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  * This project is a cut down version of the project described on the following\r
  30  * link.  Only the simple UDP client and server and the TCP echo clients are\r
  31  * included in the build:\r
  32  * http://www.freertos.org/FreeRTOS-Plus/FreeRTOS_Plus_TCP/examples_FreeRTOS_simulator.html\r
  33  */\r
  34 \r
  35 /* Standard includes. */\r
  36 #include <stdio.h>\r
  37 #include <time.h>\r
  38 \r
  39 /* Visual studio intrinsics used so the __debugbreak() function is available\r
  40 should an assert get hit. */\r
  41 #include <intrin.h>\r
  42 \r
  43 /* FreeRTOS includes. */\r
  44 #include <FreeRTOS.h>\r
  45 #include "task.h"\r
  46 \r
  47 /* TCP/IP stack includes. */\r
  48 #include "FreeRTOS_IP.h"\r
  49 #include "FreeRTOS_Sockets.h"\r
  50 \r
  51 /* Demo app includes. */\r
  52 #include "demo_logging.h"\r
  53 \r
  54 /* Set the following constants to 1 or 0 to define which tasks to include and\r
  55 exclude:\r
  56 \r
  57 mainCREATE_SIMPLE_UDP_CLIENT_SERVER_TASKS:  When set to 1 two UDP client tasks\r
  58 and two UDP server tasks are created.  The clients talk to the servers.  One set\r
  59 of tasks use the standard sockets interface, and the other the zero copy sockets\r
  60 interface.  These tasks are self checking and will trigger a configASSERT() if\r
  61 they detect a difference in the data that is received from that which was sent.\r
  62 As these tasks use UDP, and can therefore loose packets, they will cause\r
  63 configASSERT() to be called when they are run in a less than perfect networking\r
  64 environment.\r
  65 \r
  66 mainCREATE_SIMPLE_MQTT_EXAMPLE_TASKS:  TBD\r
  67 */\r
  68 #define mainCREATE_SIMPLE_UDP_CLIENT_SERVER_TASKS       1\r
  69 #define mainCREATE_SIMPLE_MQTT_EXAMPLE_TASKS            0\r
  70 \r
  71 /* Simple UDP client and server task parameters. */\r
  72 #define mainSIMPLE_UDP_CLIENT_SERVER_TASK_PRIORITY              ( tskIDLE_PRIORITY )\r
  73 #define mainSIMPLE_UDP_CLIENT_SERVER_PORT                               ( 5005UL )\r
  74 \r
  75 /*\r
  76  * Prototypes for the demos that can be started from this project.\r
  77  */\r
  78 extern void vStartSimpleMQTTDemo( void );\r
  79 extern void vStartSimpleUDPClientServerTasks( uint16_t usStackSize, uint32_t ulsPort, UBaseType_t uxPriority );\r
  80 \r
  81 /*\r
  82  * Just seeds the simple pseudo random number generator.\r
  83  *\r
  84  * !!! NOTE !!!\r
  85  * This is not a secure method of generating random numbers and production\r
  86  * devices should use a true random number generator (TRNG).\r
  87  */\r
  88 static void prvSRand( UBaseType_t ulSeed );\r
  89 \r
  90 /*\r
  91  * Miscellaneous initialisation including preparing the logging and seeding the\r
  92  * random number generator.\r
  93  */\r
  94 static void prvMiscInitialisation( void );\r
  95 \r
  96 /* The default IP and MAC address used by the demo.  The address configuration\r
  97 defined here will be used if ipconfigUSE_DHCP is 0, or if ipconfigUSE_DHCP is\r
  98 1 but a DHCP server could not be contacted.  See the online documentation for\r
  99 more information. */\r
 100 static const uint8_t ucIPAddress[ 4 ] = { configIP_ADDR0, configIP_ADDR1, configIP_ADDR2, configIP_ADDR3 };\r
 101 static const uint8_t ucNetMask[ 4 ] = { configNET_MASK0, configNET_MASK1, configNET_MASK2, configNET_MASK3 };\r
 102 static const uint8_t ucGatewayAddress[ 4 ] = { configGATEWAY_ADDR0, configGATEWAY_ADDR1, configGATEWAY_ADDR2, configGATEWAY_ADDR3 };\r
 103 static const uint8_t ucDNSServerAddress[ 4 ] = { configDNS_SERVER_ADDR0, configDNS_SERVER_ADDR1, configDNS_SERVER_ADDR2, configDNS_SERVER_ADDR3 };\r
 104 \r
 105 /* Set the following constant to pdTRUE to log using the method indicated by the\r
 106 name of the constant, or pdFALSE to not log using the method indicated by the\r
 107 name of the constant.  Options include to standard out (xLogToStdout), to a disk\r
 108 file (xLogToFile), and to a UDP port (xLogToUDP).  If xLogToUDP is set to pdTRUE\r
 109 then UDP messages are sent to the IP address configured as the echo server\r
 110 address (see the configECHO_SERVER_ADDR0 definitions in FreeRTOSConfig.h) and\r
 111 the port number set by configPRINT_PORT in FreeRTOSConfig.h. */\r
 112 const BaseType_t xLogToStdout = pdTRUE, xLogToFile = pdFALSE, xLogToUDP = pdFALSE;\r
 113 \r
 114 /* Default MAC address configuration.  The demo creates a virtual network\r
 115 connection that uses this MAC address by accessing the raw Ethernet data\r
 116 to and from a real network connection on the host PC.  See the\r
 117 configNETWORK_INTERFACE_TO_USE definition for information on how to configure\r
 118 the real network connection to use. */\r
 119 const uint8_t ucMACAddress[ 6 ] = { configMAC_ADDR0, configMAC_ADDR1, configMAC_ADDR2, configMAC_ADDR3, configMAC_ADDR4, configMAC_ADDR5 };\r
 120 \r
 121 /* Use by the pseudo random number generator. */\r
 122 static UBaseType_t ulNextRand;\r
 123 /*-----------------------------------------------------------*/\r
 124 \r
 125 int main( void )\r
 126 {\r
 127         /*\r
 128          * Instructions for using this project are provided on:\r
 129          * TBD\r
 130          */\r
 131 \r
 132         /* Miscellaneous initialisation including preparing the logging and seeding\r
 133         the random number generator. */\r
 134         prvMiscInitialisation();\r
 135 \r
 136         /* Initialise the network interface.\r
 137 \r
 138         ***NOTE*** Tasks that use the network are created in the network event hook\r
 139         when the network is connected and ready for use (see the implementation of\r
 140         vApplicationIPNetworkEventHook() below).  The address values passed in here\r
 141         are used if ipconfigUSE_DHCP is set to 0, or if ipconfigUSE_DHCP is set to 1\r
 142         but a DHCP server cannot be     contacted. */\r
 143         FreeRTOS_IPInit( ucIPAddress, ucNetMask, ucGatewayAddress, ucDNSServerAddress, ucMACAddress );\r
 144 \r
 145         /* Start the RTOS scheduler. */\r
 146         vTaskStartScheduler();\r
 147 \r
 148         /* If all is well, the scheduler will now be running, and the following\r
 149         line will never be reached.  If the following line does execute, then\r
 150         there was insufficient FreeRTOS heap memory available for the idle and/or\r
 151         timer tasks     to be created.  See the memory management section on the\r
 152         FreeRTOS web site for more details (this is standard text that is not not\r
 153         really applicable to the Win32 simulator port). */\r
 154         for( ;; )\r
 155         {\r
 156                 __debugbreak();\r
 157         }\r
 158 }\r
 159 /*-----------------------------------------------------------*/\r
 160 \r
 161 void vAssertCalled( const char *pcFile, uint32_t ulLine )\r
 162 {\r
 163 volatile uint32_t ulBlockVariable = 0UL;\r
 164 volatile char *pcFileName = ( volatile char *  ) pcFile;\r
 165 volatile uint32_t ulLineNumber = ulLine;\r
 166 \r
 167         ( void ) pcFileName;\r
 168         ( void ) ulLineNumber;\r
 169 \r
 170         printf( "vAssertCalled( %s, %u\n", pcFile, ulLine );\r
 171 \r
 172         /* Setting ulBlockVariable to a non-zero value in the debugger will allow\r
 173         this function to be exited. */\r
 174         taskDISABLE_INTERRUPTS();\r
 175         {\r
 176                 while( ulBlockVariable == 0UL )\r
 177                 {\r
 178                         __debugbreak();\r
 179                 }\r
 180         }\r
 181         taskENABLE_INTERRUPTS();\r
 182 }\r
 183 /*-----------------------------------------------------------*/\r
 184 \r
 185 /* Called by FreeRTOS+TCP when the network connects or disconnects.  Disconnect\r
 186 events are only received if implemented in the MAC driver. */\r
 187 void vApplicationIPNetworkEventHook( eIPCallbackEvent_t eNetworkEvent )\r
 188 {\r
 189 uint32_t ulIPAddress, ulNetMask, ulGatewayAddress, ulDNSServerAddress;\r
 190 char cBuffer[ 16 ];\r
 191 static BaseType_t xTasksAlreadyCreated = pdFALSE;\r
 192 \r
 193         /* If the network has just come up...*/\r
 194         if( eNetworkEvent == eNetworkUp )\r
 195         {\r
 196                 /* Create the tasks that use the IP stack if they have not already been\r
 197                 created. */\r
 198                 if( xTasksAlreadyCreated == pdFALSE )\r
 199                 {\r
 200                         #if( mainCREATE_SIMPLE_UDP_CLIENT_SERVER_TASKS == 1 )\r
 201                         {\r
 202                                 vStartSimpleUDPClientServerTasks( configMINIMAL_STACK_SIZE, mainSIMPLE_UDP_CLIENT_SERVER_PORT, mainSIMPLE_UDP_CLIENT_SERVER_TASK_PRIORITY );\r
 203                         }\r
 204                         #endif\r
 205 \r
 206                         #if( mainCREATE_SIMPLE_MQTT_EXAMPLE_TASKS == 1 )\r
 207                         {\r
 208                                 vStartSimpleMQTTDemo();\r
 209                         }\r
 210                         #endif\r
 211 \r
 212                         xTasksAlreadyCreated = pdTRUE;\r
 213                 }\r
 214 \r
 215                 /* Print out the network configuration, which may have come from a DHCP\r
 216                 server. */\r
 217                 FreeRTOS_GetAddressConfiguration( &ulIPAddress, &ulNetMask, &ulGatewayAddress, &ulDNSServerAddress );\r
 218                 FreeRTOS_inet_ntoa( ulIPAddress, cBuffer );\r
 219                 FreeRTOS_printf( ( "\r\n\r\nIP Address: %s\r\n", cBuffer ) );/*_RB_ Should use IoT libraries logging. */\r
 220 \r
 221                 FreeRTOS_inet_ntoa( ulNetMask, cBuffer );\r
 222                 FreeRTOS_printf( ( "Subnet Mask: %s\r\n", cBuffer ) );\r
 223 \r
 224                 FreeRTOS_inet_ntoa( ulGatewayAddress, cBuffer );\r
 225                 FreeRTOS_printf( ( "Gateway Address: %s\r\n", cBuffer ) );\r
 226 \r
 227                 FreeRTOS_inet_ntoa( ulDNSServerAddress, cBuffer );\r
 228                 FreeRTOS_printf( ( "DNS Server Address: %s\r\n\r\n\r\n", cBuffer ) );\r
 229         }\r
 230 }\r
 231 /*-----------------------------------------------------------*/\r
 232 \r
 233 UBaseType_t uxRand( void )\r
 234 {\r
 235 const uint32_t ulMultiplier = 0x015a4e35UL, ulIncrement = 1UL;\r
 236 \r
 237         /*\r
 238          * Utility function to generate a pseudo random number.\r
 239          *\r
 240          * !!!NOTE!!!\r
 241          * This is not a secure method of generating a random number.  Production\r
 242          * devices should use a True Random Number Generator (TRNG).\r
 243          */\r
 244         ulNextRand = ( ulMultiplier * ulNextRand ) + ulIncrement;\r
 245         return( ( int ) ( ulNextRand >> 16UL ) & 0x7fffUL );\r
 246 }\r
 247 /*-----------------------------------------------------------*/\r
 248 \r
 249 static void prvSRand( UBaseType_t ulSeed )\r
 250 {\r
 251         /* Utility function to seed the pseudo random number generator. */\r
 252         ulNextRand = ulSeed;\r
 253 }\r
 254 /*-----------------------------------------------------------*/\r
 255 \r
 256 static void prvMiscInitialisation( void )\r
 257 {\r
 258 time_t xTimeNow;\r
 259 uint32_t ulLoggingIPAddress;\r
 260 \r
 261         ulLoggingIPAddress = FreeRTOS_inet_addr_quick( configECHO_SERVER_ADDR0, configECHO_SERVER_ADDR1, configECHO_SERVER_ADDR2, configECHO_SERVER_ADDR3 );\r
 262         vLoggingInit( xLogToStdout, xLogToFile, xLogToUDP, ulLoggingIPAddress, configPRINT_PORT );\r
 263 \r
 264         /* Seed the random number generator. */\r
 265         time( &xTimeNow );\r
 266         FreeRTOS_debug_printf( ( "Seed for randomiser: %lu\n", xTimeNow ) );\r
 267         prvSRand( ( uint32_t ) xTimeNow );\r
 268         FreeRTOS_debug_printf( ( "Random numbers: %08X %08X %08X %08X\n", ipconfigRAND32(), ipconfigRAND32(), ipconfigRAND32(), ipconfigRAND32() ) );\r
 269 }\r
 270 /*-----------------------------------------------------------*/\r
 271 \r
 272 #if( ipconfigUSE_LLMNR != 0 ) || ( ipconfigUSE_NBNS != 0 ) || ( ipconfigDHCP_REGISTER_HOSTNAME == 1 )\r
 273 \r
 274         const char *pcApplicationHostnameHook( void )\r
 275         {\r
 276                 /* Assign the name "FreeRTOS" to this network node.  This function will\r
 277                 be called during the DHCP: the machine will be registered with an IP\r
 278                 address plus this name. */\r
 279                 return mainHOST_NAME;\r
 280         }\r
 281 \r
 282 #endif\r
 283 /*-----------------------------------------------------------*/\r
 284 \r
 285 #if( ipconfigUSE_LLMNR != 0 ) || ( ipconfigUSE_NBNS != 0 )\r
 286 \r
 287         BaseType_t xApplicationDNSQueryHook( const char *pcName )\r
 288         {\r
 289         BaseType_t xReturn;\r
 290 \r
 291                 /* Determine if a name lookup is for this node.  Two names are given\r
 292                 to this node: that returned by pcApplicationHostnameHook() and that set\r
 293                 by mainDEVICE_NICK_NAME. */\r
 294                 if( _stricmp( pcName, pcApplicationHostnameHook() ) == 0 )\r
 295                 {\r
 296                         xReturn = pdPASS;\r
 297                 }\r
 298                 else if( _stricmp( pcName, mainDEVICE_NICK_NAME ) == 0 )\r
 299                 {\r
 300                         xReturn = pdPASS;\r
 301                 }\r
 302                 else\r
 303                 {\r
 304                         xReturn = pdFAIL;\r
 305                 }\r
 306 \r
 307                 return xReturn;\r
 308         }\r
 309 \r
 310 #endif\r
 311 /*-----------------------------------------------------------*/\r
 312 \r
 313 /*\r
 314  * Callback that provides the inputs necessary to generate a randomized TCP\r
 315  * Initial Sequence Number per RFC 6528.  THIS IS ONLY A DUMMY IMPLEMENTATION\r
 316  * THAT RETURNS A PSEUDO RANDOM NUMBER SO IS NOT INTENDED FOR USE IN PRODUCTION\r
 317  * SYSTEMS.\r
 318  */\r
 319 extern uint32_t ulApplicationGetNextSequenceNumber( uint32_t ulSourceAddress,\r
 320                                                                                                         uint16_t usSourcePort,\r
 321                                                                                                         uint32_t ulDestinationAddress,\r
 322                                                                                                         uint16_t usDestinationPort )\r
 323 {\r
 324         ( void ) ulSourceAddress;\r
 325         ( void ) usSourcePort;\r
 326         ( void ) ulDestinationAddress;\r
 327         ( void ) usDestinationPort;\r
 328 \r
 329         return uxRand();\r
 330 }\r
 331 /*-----------------------------------------------------------*/\r
 332 \r
 333 /* configUSE_STATIC_ALLOCATION is set to 1, so the application must provide an\r
 334 implementation of vApplicationGetIdleTaskMemory() to provide the memory that is\r
 335 used by the Idle task. */\r
 336 void vApplicationGetIdleTaskMemory( StaticTask_t** ppxIdleTaskTCBBuffer, StackType_t** ppxIdleTaskStackBuffer, uint32_t* pulIdleTaskStackSize )\r
 337 {\r
 338         /* If the buffers to be provided to the Idle task are declared inside this\r
 339         function then they must be declared static - otherwise they will be allocated on\r
 340         the stack and so not exists after this function exits. */\r
 341         static StaticTask_t xIdleTaskTCB;\r
 342         static StackType_t uxIdleTaskStack[configMINIMAL_STACK_SIZE];\r
 343 \r
 344         /* Pass out a pointer to the StaticTask_t structure in which the Idle task's\r
 345         state will be stored. */\r
 346         *ppxIdleTaskTCBBuffer = &xIdleTaskTCB;\r
 347 \r
 348         /* Pass out the array that will be used as the Idle task's stack. */\r
 349         *ppxIdleTaskStackBuffer = uxIdleTaskStack;\r
 350 \r
 351         /* Pass out the size of the array pointed to by *ppxIdleTaskStackBuffer.\r
 352         Note that, as the array is necessarily of type StackType_t,\r
 353         configMINIMAL_STACK_SIZE is specified in words, not bytes. */\r
 354         *pulIdleTaskStackSize = configMINIMAL_STACK_SIZE;\r
 355 }\r
 356 /*-----------------------------------------------------------*/\r
 357 \r
 358 /* configUSE_STATIC_ALLOCATION and configUSE_TIMERS are both set to 1, so the\r
 359 application must provide an implementation of vApplicationGetTimerTaskMemory()\r
 360 to provide the memory that is used by the Timer service task. */\r
 361 void vApplicationGetTimerTaskMemory( StaticTask_t** ppxTimerTaskTCBBuffer, StackType_t** ppxTimerTaskStackBuffer, uint32_t* pulTimerTaskStackSize )\r
 362 {\r
 363         /* If the buffers to be provided to the Timer task are declared inside this\r
 364         function then they must be declared static - otherwise they will be allocated on\r
 365         the stack and so not exists after this function exits. */\r
 366         static StaticTask_t xTimerTaskTCB;\r
 367         static StackType_t uxTimerTaskStack[configTIMER_TASK_STACK_DEPTH];\r
 368 \r
 369         /* Pass out a pointer to the StaticTask_t structure in which the Timer\r
 370         task's state will be stored. */\r
 371         *ppxTimerTaskTCBBuffer = &xTimerTaskTCB;\r
 372 \r
 373         /* Pass out the array that will be used as the Timer task's stack. */\r
 374         *ppxTimerTaskStackBuffer = uxTimerTaskStack;\r
 375 \r
 376         /* Pass out the size of the array pointed to by *ppxTimerTaskStackBuffer.\r
 377         Note that, as the array is necessarily of type StackType_t,\r
 378         configMINIMAL_STACK_SIZE is specified in words, not bytes. */\r
 379         *pulTimerTaskStackSize = configTIMER_TASK_STACK_DEPTH;\r
 380 }\r
 381 \r
 382 \r