clock.c

   1 /*
   2  * Copyright 2017 Jonathan McDowell <noodles@earth.li>
   3  *
   4  * This program is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 3 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * This program is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  *
  17  * NTP code based on https://github.com/raburton/esp8266/tree/master/ntp
  18  * Those portions MIT licensed:
  19  *
  20  * Copyright (c) 2015 Richard A Burton (richardaburton@gmail.com)
  21  *
  22  * Permission is hereby granted, free of charge, to any person obtaining a copy
  23  * of this software and associated documentation files (the "Software"), to deal
  24  * in the Software without restriction, including without limitation the rights
  25  * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
  26  * copies of the Software, and to permit persons to whom the Software is
  27  * furnished to do so, subject to the following conditions:
  28  *
  29  * The above copyright notice and this permission notice shall be included in
  30  * all copies or substantial portions of the Software.
  31  *
  32  * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
  33  * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
  34  * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
  35  * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
  36  * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
  37  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
  38  * THE SOFTWARE.
  39  */
  40 #include <stdint.h>
  41
  42 #include <user_interface.h>
  43 #include <espconn.h>
  44 #include <mem.h>
  45 #include <osapi.h>
  46
  47 #include "espmissingincludes.h"
  48
  49 #include "clock.h"
  50
  51 #define NTP_SERVER     "uk.pool.ntp.org"
  52 #define NTP_TIMEOUT_MS 5000
  53
  54 static uint32_t sys_last_ticks;
  55 static uint32_t sys_delta;
  56 static os_timer_t ntp_timeout;
  57
  58 static ip_addr_t ntp_server_ip;
  59
  60 typedef struct {
  61         uint8 options;
  62         uint8 stratum;
  63         uint8 poll;
  64         uint8 precision;
  65         uint32 root_delay;
  66         uint32 root_disp;
  67         uint32 ref_id;
  68         uint8 ref_time[8];
  69         uint8 orig_time[8];
  70         uint8 recv_time[8];
  71         uint8 trans_time[8];
  72 } ntp_t;
  73
  74 void ICACHE_FLASH_ATTR set_time(uint32_t now)
  75 {
  76         sys_last_ticks = system_get_time();
  77         sys_delta = now - (sys_last_ticks / 1000000);
  78 }
  79
  80 uint32_t ICACHE_FLASH_ATTR get_time(void)
  81 {
  82         uint32_t sys_ticks;
  83
  84         sys_ticks = system_get_time();
  85         if (sys_ticks < sys_last_ticks) {
  86                 sys_delta += (1ULL << 32ULL) / 1000000;
  87         }
  88         sys_last_ticks = sys_ticks;
  89
  90         return sys_ticks / 1000000 + sys_delta;
  91 }
  92
  93 bool ICACHE_FLASH_ATTR is_leap(uint32_t year)
  94 {
  95         return year % 4 == 0 && (year % 100 != 0 || year % 400 == 0);
  96 }
  97
  98 void ICACHE_FLASH_ATTR breakdown_time(uint32_t time, struct tm *result)
  99 {
 100         uint32_t era, doe, yoe, mp;
 101
 102         /* Do the time component */
 103         result->tm_sec = time % 60;
 104         time /= 60;
 105         result->tm_min = time % 60;
 106         time /= 60;
 107         result->tm_hour = time % 24;
 108         time /= 24;
 109
 110         /* Now time is the number of days since 1970-01-01 (a Thursday) */
 111         result->tm_wday = (time + 4) % 7;
 112
 113         /* Below from http://howardhinnant.github.io/date_algorithms.html */
 114         time += 719468;
 115         era = time / 146097;
 116         doe = time - era * 146097;
 117         yoe = (doe - doe / 1460 + doe / 36524 - doe / 146096) / 365;
 118
 119         result->tm_year = yoe + era * 400;
 120         result->tm_yday = doe - (365 * yoe + yoe / 4 - yoe / 100);
 121         mp = (5 * result->tm_yday + 2) / 153;
 122         result->tm_mday = result->tm_yday - (153 * mp + 2) / 5 + 1;
 123         result->tm_mon = mp + (mp < 10 ? 2 : -10);
 124         if (result->tm_mon <=2)
 125                 result->tm_year++;
 126
 127         /* result->tm_yday is March 1st indexed at this point; fix up */
 128         result->tm_yday += 28 + 31;
 129         if (is_leap(result->tm_year))
 130                 result->tm_yday++;
 131 }
 132
 133 static void ICACHE_FLASH_ATTR ntp_udp_timeout(void *arg)
 134 {
 135         struct espconn *pCon = (struct espconn *) arg;
 136
 137         os_timer_disarm(&ntp_timeout);
 138         os_printf("NTP timeout.\n");
 139
 140         // clean up connection
 141         if (pCon) {
 142                 espconn_delete(pCon);
 143                 os_free(pCon->proto.udp);
 144                 os_free(pCon);
 145                 pCon = 0;
 146         }
 147 }
 148
 149 static void ICACHE_FLASH_ATTR ntp_udp_recv(void *arg, char *pdata,
 150         unsigned short len)
 151 {
 152         struct espconn *pCon = (struct espconn *) arg;
 153         uint32_t timestamp;
 154         ntp_t *ntp;
 155         struct tm dt;
 156
 157         os_printf("Got NTP response.\n");
 158
 159         os_timer_disarm(&ntp_timeout);
 160
 161         // Extract NTP time
 162         ntp = (ntp_t *) pdata;
 163         timestamp = ntp->trans_time[0] << 24 | ntp->trans_time[1] << 16 |
 164                 ntp->trans_time[2] << 8 | ntp->trans_time[3];
 165         // Convert to Unix time ms
 166         timestamp -= 2208988800ULL;
 167
 168         // Store the time
 169         set_time(timestamp);
 170
 171         // Print it out
 172         breakdown_time(timestamp, &dt);
 173         os_printf("%04d-%02d-%02d %02d:%02d:%02d (%u)\r\n",
 174                 dt.tm_year, dt.tm_mon + 1, dt.tm_mday,
 175                 dt.tm_hour, dt.tm_min, dt.tm_sec, timestamp);
 176
 177         // clean up connection
 178         if (pCon) {
 179                 espconn_delete(pCon);
 180                 os_free(pCon->proto.udp);
 181                 os_free(pCon);
 182                 pCon = NULL;
 183         }
 184 }
 185
 186 void ICACHE_FLASH_ATTR ntp_got_dns(const char *name, ip_addr_t *ip, void *arg)
 187 {
 188         ntp_t ntp;
 189         struct espconn *pCon = (struct espconn *) arg;
 190
 191         if (ip == NULL) {
 192                 os_printf("NTP DNS request failed.\n");
 193                 os_free(pCon);
 194                 return;
 195         }
 196
 197         os_printf("Sending NTP request.\n");
 198
 199         // Set up the UDP "connection"
 200         pCon->type = ESPCONN_UDP;
 201         pCon->state = ESPCONN_NONE;
 202         pCon->proto.udp = (esp_udp *) os_zalloc(sizeof(esp_udp));
 203         pCon->proto.udp->local_port = espconn_port();
 204         pCon->proto.udp->remote_port = 123;
 205         os_memcpy(pCon->proto.udp->remote_ip, &ip->addr, 4);
 206
 207         // Create a really simple NTP request packet
 208         os_memset(&ntp, 0, sizeof(ntp_t));
 209         ntp.options = 0b00100011; // leap = 0, version = 4, mode = 3 (client)
 210
 211         // Set timeout timer
 212         os_timer_disarm(&ntp_timeout);
 213         os_timer_setfn(&ntp_timeout, (os_timer_func_t*) ntp_udp_timeout, pCon);
 214         os_timer_arm(&ntp_timeout, NTP_TIMEOUT_MS, 0);
 215
 216         // Send the NTP request
 217         espconn_create(pCon);
 218         espconn_regist_recvcb(pCon, ntp_udp_recv);
 219         espconn_sent(pCon, (uint8_t *) &ntp, sizeof(ntp_t));
 220 }
 221
 222 void ICACHE_FLASH_ATTR ntp_get_time(void)
 223 {
 224         struct espconn *pCon = NULL;
 225
 226         os_printf("Sending DNS request for NTP server.\n");
 227         pCon = (struct espconn *) os_zalloc(sizeof(struct espconn));
 228         espconn_gethostbyname(pCon, NTP_SERVER, &ntp_server_ip, ntp_got_dns);
 229 }
 230
 231 void ICACHE_FLASH_ATTR rtc_init(void)
 232 {
 233         sys_last_ticks = system_get_time();
 234 }