Build with constparam

Author: kivkiv12345

lib/apm_csh

@@ -8,8 +8,8 @@
 #include <stdio.h>
 #include <time.h>
 #include <pthread.h>
-#include <param/param_queue.h>
 #include <param/param_server.h>
+#include <param/param_queue.h>
 #include <param/param_serializer.h>
 #include <mpack/mpack.h>
 #include <csp/csp.h>
@@ -20,6 +20,7 @@
 #include <apm/csh_api.h>
 
 #include "param_sniffer.h"
+#include "hk_param_sniffer.h"
 
 pthread_t hk_param_sniffer_thread;
 #define MAX_HKS 16
@@ -38,41 +39,16 @@ typedef struct timesync_nodes_s {
 } timesync_nodes_t;
 static timesync_nodes_t timesync_nodes = {0};
 
-void hk_set_utcparam(unsigned int node, unsigned int paramid) {
-
-	// update existing
-	for (int i = 0; i < timesync_nodes.count; i++) {
-		if (timesync_nodes.node[i] == node) {
-			timesync_nodes.node[i] = node;
-			timesync_nodes.paramid[i] = paramid;
-			printf("Updating HK UTC parameter from node %u\n", node);
-			return;
-		}
-	}
-
-	if (timesync_nodes.count >= MAX_HKS) {
-		printf("Error: Maximum number of HK nodes reached (%d). Cannot set new utcparam for node %u\n", MAX_HKS, node);
-		return;
-	}
-
-	timesync_nodes.node[timesync_nodes.count] = node;
-	timesync_nodes.paramid[timesync_nodes.count++] = paramid;
-
-	printf("Adding HK UTC parameter from node %u\n", node);
-}
-
 void hk_set_epoch(time_t epoch, uint16_t node, bool auto_sync) {
 
 	time_t current_epoch;
 	time(&current_epoch);
-	char current_time_str[32];
-	strftime(current_time_str, sizeof(current_time_str), "%Y-%m-%d %H:%M:%S", gmtime(&current_epoch));
 
-	/* 1577833200: Jan 1st 2020 */
-	if (epoch > current_epoch || epoch < 1577833200) {
+	/* 1577836800: Jan 1st 2020 */
+	if (epoch > current_epoch || epoch < 1577836800) {
 		char current_epoch_str[32];
 		strftime(current_epoch_str, sizeof(current_epoch_str), "%Y-%m-%d %H:%M:%S", gmtime(&epoch));
-		printf("At %s: Illegal EPOCH %lu (%s) received\n", current_time_str, current_epoch, current_epoch_str);
+		printf("HK: Illegal EPOCH %lu (%s) received\n", current_epoch, current_epoch_str);
 		return;
 	}
 
@@ -85,15 +61,15 @@ void hk_set_epoch(time_t epoch, uint16_t node, bool auto_sync) {
 				strftime(time, sizeof(time), "%Y-%m-%d %H:%M:%S", gmtime(&epoch));
 				char time_current[32];
 				strftime(time_current, sizeof(time_current), "%Y-%m-%d %H:%M:%S", gmtime(&hks.local_epoch[i]));
-				printf("At %s: Skipping possible invalid EPOCH %s, current EPOCH for HK node %u is %s\n", current_time_str, time, node, time_current);
+				printf("HK: Skipping possible invalid EPOCH %s, current EPOCH for HK node %u is %s (%ld)\n", time, node, time_current, hks.local_epoch[i]);
 				return;
 			}
 
 			if (labs(hks.local_epoch[i] - epoch) > 1 || !auto_sync) {
 				/* get unix time to string time */
 				char time[32];
 				strftime(time, sizeof(time), "%Y-%m-%d %H:%M:%S", gmtime(&epoch));
-				printf("At %s: Updating HK node %u EPOCH by %ld sec to %s\n", current_time_str, node, hks.local_epoch[i] - epoch, time);
+				printf("HK: Updating HK node %u EPOCH by %ld sec to %s (%ld)\n", node, hks.local_epoch[i] - epoch, time, epoch);
 			}
 
 			hks.local_epoch[i] = epoch;
@@ -102,14 +78,16 @@ void hk_set_epoch(time_t epoch, uint16_t node, bool auto_sync) {
 	}
 
 	if (hks.count >= MAX_HKS) {
-		printf("At %s: Error: Maximum number of HK nodes reached (%d). Cannot set new epoch for node %u\n", current_time_str, MAX_HKS, node);
+		printf("HK: Error: Maximum number of HK nodes reached (%d). Cannot set new epoch for node %u\n", MAX_HKS, node);
 		return;
 	}
 
 	hks.node[hks.count] = node;
 	hks.local_epoch[hks.count++] = epoch;
 
-	printf("At %s: Setting new hk node %u EPOCH to %ld\n", current_time_str, node, epoch);
+	char new_epoch_str[32];
+	strftime(new_epoch_str, sizeof(new_epoch_str), "%Y-%m-%d %H:%M:%S", gmtime(&epoch));
+	printf("HK: Setting new hk node %u EPOCH to %s (%ld)\n", node, new_epoch_str, epoch);
 }
 
 bool hk_get_epoch(time_t * local_epoch, uint16_t node) {
@@ -151,33 +129,37 @@ bool hk_param_sniffer(csp_packet_t * packet) {
 		if (node == 0) {
 			node = packet->id.src;
 		}
-		param_t * param = param_list_find_id(node, id);
+		const param_t * param = param_list_find_id(node, id);
 		if (param) {
 			*param->timestamp = timestamp;
 			if (param->timestamp->tv_sec == 0) {
 				printf("HK: Param timestamp is missing for %u:%s, logging is aborted\n", *(param->node), param->name);
 				break;
 			}
 
-			time_t local_epoch = -1;
-			for (int i = 0; i < timesync_nodes.count; i++) {
-				if (timesync_nodes.node[i] == node && timesync_nodes.paramid[i] == param->id) {
-					mpack_tag_t tag = mpack_peek_tag(&reader);
-					local_epoch = tag.v.i - timestamp.tv_sec;
-					hk_set_epoch(local_epoch, packet->id.src, true);
-					break;
+			/* Only use local epoch if not receiving a UTC timestamp. 1577836800: Jan 1st 2020 */
+			if (param->timestamp->tv_sec < 1577836800) {
+				time_t local_epoch = -1;
+				for (int i = 0; i < timesync_nodes.count; i++) {
+					if (timesync_nodes.node[i] == node && timesync_nodes.paramid[i] == param->id) {
+						mpack_tag_t tag = mpack_peek_tag(&reader);
+						local_epoch = tag.v.i - timestamp.tv_sec;
+						hk_set_epoch(local_epoch, packet->id.src, true);
+						break;
+					}
 				}
-			}
-			if (local_epoch == -1 && !hk_get_epoch(&local_epoch, packet->id.src)) {
-				if(!epoch_notfound_warning) {
-					printf("HK: No local epoch found for node %u, skipping\n", packet->id.src);
-					epoch_notfound_warning = true;
+
+				if (local_epoch == -1 && !hk_get_epoch(&local_epoch, packet->id.src)) {
+					if(!epoch_notfound_warning) {
+						printf("HK: No local epoch found for node %u, skipping %u %u %u\n", packet->id.src, *param->node, param->id, param->timestamp->tv_sec);
+						epoch_notfound_warning = true;
+					}
+					mpack_discard(&reader);
+					continue;
 				}
-				mpack_discard(&reader);
-				continue;
-			}
 
-			param->timestamp->tv_sec += local_epoch;
+				param->timestamp->tv_sec += local_epoch;
+			}
 			param_sniffer_log(NULL, &queue, param, offset, &reader, param->timestamp);
 		} else {
 			printf("HK: Found unknown param node %d id %d\n", node, id);

lib/csp

@@ -12,7 +12,7 @@
 #include <csp/csp.h>
 
 bool hk_get_epoch(time_t* epoch, uint16_t node);
-void hk_set_epoch(time_t epoch, uint16_t node);
+void hk_set_epoch(time_t epoch, uint16_t node, bool auto_sync);
 /* returns true if the packet was found to be for housekeeping */
 bool hk_param_sniffer(csp_packet_t * packet);
 

lib/param

@@ -8,14 +8,15 @@
 #include <stdio.h>
 #include <sys/time.h>
 #include <pthread.h>
-#include <param/param_queue.h>
 #include <param/param_server.h>
+#include <param/param_queue.h>
 #include <param/param_serializer.h>
 #include <mpack/mpack.h>
 #include <csp/csp.h>
 #include <csp/csp_hooks.h>
 #include <csp/csp_crc32.h>
 
+#include "param_sniffer.h"
 #include "hk_param_sniffer.h"
 #include "victoria_metrics.h"
 #include "vts.h"
@@ -27,9 +28,9 @@ int sniffer_running = 0;
 pthread_t param_sniffer_thread;
 FILE *logfile;
 
-int param_sniffer_log(void * ctx, param_queue_t *queue, param_t *param, int offset, void *reader, csp_timestamp_t *timestamp) {
+int param_sniffer_log(void * ctx, param_queue_t *queue, const param_t *param, int offset, void *reader, csp_timestamp_t *timestamp) {
 
-    char tmp[1000] = {};
+    char tmp[1000] = {0};
 
     if (offset < 0)
         offset = 0;
@@ -136,7 +137,7 @@ int param_sniffer_crc(csp_packet_t * packet) {
     return 0;
 }
 
-static void * param_sniffer(void * param) {
+static void * param_sniffer(void * arg) {
     csp_promisc_enable(100);
     while(1) {
         csp_packet_t * packet = csp_promisc_read(CSP_MAX_DELAY);
@@ -176,7 +177,6 @@ static void * param_sniffer(void * param) {
         csp_timestamp_t time_now;
         csp_clock_get_time(&time_now);
         queue.last_timestamp = time_now;
-        queue.client_timestamp = time_now;
 
         mpack_reader_t reader;
         mpack_reader_init_data(&reader, queue.buffer, queue.used);
@@ -192,7 +192,7 @@ static void * param_sniffer(void * param) {
                 timestamp.tv_sec = packet->timestamp_rx;
                 timestamp.tv_nsec = 0;
             }
-            param_t * param = param_list_find_id(node, id);
+            const param_t * param = param_list_find_id(node, id);
             if (param) {
                 param_sniffer_log(NULL, &queue, param, offset, &reader, &timestamp);
             } else {

lib/pycsh_core

@@ -11,7 +11,7 @@
 #include <csp/csp.h>
 
 int param_sniffer_crc(csp_packet_t * packet);
-int param_sniffer_log(void * ctx, param_queue_t *queue, param_t *param, int offset, void *reader, csp_timestamp_t *timestamp);
+int param_sniffer_log(void * ctx, param_queue_t *queue, const param_t *param, int offset, void *reader, csp_timestamp_t *timestamp);
 void param_sniffer_init(int add_logfile);
 
 #endif /* SRC_PARAM_SNIFFER_H_ */

lib/slash

@@ -21,7 +21,7 @@
 
 static uint32_t _serial0;
 
-PARAM_DEFINE_STATIC_RAM(PARAMID_SERIAL0, serial0, PARAM_TYPE_INT32, -1, 0, PM_HWREG, NULL, "", &_serial0, NULL);
+PARAM_DEFINE_STATIC_RAM(PARAMID_SERIAL0, serial0, PARAM_TYPE_XINT32, -1, 0, PM_HWREG, NULL, "", &_serial0, NULL);
 PARAM_DEFINE_STATIC_RAM(PARAMID_CSP_DBG_BUFFER_OUT,   csp_buf_out,         PARAM_TYPE_UINT8,  0, 0, PM_DEBUG | PM_ERRCNT, NULL, "", &csp_dbg_buffer_out, "Number of buffer overruns");
 PARAM_DEFINE_STATIC_RAM(PARAMID_CSP_DBG_CONN_OUT,     csp_conn_out,        PARAM_TYPE_UINT8,  0, 0, PM_DEBUG | PM_ERRCNT, NULL, "", &csp_dbg_conn_out, "Number of connection overruns");
 PARAM_DEFINE_STATIC_RAM(PARAMID_CSP_DBG_CONN_OVF,     csp_conn_ovf,        PARAM_TYPE_UINT8,  0, 0, PM_DEBUG | PM_ERRCNT, NULL, "", &csp_dbg_conn_ovf, "Number of rx-queue overflows");