git.sur5r.net Git - freertos/blob - FreeRTOS-Plus/Source/FreeRTOS-Plus-TCP/protocols/NTP/NTPDemo.c

   1 /*\r
   2  * FreeRTOS+TCP V2.0.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  * NTPDemo.c\r
  30  *\r
  31  * An example of how to lookup a domain using DNS\r
  32  * And also how to send and receive UDP messages to get the NTP time\r
  33  *\r
  34  */\r
  35 \r
  36 /* Standard includes. */\r
  37 #include <stdint.h>\r
  38 #include <stdio.h>\r
  39 #include <stdlib.h>\r
  40 #include <time.h>\r
  41 \r
  42 /* FreeRTOS includes. */\r
  43 #include "FreeRTOS.h"\r
  44 #include "task.h"\r
  45 #include "semphr.h"\r
  46 \r
  47 /* FreeRTOS+TCP includes. */\r
  48 #include "FreeRTOS_IP.h"\r
  49 #include "FreeRTOS_Sockets.h"\r
  50 #include "FreeRTOS_DNS.h"\r
  51 #include "FreeRTOS_Stream_Buffer.h"\r
  52 \r
  53 /* Use the date & time functions from +FAT. */\r
  54 #include "ff_time.h"\r
  55 \r
  56 #include "NTPDemo.h"\r
  57 #include "ntpClient.h"\r
  58 \r
  59 #include "date_and_time.h"\r
  60 \r
  61 enum EStatus {\r
  62         EStatusLookup,\r
  63         EStatusAsking,\r
  64         EStatusPause,\r
  65         EStatusFailed,\r
  66 };\r
  67 \r
  68 static struct SNtpPacket xNTPPacket;\r
  69 \r
  70 #if( ipconfigUSE_CALLBACKS == 0 )\r
  71         static char cRecvBuffer[ sizeof( struct SNtpPacket ) + 64 ];\r
  72 #endif\r
  73 \r
  74 static enum EStatus xStatus = EStatusLookup;\r
  75 \r
  76 static const char *pcTimeServers[] = {\r
  77         "0.asia.pool.ntp.org",\r
  78         "0.europe.pool.ntp.org",\r
  79         "0.id.pool.ntp.org",\r
  80         "0.south-america.pool.ntp.org",\r
  81         "0.oceania.pool.ntp.org",\r
  82         "0.north-america.pool.ntp.org"\r
  83 };\r
  84 \r
  85 static SemaphoreHandle_t xNTPWakeupSem = NULL;\r
  86 static uint32_t ulIPAddressFound;\r
  87 static Socket_t xUDPSocket = NULL;\r
  88 static TaskHandle_t xNTPTaskhandle = NULL;\r
  89 static TickType_t uxSendTime;\r
  90 \r
  91 static void prvNTPTask( void *pvParameters );\r
  92 \r
  93 static void vSignalTask( void )\r
  94 {\r
  95         #if( ipconfigUSE_CALLBACKS == 0 )\r
  96         if( xUDPSocket != NULL )\r
  97         {\r
  98                 /* Send a signal to the socket so that the\r
  99                 FreeRTOS_recvfrom will get interrupted. */\r
 100                 FreeRTOS_SignalSocket( xUDPSocket );\r
 101         }\r
 102         else\r
 103         #endif\r
 104         if( xNTPWakeupSem != NULL )\r
 105         {\r
 106                 xSemaphoreGive( xNTPWakeupSem );\r
 107         }\r
 108 }\r
 109 \r
 110 void vStartNTPTask( uint16_t usTaskStackSize, UBaseType_t uxTaskPriority )\r
 111 {\r
 112         /* The only public function in this module: start a task to contact\r
 113         some NTP server. */\r
 114 \r
 115         if( xNTPTaskhandle != NULL )\r
 116         {\r
 117                 switch( xStatus )\r
 118                 {\r
 119                 case EStatusPause:\r
 120                         xStatus = EStatusAsking;\r
 121                         vSignalTask();\r
 122                         break;\r
 123                 case EStatusLookup:\r
 124                         FreeRTOS_printf( ( "NTP looking up server\n" ) );\r
 125                         break;\r
 126                 case EStatusAsking:\r
 127                         FreeRTOS_printf( ( "NTP still asking\n" ) );\r
 128                         break;\r
 129                 case EStatusFailed:\r
 130                         FreeRTOS_printf( ( "NTP failed somehow\n" ) );\r
 131                         ulIPAddressFound = 0ul;\r
 132                         xStatus = EStatusLookup;\r
 133                         vSignalTask();\r
 134                         break;\r
 135                 }\r
 136         }\r
 137         else\r
 138         {\r
 139                 xUDPSocket = FreeRTOS_socket( FREERTOS_AF_INET, FREERTOS_SOCK_DGRAM, FREERTOS_IPPROTO_UDP );\r
 140                 if( xUDPSocket != NULL )\r
 141                 {\r
 142                 struct freertos_sockaddr xAddress;\r
 143                 #if( ipconfigUSE_CALLBACKS != 0 )\r
 144                         BaseType_t xReceiveTimeOut = pdMS_TO_TICKS( 0 );\r
 145                 #else\r
 146                         BaseType_t xReceiveTimeOut = pdMS_TO_TICKS( 5000 );\r
 147                 #endif\r
 148 \r
 149                         xAddress.sin_addr = 0ul;\r
 150                         xAddress.sin_port = FreeRTOS_htons( NTP_PORT );\r
 151 \r
 152                         FreeRTOS_bind( xUDPSocket, &xAddress, sizeof( xAddress ) );\r
 153                         FreeRTOS_setsockopt( xUDPSocket, 0, FREERTOS_SO_RCVTIMEO, &xReceiveTimeOut, sizeof( xReceiveTimeOut ) );\r
 154                         xTaskCreate(    prvNTPTask,                                             /* The function that implements the task. */\r
 155                                                         ( const char * ) "NTP client",  /* Just a text name for the task to aid debugging. */\r
 156                                                         usTaskStackSize,                                /* The stack size is defined in FreeRTOSIPConfig.h. */\r
 157                                                         NULL,                                                   /* The task parameter, not used in this case. */\r
 158                                                         uxTaskPriority,                                 /* The priority assigned to the task is defined in FreeRTOSConfig.h. */\r
 159                                                         &xNTPTaskhandle );                              /* The task handle. */\r
 160                 }\r
 161                 else\r
 162                 {\r
 163                         FreeRTOS_printf( ( "Creating socket failed\n" ) );\r
 164                 }\r
 165         }\r
 166 }\r
 167 /*-----------------------------------------------------------*/\r
 168 \r
 169 static void vDNS_callback( const char *pcName, void *pvSearchID, uint32_t ulIPAddress )\r
 170 {\r
 171 char pcBuf[16];\r
 172 \r
 173         /* The DNS lookup has a result, or it has reached the time-out. */\r
 174         FreeRTOS_inet_ntoa( ulIPAddress, pcBuf );\r
 175         FreeRTOS_printf( ( "IP address of %s found: %s\n", pcName, pcBuf ) );\r
 176         if( ulIPAddressFound == 0ul )\r
 177         {\r
 178                 ulIPAddressFound = ulIPAddress;\r
 179         }\r
 180         /* For testing: in case DNS doen't respond, still try some NTP server\r
 181         with a known IP-address. */\r
 182         if( ulIPAddressFound == 0ul )\r
 183         {\r
 184                 ulIPAddressFound = FreeRTOS_inet_addr_quick( 184, 105, 182, 7 );\r
 185 /*              ulIPAddressFound = FreeRTOS_inet_addr_quick( 103, 242,  70, 4 );        */\r
 186         }\r
 187         xStatus = EStatusAsking;\r
 188 \r
 189         vSignalTask();\r
 190 }\r
 191 /*-----------------------------------------------------------*/\r
 192 \r
 193 static void prvSwapFields( struct SNtpPacket *pxPacket)\r
 194 {\r
 195         /* NTP messages are big-endian */\r
 196         pxPacket->rootDelay = FreeRTOS_htonl( pxPacket->rootDelay );\r
 197         pxPacket->rootDispersion = FreeRTOS_htonl( pxPacket->rootDispersion );\r
 198 \r
 199         pxPacket->referenceTimestamp.seconds = FreeRTOS_htonl( pxPacket->referenceTimestamp.seconds );\r
 200         pxPacket->referenceTimestamp.fraction = FreeRTOS_htonl( pxPacket->referenceTimestamp.fraction );\r
 201 \r
 202         pxPacket->originateTimestamp.seconds = FreeRTOS_htonl( pxPacket->originateTimestamp.seconds );\r
 203         pxPacket->originateTimestamp.fraction = FreeRTOS_htonl( pxPacket->originateTimestamp.fraction );\r
 204 \r
 205         pxPacket->receiveTimestamp.seconds = FreeRTOS_htonl( pxPacket->receiveTimestamp.seconds );\r
 206         pxPacket->receiveTimestamp.fraction = FreeRTOS_htonl( pxPacket->receiveTimestamp.fraction );\r
 207 \r
 208         pxPacket->transmitTimestamp.seconds = FreeRTOS_htonl( pxPacket->transmitTimestamp.seconds );\r
 209         pxPacket->transmitTimestamp.fraction = FreeRTOS_htonl( pxPacket->transmitTimestamp.fraction );\r
 210 }\r
 211 /*-----------------------------------------------------------*/\r
 212 \r
 213 static void prvNTPPacketInit( )\r
 214 {\r
 215         memset (&xNTPPacket, '\0', sizeof( xNTPPacket ) );\r
 216 \r
 217         xNTPPacket.flags = 0xDB;                                /* value 0xDB : mode 3 (client), version 3, leap indicator unknown 3 */\r
 218         xNTPPacket.poll = 10;                                   /* 10 means 1 << 10 = 1024 seconds */\r
 219         xNTPPacket.precision = 0xFA;                    /* = 250 = 0.015625 seconds */\r
 220         xNTPPacket.rootDelay = 0x5D2E;                  /* 0x5D2E = 23854 or (23854/65535)= 0.3640 sec */\r
 221         xNTPPacket.rootDispersion = 0x0008CAC8; /* 0x0008CAC8 = 8.7912  seconds */\r
 222 \r
 223         /* use the recorded NTP time */\r
 224         time_t uxSecs = FreeRTOS_time( NULL );/* apTime may be NULL, returns seconds */\r
 225 \r
 226         xNTPPacket.referenceTimestamp.seconds = uxSecs; /* Current time */\r
 227         xNTPPacket.transmitTimestamp.seconds = uxSecs + 3;\r
 228 \r
 229         /* Transform the contents of the fields from native to big endian. */\r
 230         prvSwapFields( &xNTPPacket );\r
 231 }\r
 232 /*-----------------------------------------------------------*/\r
 233 \r
 234 static void prvReadTime( struct SNtpPacket * pxPacket )\r
 235 {\r
 236         FF_TimeStruct_t xTimeStruct;\r
 237         time_t uxPreviousSeconds;\r
 238         time_t uxPreviousMS;\r
 239 \r
 240         time_t uxCurrentSeconds;\r
 241         time_t uxCurrentMS;\r
 242 \r
 243         const char *pcTimeUnit;\r
 244         int32_t ilDiff;\r
 245         TickType_t uxTravelTime;\r
 246 \r
 247         uxTravelTime = xTaskGetTickCount() - uxSendTime;\r
 248 \r
 249         /* Transform the contents of the fields from big to native endian. */\r
 250         prvSwapFields( pxPacket );\r
 251 \r
 252         uxCurrentSeconds = pxPacket->receiveTimestamp.seconds - TIME1970;\r
 253         uxCurrentMS = pxPacket->receiveTimestamp.fraction / 4294967;\r
 254         uxCurrentSeconds += uxCurrentMS / 1000;\r
 255         uxCurrentMS = uxCurrentMS % 1000;\r
 256 \r
 257         // Get the last time recorded\r
 258         uxPreviousSeconds = FreeRTOS_get_secs_msec( &uxPreviousMS );\r
 259 \r
 260         // Set the new time with precision in msec. */\r
 261         FreeRTOS_set_secs_msec( &uxCurrentSeconds, &uxCurrentMS );\r
 262 \r
 263         if( uxCurrentSeconds >= uxPreviousSeconds )\r
 264         {\r
 265                 ilDiff = ( int32_t ) ( uxCurrentSeconds - uxPreviousSeconds );\r
 266         }\r
 267         else\r
 268         {\r
 269                 ilDiff = 0 - ( int32_t ) ( uxPreviousSeconds - uxCurrentSeconds );\r
 270         }\r
 271 \r
 272         if( ( ilDiff < -5 ) || ( ilDiff > 5 ) )\r
 273         {\r
 274                 /* More than 5 seconds difference. */\r
 275                 pcTimeUnit = "sec";\r
 276         }\r
 277         else\r
 278         {\r
 279                 /* Less than or equal to 5 second difference. */\r
 280                 pcTimeUnit = "ms";\r
 281                 uint32_t ulLowest = ( uxCurrentSeconds <= uxPreviousSeconds ) ? uxCurrentSeconds : uxPreviousSeconds;\r
 282                 int32_t iCurMS = 1000 * ( uxCurrentSeconds - ulLowest ) + uxCurrentMS;\r
 283                 int32_t iPrevMS = 1000 * ( uxPreviousSeconds - ulLowest ) + uxPreviousMS;\r
 284                 ilDiff = iCurMS - iPrevMS;\r
 285         }\r
 286         uxCurrentSeconds -= iTimeZone;\r
 287 \r
 288         FreeRTOS_gmtime_r( &uxCurrentSeconds, &xTimeStruct );\r
 289 \r
 290         /*\r
 291                 378.067 [NTP client] NTP time: 9/11/2015 16:11:19.559 Diff -20 ms (289 ms)\r
 292                 379.441 [NTP client] NTP time: 9/11/2015 16:11:20.933 Diff 0 ms (263 ms)\r
 293         */\r
 294 \r
 295         FreeRTOS_printf( ("NTP time: %d/%d/%02d %2d:%02d:%02d.%03u Diff %d %s (%lu ms)\n",\r
 296                 xTimeStruct.tm_mday,\r
 297                 xTimeStruct.tm_mon + 1,\r
 298                 xTimeStruct.tm_year + 1900,\r
 299                 xTimeStruct.tm_hour,\r
 300                 xTimeStruct.tm_min,\r
 301                 xTimeStruct.tm_sec,\r
 302                 ( unsigned )uxCurrentMS,\r
 303                 ( unsigned )ilDiff,\r
 304                 pcTimeUnit,\r
 305                 uxTravelTime ) );\r
 306 \r
 307         /* Remove compiler warnings in case FreeRTOS_printf() is not used. */\r
 308         ( void ) pcTimeUnit;\r
 309         ( void ) uxTravelTime;\r
 310 }\r
 311 /*-----------------------------------------------------------*/\r
 312 \r
 313 #if( ipconfigUSE_CALLBACKS != 0 )\r
 314 \r
 315         static BaseType_t xOnUDPReceive( Socket_t xSocket, void * pvData, size_t xLength,\r
 316                 const struct freertos_sockaddr *pxFrom, const struct freertos_sockaddr *pxDest )\r
 317         {\r
 318                 if( xLength >= sizeof( xNTPPacket ) )\r
 319                 {\r
 320                         prvReadTime( ( struct SNtpPacket *)pvData );\r
 321                         if( xStatus != EStatusPause )\r
 322                         {\r
 323                                 xStatus = EStatusPause;\r
 324                         }\r
 325                 }\r
 326                 vSignalTask();\r
 327                 /* Tell the driver not to store the RX data */\r
 328                 return 1;\r
 329         }\r
 330         /*-----------------------------------------------------------*/\r
 331 \r
 332 #endif  /* ipconfigUSE_CALLBACKS != 0 */\r
 333 \r
 334 static void prvNTPTask( void *pvParameters )\r
 335 {\r
 336 BaseType_t xServerIndex = 3;\r
 337 struct freertos_sockaddr xAddress;\r
 338 #if( ipconfigUSE_CALLBACKS != 0 )\r
 339         F_TCP_UDP_Handler_t xHandler;\r
 340 #endif /* ipconfigUSE_CALLBACKS != 0 */\r
 341 \r
 342         xStatus = EStatusLookup;\r
 343         #if( ipconfigSOCKET_HAS_USER_SEMAPHORE != 0 ) || ( ipconfigUSE_CALLBACKS != 0 )\r
 344         {\r
 345                 xNTPWakeupSem = xSemaphoreCreateBinary();\r
 346         }\r
 347         #endif\r
 348 \r
 349         #if( ipconfigUSE_CALLBACKS != 0 )\r
 350         {\r
 351                 memset( &xHandler, '\0', sizeof( xHandler ) );\r
 352                 xHandler.pxOnUDPReceive = xOnUDPReceive;\r
 353                 FreeRTOS_setsockopt( xUDPSocket, 0, FREERTOS_SO_UDP_RECV_HANDLER, ( void * ) &xHandler, sizeof( xHandler ) );\r
 354         }\r
 355         #endif\r
 356         #if( ipconfigSOCKET_HAS_USER_SEMAPHORE != 0 )\r
 357         {\r
 358                 FreeRTOS_setsockopt( xUDPSocket, 0, FREERTOS_SO_SET_SEMAPHORE, ( void * ) &xNTPWakeupSem, sizeof( xNTPWakeupSem ) );\r
 359         }\r
 360         #endif\r
 361         for( ; ; )\r
 362         {\r
 363                 switch( xStatus )\r
 364                 {\r
 365                 case EStatusLookup:\r
 366                         if( ( ulIPAddressFound == 0ul ) || ( ulIPAddressFound == ~0ul ) )\r
 367                         {\r
 368                                 if( ++xServerIndex == sizeof( pcTimeServers ) / sizeof( pcTimeServers[ 0 ] ) )\r
 369                                 {\r
 370                                         xServerIndex = 0;\r
 371                                 }\r
 372                                 FreeRTOS_printf( ( "Looking up server '%s'\n", pcTimeServers[ xServerIndex ] ) );\r
 373                                 FreeRTOS_gethostbyname_a( pcTimeServers[ xServerIndex ], vDNS_callback, (void *)NULL, 1200 );\r
 374                         }\r
 375                         else\r
 376                         {\r
 377                                 xStatus = EStatusAsking;\r
 378                         }\r
 379                         break;\r
 380 \r
 381                 case EStatusAsking:\r
 382                         {\r
 383                         char pcBuf[16];\r
 384 \r
 385                                 prvNTPPacketInit( );\r
 386                                 xAddress.sin_addr = ulIPAddressFound;\r
 387                                 xAddress.sin_port = FreeRTOS_htons( NTP_PORT );\r
 388 \r
 389                                 FreeRTOS_inet_ntoa( xAddress.sin_addr, pcBuf );\r
 390                                 FreeRTOS_printf( ( "Sending UDP message to %s:%u\n",\r
 391                                         pcBuf,\r
 392                                         FreeRTOS_ntohs( xAddress.sin_port ) ) );\r
 393 \r
 394                                 uxSendTime = xTaskGetTickCount( );\r
 395                                 FreeRTOS_sendto( xUDPSocket, ( void * )&xNTPPacket, sizeof( xNTPPacket ), 0, &xAddress, sizeof( xAddress ) );\r
 396                         }\r
 397                         break;\r
 398 \r
 399                 case EStatusPause:\r
 400                         break;\r
 401 \r
 402                 case EStatusFailed:\r
 403                         break;\r
 404                 }\r
 405 \r
 406                 #if( ipconfigUSE_CALLBACKS != 0 )\r
 407                 {\r
 408                         xSemaphoreTake( xNTPWakeupSem, 5000 );\r
 409                 }\r
 410                 #else\r
 411                 {\r
 412                 uint32_t xAddressSize;\r
 413                 BaseType_t xReturned;\r
 414 \r
 415                         xAddressSize = sizeof( xAddress );\r
 416                         xReturned = FreeRTOS_recvfrom( xUDPSocket, ( void * ) cRecvBuffer, sizeof( cRecvBuffer ), 0, &xAddress, &xAddressSize );\r
 417                         switch( xReturned )\r
 418                         {\r
 419                         case 0:\r
 420                         case -pdFREERTOS_ERRNO_EAGAIN:\r
 421                         case -pdFREERTOS_ERRNO_EINTR:\r
 422                                 break;\r
 423                         default:\r
 424                                 if( xReturned < sizeof( xNTPPacket ) )\r
 425                                 {\r
 426                                         FreeRTOS_printf( ( "FreeRTOS_recvfrom: returns %ld\n", xReturned ) );\r
 427                                 }\r
 428                                 else\r
 429                                 {\r
 430                                         prvReadTime( ( struct SNtpPacket *)cRecvBuffer );\r
 431                                         if( xStatus != EStatusPause )\r
 432                                         {\r
 433                                                 xStatus = EStatusPause;\r
 434                                         }\r
 435                                 }\r
 436                                 break;\r
 437                         }\r
 438                 }\r
 439                 #endif\r
 440         }\r
 441 }\r
 442 /*-----------------------------------------------------------*/\r