better blink

cube/Core/Src/main.c

@@ -1,4 +1,4 @@
-// Processed by ../tools/insertMyCode.sh
+// Processed by ../tools/insertMyCode.sh
 /* USER CODE BEGIN Header */
 /**
   ******************************************************************************
@@ -27,8 +27,8 @@
 #include "gpio.h"
 
 /* Private includes ----------------------------------------------------------*/
-/* USER CODE BEGIN Includes */
-#include "main2.h"
+/* USER CODE BEGIN Includes */
+#include "main2.h"
 
 
 /* USER CODE END Includes */
@@ -70,8 +70,8 @@ void SystemClock_Config(void);
   */
 int main(void)
 {
-  /* USER CODE BEGIN 1 */
-  my_setup_1();
+  /* USER CODE BEGIN 1 */
+  my_setup_1();
 
 
   /* USER CODE END 1 */
@@ -98,9 +98,9 @@ int main(void)
   MX_SPI2_Init();
   MX_TIM1_Init();
   MX_USART1_UART_Init();
-  // MX_IWDG_Init();
-  /* USER CODE BEGIN 2 */
-  my_setup_2();
+  MX_IWDG_Init();
+  /* USER CODE BEGIN 2 */
+  my_setup_2();
 
 
   /* USER CODE END 2 */
@@ -111,8 +111,8 @@ int main(void)
   {
     /* USER CODE END WHILE */
 
-    /* USER CODE BEGIN 3 */
-    my_loop();
+    /* USER CODE BEGIN 3 */
+    my_loop();
 
   }
   /* USER CODE END 3 */
@@ -167,13 +167,13 @@ void SystemClock_Config(void)
   */
 void Error_Handler(void)
 {
-  /* USER CODE BEGIN Error_Handler_Debug */
-  my_errorHandler();
+  /* USER CODE BEGIN Error_Handler_Debug */
+  my_errorHandler();
 
   /* User can add his own implementation to report the HAL error return state */
 
-  /* USER CODE END Error_Handler_Debug */
-  while(1) { };
+  /* USER CODE END Error_Handler_Debug */
+  while(1) { };
 
 }
 

cube/User/Inc/networkAbstractionLayer_impl.h

@@ -2,12 +2,11 @@
 #define _NETWORK_ABSTRACTION_LAYER_IMPL_H_
 
 #include <stdint.h>
+#include <stdbool.h>
 
 uint64_t networkSntpQuery();
-
-
 int8_t networkUdpSend(char *hostname, uint16_t port, uint8_t *buf, uint16_t bufLen);
 void networkImplInit();
-
+bool isNetworkAvailable();
 
 #endif /* _NETWORK_ABSTRACTION_LAYER_IMPL_H_ */

cube/User/Inc/show.h

@@ -12,7 +12,7 @@ typedef enum {
     LED_BLUE
 } signalPin_t;
 
-typedef enum { ON, OFF, TOGGLE, BLINK } signalAction_t;
+typedef enum { ON, OFF, TOGGLE, BLINK, BLINK_FAST } signalAction_t;
 
 void showInit();
 void show(signalPin_t signalPin, signalAction_t action);

cube/User/Inc/wizHelper.h

@@ -7,10 +7,9 @@
 
 
 int wizInit();
-bool isNetworkAvailable();
+bool wizIsNetworkAvailable();
 uint8_t* wizGetIPAddress();
 bool wizDnsQuery(char *name, uint8_t *ip);
-uint64_t wizSntpQuery();
 
 
 #endif // _WIZHELPER_H_

cube/User/Src/counter.c

@@ -48,7 +48,7 @@ void counterMinuteTick(void *handle) {
             minuteBuffer->s.totalRunningHours = deviceStats->totalRunningHours;
             minuteBuffer->s.totalPowercycles = deviceStats->totalPowercycles;
             minuteBuffer->s.totalWatchdogResets = deviceStats->totalWatchdogResets;
-            minuteBuffer->s.version = strtol(VERSION, NULL, 16);
+            minuteBuffer->s.version = strtoll(VERSION, NULL, 16);
 
 
             memset(minuteBuffer->s.deviceId, 0, sizeof(minuteBuffer->s.deviceId));

cube/User/Src/networkAbstractionLayer.c

@@ -3,6 +3,7 @@
 #include <iwdg.h>
 #include <logger.h>
 #include <sinkStruct.h>
+#include <show.h>
 #include <config.h>
 
 #include <networkAbstractionLayer_impl.h>
@@ -14,12 +15,13 @@ static t_seconds seconds = { .seconds = 0, .missedUpdates = 0, .valid = false };
 static t_configBlock *config;
 
 
+
 static void networkSecondsHandler(void *handle) {
     static bool tryAgain = false;
 
     seconds.seconds += 1;
 
-    if (! seconds.valid) {
+    if (! seconds.valid && isNetworkAvailable()) {
         coloredMsg(LOG_YELLOW, "nsh, initially querying time");
         uint64_t tmpSeconds = networkSntpQuery();
         if (tmpSeconds != 0) {
@@ -27,6 +29,7 @@ static void networkSecondsHandler(void *handle) {
             seconds.seconds = tmpSeconds;
             seconds.missedUpdates = 0;
             seconds.valid = true;
+            show(LED_GREEN, ON);
         } else {
             coloredMsg(LOG_YELLOW, "nsh, failed");
             seconds.missedUpdates += 1;
@@ -38,6 +41,7 @@ static void networkSecondsHandler(void *handle) {
             coloredMsg(LOG_YELLOW, "nsh, success, network time is %lu", tmpSeconds);
             seconds.missedUpdates = 0;
             tryAgain = false;
+            show(LED_GREEN, ON);
             if (seconds.seconds != tmpSeconds) {
                 coloredMsg(LOG_YELLOW, "nsh, local time updated");
                 seconds.seconds = tmpSeconds;

cube/User/Src/networkAbstractionLayer_lan.c

@@ -4,134 +4,195 @@
 #include <networkAbstractionLayer_impl.h>
 #include <logger.h>
 #include <PontCoopScheduler.h>
+
 #include <wizHelper.h>
 #include <wizchip_conf.h>
 #include <socket.h>
-#include <wizchip_conf.h>
 #include <config.h>
+#include <sntp.h>
+
 
 static t_configBlock *config;
 
 
-const uint16_t MAX_RECV_RETRY_COUNT = 100;
-const uint64_t UNIX_NTP_EPOCH_DIFF = 2208988800;
+
+static const uint64_t UNIX_NTP_EPOCH_DIFF = 2208988800;
+static const uint16_t NTP_PORT = 123;
+static const uint16_t MAX_SNTP_RETRIES = 100;
+extern const uint8_t SNTP_SOCK;
+
+
 
 const uint8_t SEND_LI_VN_MODE = 0xe3; // LI: unknown (3), VN: 4, Mode: Client (3)
-typedef struct {
+typedef struct s_ntpStruct {
     uint8_t   li_vn_mode;
-	uint8_t   stratum;
-	uint8_t   poll;
-	uint8_t   precision;
-	uint32_t  rootdelay;
-	uint32_t  rootdisp;
-	uint32_t  refid;
-	uint64_t  reftime;
-	uint64_t  org;
-	uint64_t  rec;
-	uint64_t  xmt;
+    uint8_t   stratum;
+    uint8_t   poll;
+    uint8_t   precision;
+    uint32_t  rootdelay;
+    uint32_t  rootdisp;
+    uint32_t  refid;
+    //uint64_t  reftime;
+    uint32_t reftime_h;
+    uint32_t reftime_l;
+    //uint64_t  org;
+    uint32_t org_h;
+    uint32_t org_l;
+    //uint64_t  rec;
+    uint32_t rec_h;
+    uint32_t rec_l;
+    //uint64_t  xmt;
+    uint32_t xmt_h;
+    uint32_t xmt_l;
+} t_ntpStruct;
+
+typedef union __attribute__((__packed__)) {
+    t_ntpStruct s;
+    uint8_t b[sizeof(t_ntpStruct)];
 } ntpMsg_t;
 
-extern uint8_t SNTP_SOCK;
+typedef struct {
+    ntpMsg_t ntpMsg;
+    uint8_t ntpAddr[4];
+    uint16_t retryCount;
+    uint64_t seconds;
+    enum {
+        SNTP_STATE_IDLE,
+        SNTP_STATE_START, 
+        SNTP_STATE_SEND,
+        SNTP_STATE_RECV,
+        SNTP_STATE_DONE,
+        SNTP_STATE_ERROR
+    } sntpState;
+} sntpEngineHandle_t;
 
-const uint16_t NTP_PORT = 123;
-
-enum { 
-    SNTP_STATE_IDLE, 
-    SNTP_STATE_START,
-    SNTP_STATE_SEND,
-    SNTP_STATE_RECV,
-    SNTP_STATE_ERROR,
-    SNTP_STATE_DONE 
-} sntpState = SNTP_STATE_IDLE;
-uint64_t seconds;
+sntpEngineHandle_t sntpEngineHandle = { 
+    .seconds = 0, 
+    .retryCount = 0, 
+    .sntpState = SNTP_STATE_IDLE 
+};
 
 
-/*
-static void networkSntpEngine(void *handle) {
-    static uint16_t retryCount = 0;
-
-    coloredMsg(LOG_BLUE, "nes, %u", sntpState);
-
-    switch (sntpState) {
-        case SNTP_STATE_START:
-            coloredMsg(LOG_BLUE, "nes, about to send");
-            uint8_t ntpAddr[4];
-            if (! wizDnsQuery(config->ntpServer, ntpAddr)) {
-                coloredMsg(LOG_BLUE, "nes, failed to resolve ntp server");
-                sntpState = SNTP_STATE_ERROR;
-            } else {
+void networkSntpEngine(void *handle) {
+    sntpEngineHandle_t *localHandle = (sntpEngineHandle_t*) handle;
+    if (isNetworkAvailable()) {
+        switch (localHandle->sntpState) {
+            case SNTP_STATE_START:
+                coloredMsg(LOG_BLUE, "nes, resolve ntp server");
+                if (! wizDnsQuery(config->ntpServer, localHandle->ntpAddr)) {
+                    coloredMsg(LOG_BLUE, "nes, failed to resolve ntp server");
+                    localHandle->sntpState = SNTP_STATE_ERROR;
+                } else {
+                    localHandle->sntpState = SNTP_STATE_SEND;
+                    schAdd(networkSntpEngine, (void*) localHandle, 10, 0);
+                }
+                break;
+            case SNTP_STATE_SEND:
+                coloredMsg(LOG_BLUE, "nes, about to call SNTP");
+                localHandle->retryCount = 0;
                 socket(SNTP_SOCK, Sn_MR_UDP, NTP_PORT, 0);
-                retryCount = 0;
                 uint8_t sockState = getSn_SR(SNTP_SOCK);
                 if (sockState == SOCK_UDP) {
-                    ntpMsg_t ntpMsg;
-                    memset(&ntpMsg, 0, sizeof(ntpMsg));
-                    ntpMsg.li_vn_mode = SEND_LI_VN_MODE;
-                    sendto(SNTP_SOCK, (uint8_t*)&ntpMsg, sizeof(ntpMsg), ntpAddr, NTP_PORT);
+                    memset(&(localHandle->ntpMsg), 0, sizeof(localHandle->ntpMsg));
+                    localHandle->ntpMsg.s.li_vn_mode = SEND_LI_VN_MODE;
+                    localHandle->ntpMsg.s.xmt_l = 1;
+                    sendto(SNTP_SOCK, localHandle->ntpMsg.b, 
+                           sizeof(localHandle->ntpMsg.b), localHandle->ntpAddr, NTP_PORT);
                     coloredMsg(LOG_BLUE, "nes, sent");
-                    sntpState = SNTP_STATE_RECV;
-                    schAdd(networkSntpEngine, NULL, 1000, 0);
+                    localHandle->sntpState = SNTP_STATE_RECV;
+                    schAdd(networkSntpEngine, (void*) localHandle, 100, 0);
                 } else {
-                    coloredMsg(LOG_BLUE, "nes, socket in unexpected state: %d", sockState);
-                    sntpState = SNTP_STATE_ERROR;
+                    coloredMsg(LOG_BLUE, "nes, socket in unexpected state %d", sockState);
+                    localHandle->sntpState = SNTP_STATE_ERROR;
                 }
-            }
-            break;
-        case SNTP_STATE_RECV:
-            coloredMsg(LOG_BLUE, "nes, check receive");
-            uint16_t recvLen = getSn_RX_RSR(SNTP_SOCK);
-            if (recvLen == 0) {
-                retryCount += 1;
-                if (retryCount > MAX_RECV_RETRY_COUNT) {
-                    coloredMsg(LOG_BLUE, "nes max retry count reached, failed");
-                    sntpState = SNTP_STATE_ERROR;
+                break;
+            case SNTP_STATE_RECV:
+                coloredMsg(LOG_BLUE, "nes, check receive");
+                localHandle->retryCount += 1;
+                uint16_t recvLen = getSn_RX_RSR(SNTP_SOCK);
+                if (recvLen == 0) {
+                    if (localHandle->retryCount > MAX_SNTP_RETRIES) {
+                        coloredMsg(LOG_BLUE, "nes, max retry count reached, failed");
+                        localHandle->sntpState = SNTP_STATE_ERROR;
+                    } else {
+                        coloredMsg(LOG_BLUE, "nes, nothing received yet, try again");
+                        schAdd(networkSntpEngine, (void*) localHandle, 100, 0);
+                    }
+                } else if (recvLen >= sizeof(localHandle->ntpMsg)) {
+                    memset(&(localHandle->ntpMsg), 0, sizeof(localHandle->ntpMsg));
+                    uint8_t srcAddr[4];
+                    uint16_t srcPort;
+                    
+                    recvfrom(SNTP_SOCK, localHandle->ntpMsg.b,
+                             sizeof(localHandle->ntpMsg.b), srcAddr, &srcPort);
+                    
+                    
+                    uint8_t *buf = localHandle->ntpMsg.b;
+                    uint8_t x = 0;
+                    coloredMsg(LOG_BLUE, "nes, %02x %02x %02x %02x %02x %02x %02x %02x  %02x %02x %02x %02x %02x %02x %02x %02x",
+                               buf[x+0], buf[x+1], buf[x+2], buf[x+3], buf[x+4], buf[x+5], buf[x+6], buf[x+7],
+                               buf[x+8], buf[x+9], buf[x+10], buf[x+11], buf[x+12], buf[x+13], buf[x+14], buf[x+15]);
+                    x += 16;
+                    coloredMsg(LOG_BLUE, "nes, %02x %02x %02x %02x %02x %02x %02x %02x  %02x %02x %02x %02x %02x %02x %02x %02x",
+                               buf[x+0], buf[x+1], buf[x+2], buf[x+3], buf[x+4], buf[x+5], buf[x+6], buf[x+7],
+                               buf[x+8], buf[x+9], buf[x+10], buf[x+11], buf[x+12], buf[x+13], buf[x+14], buf[x+15]);
+                    x += 16;
+                    coloredMsg(LOG_BLUE, "nes, %02x %02x %02x %02x %02x %02x %02x %02x  %02x %02x %02x %02x %02x %02x %02x %02x",
+                               buf[x+0], buf[x+1], buf[x+2], buf[x+3], buf[x+4], buf[x+5], buf[x+6], buf[x+7],
+                               buf[x+8], buf[x+9], buf[x+10], buf[x+11], buf[x+12], buf[x+13], buf[x+14], buf[x+15]);
+                    x += 16;
+                    coloredMsg(LOG_BLUE, "nes, %02x %02x %02x %02x %02x %02x %02x %02x  %02x %02x %02x %02x %02x %02x %02x %02x",
+                               buf[x+0], buf[x+1], buf[x+2], buf[x+3], buf[x+4], buf[x+5], buf[x+6], buf[x+7],
+                               buf[x+8], buf[x+9], buf[x+10], buf[x+11], buf[x+12], buf[x+13], buf[x+14], buf[x+15]);
+
+                    close(SNTP_SOCK);
+                    coloredMsg(LOG_BLUE, "nes, msg received from %d.%d.%d.%d:%d", 
+                               srcAddr[0], srcAddr[1], srcAddr[2], srcAddr[3],
+                               srcPort);
+                    
+                    coloredMsg(LOG_BLUE, "nes, received in the %d. cycles", localHandle->retryCount);
+                    uint32_t xmt_h = 
+                        (localHandle->ntpMsg.s.xmt_h & 0x0000000ff) << 24 |
+                        (localHandle->ntpMsg.s.xmt_h & 0x00000ff00) << 8 |
+                        (localHandle->ntpMsg.s.xmt_h & 0x000ff0000) >> 8 |
+                        (localHandle->ntpMsg.s.xmt_h & 0x0ff000000) >> 24;
+                    localHandle->seconds = ((uint64_t)xmt_h) - UNIX_NTP_EPOCH_DIFF;
+                    coloredMsg(LOG_BLUE, "nes, xmt: %08x", xmt_h);
+                    coloredMsg(LOG_BLUE, "nes, seconds: %lu", localHandle->seconds);
+                    localHandle->sntpState = SNTP_STATE_DONE;
                 } else {
-                    coloredMsg(LOG_BLUE, "nes, nothing received yet, try again");
-                    schAdd(networkSntpEngine, NULL, 100, 0);
+                    coloredMsg(LOG_BLUE, "nes, invalid number of octets received: %d", recvLen);
+                    localHandle->sntpState = SNTP_STATE_ERROR;
                 }
-            } else if (recvLen == sizeof(ntpMsg_t)) {
-                ntpMsg_t ntpMsg;
-                memset(&ntpMsg, 0, sizeof(ntpMsg_t));
-                uint8_t srcAddr[4];
-                uint16_t srcPort;
-                recvfrom(SNTP_SOCK, (uint8_t*)&ntpMsg, sizeof(ntpMsg_t), srcAddr, &srcPort);
-                close(SNTP_SOCK);
-                coloredMsg(LOG_BLUE, "nes, msg received from %d.%d.%d.%d:%d", 
-                           srcAddr[0], srcAddr[1], srcAddr[2], srcAddr[3],
-                           srcPort);
-                coloredMsg(LOG_BLUE, "nes, received in the %d. cycles", retryCount);
-                seconds = ntpMsg.rec - UNIX_NTP_EPOCH_DIFF;
-                coloredMsg(LOG_BLUE, "nes, seconds: %lu", seconds);
-                sntpState = SNTP_STATE_DONE;
-            } else {
-                coloredMsg(LOG_BLUE, "nes, invalid number of octets received: %d", recvLen);
-                sntpState = SNTP_STATE_ERROR;
-            }
-            break;
-        default:
-            coloredMsg(LOG_BLUE, "nes, unexpected state");
+                break;
+            default:
+                coloredMsg(LOG_BLUE, "nes, unexpected state");
+        }
+    } else {
+        coloredMsg(LOG_BLUE, "nes, no network yet, try again");
+        schAdd(networkSntpEngine, (void*) localHandle, 100, 0);
     }
 }
-*/
-
 
 uint64_t networkSntpQuery() {
-    /*
     uint64_t res = 0;
-    if (sntpState == SNTP_STATE_IDLE) {
-        sntpState = SNTP_STATE_START;
-        schAdd(networkSntpEngine, NULL, 1, 0);
-    } else if (sntpState == SNTP_STATE_ERROR) {
-        sntpState = SNTP_STATE_IDLE;
-    } else if (sntpState == SNTP_STATE_DONE) {
-        sntpState = SNTP_STATE_IDLE;
-        res = seconds;
-    }
-    return res;
-    */
-   return 0;
-}
 
+    if (sntpEngineHandle.sntpState == SNTP_STATE_IDLE) {
+        coloredMsg(LOG_BLUE, "nsq, start sntp request");
+        sntpEngineHandle.sntpState = SNTP_STATE_START;
+        schAdd(networkSntpEngine, (void*) &sntpEngineHandle, 1, 0);
+    } else if (sntpEngineHandle.sntpState == SNTP_STATE_DONE) {
+        coloredMsg(LOG_BLUE, "nsq, start sntp done");
+        res = sntpEngineHandle.seconds;
+        coloredMsg(LOG_BLUE, "nsq, time is %lu", res);
+        sntpEngineHandle.sntpState = SNTP_STATE_IDLE;
+    } else if (sntpEngineHandle.sntpState == SNTP_STATE_ERROR) {
+        coloredMsg(LOG_BLUE, "nsq, start sntp failed");
+        sntpEngineHandle.sntpState = SNTP_STATE_IDLE;
+    }
+
+    return res;
+}
 
 extern uint8_t SINK_SOCK;
 
@@ -159,6 +220,10 @@ int8_t networkUdpSend(char *hostname, uint16_t port, uint8_t *buf, uint16_t bufL
     return 1;
 }
 
+bool isNetworkAvailable() {
+    return wizIsNetworkAvailable();
+}
+
 void networkImplInit() {
     config = getConfig();
     wizInit();

cube/User/Src/show.c

@@ -1,6 +1,7 @@
 #include <main.h>
 #include <show.h>
 #include <PontCoopScheduler.h>
+#include <show.h>
 
 #include <stdint.h>
 #include <stdlib.h>
@@ -24,9 +25,20 @@ showElement_t showElement[] = {
 };
 
 static void showHandler(void *handle) {
+    const uint8_t MAX_CNT = 3;
+    static uint8_t cnt = 0;
+    cnt += 1;
+    if (cnt > MAX_CNT) {
+        cnt = 0;
+    }
+
     uint8_t idx = 0;
     while (showElement[idx].port) {
         if (showElement[idx].currentState == BLINK) {
+            if (cnt == MAX_CNT) {
+                HAL_GPIO_TogglePin(showElement[idx].port, showElement[idx].pin);
+            }
+        } else if (showElement[idx].currentState == BLINK_FAST) {
             HAL_GPIO_TogglePin(showElement[idx].port, showElement[idx].pin);
         }
         idx++;
@@ -43,5 +55,5 @@ void show(signalPin_t signalPin, signalAction_t action) {
 }
 
 void showInit() {
-    schAdd(showHandler, NULL, 0, 250);
+    schAdd(showHandler, NULL, 0, 100);
 }

cube/User/Src/wizHelper.c

@@ -33,7 +33,7 @@ extern const uint8_t DNS_SOCK;
 
 static bool networkAvailable = false;
 
-bool isNetworkAvailable() {
+bool wizIsNetworkAvailable() {
     return networkAvailable;
 }
 
@@ -86,7 +86,7 @@ static void wizDHCPAssign() {
     coloredMsg(LOG_BLUE, "wizda, set netinfo again");
 
     networkAvailable = true;
-    show(LED_GREEN, ON);
+    show(LED_GREEN, BLINK_FAST);
     coloredMsg(LOG_BLUE, "wizda, network is available");
 }