diff --git a/include/param/param.h b/include/param/param.h
index dfc872f2..d3c5a706 100644
--- a/include/param/param.h
+++ b/include/param/param.h
@@ -10,7 +10,6 @@
 
 #include <stdint.h>
 #include <csp/csp_types.h>
-#include <vmem/vmem.h>
 
 #include <libparam.h>
 
@@ -42,6 +41,31 @@ typedef enum {
 	PARAM_TYPE_INVALID,
 } param_type_e;
 
+#define PARAM_CTYPE_PARAM_TYPE_UINT8   uint8_t
+#define PARAM_CTYPE_PARAM_TYPE_UINT16  uint16_t
+#define PARAM_CTYPE_PARAM_TYPE_UINT32  uint32_t
+#define PARAM_CTYPE_PARAM_TYPE_UINT64  uint64_t
+#define PARAM_CTYPE_PARAM_TYPE_INT8    int8_t
+#define PARAM_CTYPE_PARAM_TYPE_INT16   int16_t
+#define PARAM_CTYPE_PARAM_TYPE_INT32   int32_t
+#define PARAM_CTYPE_PARAM_TYPE_INT64   int64_t
+#define PARAM_CTYPE_PARAM_TYPE_XINT8   uint8_t
+#define PARAM_CTYPE_PARAM_TYPE_XINT16  uint16_t
+#define PARAM_CTYPE_PARAM_TYPE_XINT32  uint32_t
+#define PARAM_CTYPE_PARAM_TYPE_XINT64  uint64_t
+#define PARAM_CTYPE_PARAM_TYPE_FLOAT   float
+#define PARAM_CTYPE_PARAM_TYPE_DOUBLE  double
+#define PARAM_CTYPE_PARAM_TYPE_STRING  char
+#define PARAM_CTYPE_PARAM_TYPE_DATA  char
+
+
+/* “Selector” macro */
+#define PARAM_CTYPE(_ptype_token) PARAM_CTYPE_##_ptype_token
+
+/* Deriver sizeof/alignof fra token */
+#define PARAM_SIZEOF(_ptype_token)  (sizeof(PARAM_CTYPE(_ptype_token)))
+#define PARAM_ALIGNOF(_ptype_token) (_Alignof(PARAM_CTYPE(_ptype_token)))
+
 /**
  * Global parameter mask
  */
@@ -90,37 +114,36 @@ typedef enum {
 /**
  * Parameter description structure
  * Note: this is not packed in order to maximise run-time efficiency
+ *       But the order of the elements is chosen to minimize padding.
+ *       So we start by largest types first, down to smallest types.
  */
 typedef struct param_s {
+	
+	uint64_t vaddr; /* Virtual address in case of VMEM */
 
-	/* Parameter declaration */
-	uint16_t id;
 	uint16_t * node;
-	param_type_e type;
-	uint32_t mask;
 	char *name;
 	char *unit;
 	char *docstr;
-
-	/* Storage */
 	void * addr; /* Physical address */
-	uint64_t vaddr; /* Virtual address in case of VMEM */
-	struct vmem_s * vmem;
-	int array_size;
-	int array_step;
+	const struct vmem_s * vmem;
+	void (*callback)(const struct param_s * param, int offset);
 
-	/* Local info */
-	void (*callback)(struct param_s * param, int offset);
-#ifdef PARAM_HAVE_TIMESTAMP
+	#ifdef PARAM_HAVE_TIMESTAMP
 	csp_timestamp_t * timestamp;
-#endif
-
-#ifdef PARAM_HAVE_SYS_QUEUE
+	#endif
+	
+	#ifdef PARAM_HAVE_SYS_QUEUE
 	/* single linked list:
-	 * The weird definition format comes from sys/queue.h SLINST_ENTRY() macro */
+	* The weird definition format comes from sys/queue.h SLINST_ENTRY() macro */
 	struct { struct param_s *sle_next; } next;
-#endif
+	#endif
 
+	uint32_t mask;
+	uint16_t id;
+	uint16_t array_step;    // Deliberate use of 16-bit to balance speed and size
+	uint16_t array_size;    // Deliberate use of 16-bit to balance speed and size
+	uint16_t type;          // Deliberate use of 16-bit to balance speed and size
 
 } param_t;
 
@@ -149,16 +172,55 @@ typedef struct param_s {
 #define PARAM_TIMESTAMP_INIT(_name)
 #endif
 
+static const uint16_t node_self = 0;
+
+#define STR1(x) #x
+#define STR(x)  STR1(x)
+
+/*
+ * Compile-time type check for param backing storage.
+ *
+ * This macro verifies that the C type of the object pointed to by `ptr`
+ * matches the PARAM_TYPE_* token specified by `_ptype_token`.
+ *
+ * It uses the GCC/Clang builtin `__builtin_types_compatible_p(T1, T2)`,
+ * which evaluates to 1 at compile time if the two types are compatible
+ * (i.e. the same underlying type), and 0 otherwise.
+ *
+ * The result is stored in a uniquely named enum constant to force the
+ * expression to be an integer constant expression, allowing it to be
+ * used in a `_Static_assert`.
+ *
+ * If the types do not match, compilation fails with a clear error message,
+ * preventing mismatches such as declaring PARAM_TYPE_UINT16 for a uint8_t
+ * variable, or passing the address of an array instead of an element.
+ *
+ * Notes:
+ *  - This check is evaluated entirely at compile time.
+ *  - No code or data is generated.
+ *  - Requires GCC or Clang (GNU extensions enabled).
+ */
+#define PARAM_TYPECHECK(_name, _ptype_token, ptr)                           \
+    enum {                                                                  \
+        param_typecheck__##_name = __builtin_types_compatible_p(            \
+            __typeof__(*(ptr)), PARAM_CTYPE(_ptype_token)                   \
+        )                                                                   \
+    };                                                                      \
+    _Static_assert(param_typecheck__##_name,                                \
+                   "param: param_type does not match pointer element type")
+
+
 
 #define PARAM_DEFINE_STATIC_RAM(_id, _name, _type, _array_count, _array_step, _flags, _callback, _unit, _physaddr, _docstr) \
-	; /* Catch const param defines */ \
+	_Static_assert(((_array_count) <= 1) ? ((_array_step) <= 0) : ((_array_step) >= PARAM_SIZEOF(_type)), "param: array_step invalid for array_count"); \
+	_Static_assert(((_array_count) <= 1) ? 1 : (((_array_step) % PARAM_ALIGNOF(_type)) == 0U),"param: array_step not aligned to type"); \
+	PARAM_TYPECHECK(_name, _type, _physaddr); \
 	PARAM_TIMESTAMP_DECL(_name) \
-	uint16_t _node_##_name = 0; \
-	__attribute__((section("param"))) \
-	__attribute__((used, no_reorder)) \
-	param_t _name = { \
+	__attribute__((section("param." STR(_name)))) \
+	__attribute__((used, aligned(8))) \
+	const param_t _name = { \
 		.vmem = NULL, \
-		.node = &_node_##_name, \
+		.node = (uint16_t *) &node_self, \
 		.id = _id, \
 		.type = _type, \
 		.name = #_name, \
@@ -174,13 +236,13 @@ typedef struct param_s {
 	}
 
 #define PARAM_DEFINE_STATIC_VMEM(_id, _name, _type, _array_count, _array_step, _flags, _callback, _unit, _vmem_name, _vmem_addr, _docstr) \
-	; /* Catch const param defines */ \
+	_Static_assert(((_array_count) <= 1) ? ((_array_step) <= 0) : ((_array_step) >= PARAM_SIZEOF(_type)), "param: array_step invalid for array_count"); \
+	_Static_assert(((_array_count) <= 1) ? 1 : (((_array_step) % PARAM_ALIGNOF(_type)) == 0U),"param: array_step not aligned to type"); \
 	PARAM_TIMESTAMP_DECL(_name) \
-	uint16_t _node_##_name = 0; \
-	__attribute__((section("param"))) \
-	__attribute__((used, no_reorder)) \
-	param_t _name = { \
-		.node = &_node_##_name, \
+	__attribute__((section("param." STR(_name)))) \
+	__attribute__((used, aligned(8))) \
+	const param_t _name = { \
+		.node = (uint16_t *) &node_self, \
 		.id = _id, \
 		.type = _type, \
 		.name = #_name, \
@@ -199,11 +261,13 @@ typedef struct param_s {
 #define PARAM_REMOTE_NODE_IGNORE 16382
 
 #define PARAM_DEFINE_REMOTE(_id, _name, _nodeaddr, _type, _array_count, _array_step, _flags, _physaddr, _docstr) \
-	; /* Catch const param defines */ \
+	_Static_assert(((_array_count) <= 1) ? ((_array_step) <= 0) : ((_array_step) >= PARAM_SIZEOF(_type)), "param: array_step invalid for array_count"); \
+	_Static_assert(((_array_count) <= 1) ? 1 : (((_array_step) % PARAM_ALIGNOF(_type)) == 0U),"param: array_step not aligned to type"); \
+	PARAM_TYPECHECK(_name, _type, _physaddr); \
 	PARAM_TIMESTAMP_DECL(_name) \
-	__attribute__((section("param"))) \
-	__attribute__((used, no_reorder)) \
-	param_t _name = { \
+	__attribute__((section("param." STR(_name)))) \
+	__attribute__((used, aligned(8))) \
+	const param_t _name = { \
 		.node = _nodeaddr, \
 		.id = _id, \
 		.type = _type, \
@@ -219,7 +283,9 @@ typedef struct param_s {
 	};
 
 #define PARAM_DEFINE_REMOTE_DYNAMIC(_id, _name, _node, _type, _array_count, _array_step, _flags, _physaddr, _docstr) \
-	; /* Catch const param defines */ \
+	_Static_assert(((_array_count) <= 1) ? ((_array_step) <= 0) : ((_array_step) >= PARAM_SIZEOF(_type)), "param: array_step invalid for array_count"); \
+	_Static_assert(((_array_count) <= 1) ? 1 : (((_array_step) % PARAM_ALIGNOF(_type)) == 0U),"param: array_step not aligned to type"); \
+	PARAM_TYPECHECK(_name, _type, _physaddr); \
 	PARAM_TIMESTAMP_DECL(_name) \
 	uint16_t _node_##_name = _node; \
 	param_t _name = { \
@@ -239,8 +305,8 @@ typedef struct param_s {
 
 /* Native getter functions, will return native types */
 #define PARAM_GET(type, name) \
-	type param_get_##name(param_t * param); \
-	type param_get_##name##_array(param_t * param, unsigned int i);
+	type param_get_##name(const param_t * param); \
+	type param_get_##name##_array(const param_t * param, unsigned int i);
 PARAM_GET(uint8_t, uint8)
 PARAM_GET(uint16_t, uint16)
 PARAM_GET(uint32_t, uint32)
@@ -255,10 +321,10 @@ PARAM_GET(double, double)
 
 /* Native setter functions, these take a native type as argument */
 #define PARAM_SET(type, name) \
-	void param_set_##name(param_t * param, type value); \
-	void param_set_##name##_nocallback(param_t * param, type value); \
-	void param_set_##name##_array(param_t * param, unsigned int i, type value); \
-	void param_set_##name##_array_nocallback(param_t * param, unsigned int i, type value);
+	void param_set_##name(const param_t * param, type value); \
+	void param_set_##name##_nocallback(const param_t * param, type value); \
+	void param_set_##name##_array(const param_t * param, unsigned int i, type value); \
+	void param_set_##name##_array_nocallback(const param_t * param, unsigned int i, type value);
 PARAM_SET(uint8_t, uint8)
 PARAM_SET(uint16_t, uint16)
 PARAM_SET(uint32_t, uint32)
@@ -272,24 +338,24 @@ PARAM_SET(double, double)
 #undef PARAM_SET
 
 /* Non-native types needs to go through a function which includes a void pointer and the length */
-void param_set_data(param_t * param, const void * inbuf, int len);
-void param_set_data_nocallback(param_t * param, const void * inbuf, int len);
-void param_get_data(param_t * param, void * outbuf, int len);
-void param_set_string(param_t * param, const char * inbuf, int len);
+void param_set_data(const param_t * param, const void * inbuf, int len);
+void param_set_data_nocallback(const param_t * param, const void * inbuf, int len);
+void param_get_data(const param_t * param, void * outbuf, int len);
+void param_set_string(const param_t * param, const char * inbuf, int len);
 #define param_get_string param_get_data
 
 /* Generic setter function:
  * This function can be used to set data of any type
  */
-void param_set(param_t * param, unsigned int offset, void * value);
-void param_get(param_t * param, unsigned int offset, void * value);
+void param_set(const param_t * param, unsigned int offset, void * value);
+void param_get(const param_t * param, unsigned int offset, void * value);
 
 /* Returns the size of a native type */
 int param_typesize(param_type_e type);
-int param_size(param_t * param);
+int param_size(const param_t * param);
 
 /* Copies from one parameter to another */
-void param_copy(param_t * dest, param_t * src);
+void param_copy(const param_t * dest, const param_t * src);
 
 /* External hooks to get atomic writes */
 extern __attribute__((weak)) void param_enter_critical(void);
diff --git a/include/param/param_client.h b/include/param/param_client.h
index ada01fad..2e31362a 100644
--- a/include/param/param_client.h
+++ b/include/param/param_client.h
@@ -35,7 +35,7 @@
  * @param version       1 or 2
  * @return              0 = ok, -1 on network error
  */
-int param_pull_single(param_t *param, int offset, int prio, int verbose, int host, int timeout, int version);
+int param_pull_single(const param_t *param, int offset, int prio, int verbose, int host, int timeout, int version);
 
 /**
  * PULL all
@@ -65,7 +65,7 @@ int param_pull_all(int prio, int verbose, int host, uint32_t include_mask, uint3
  * @param ack_with_pull ack with param queue
  * @return              0 = OK, -1 on network error
  */
-int param_push_single(param_t *param, int offset, int prio, void *value, int verbose, int host, int timeout, int version, bool ack_with_pull);
+int param_push_single(const param_t *param, int offset, int prio, void *value, int verbose, int host, int timeout, int version, bool ack_with_pull);
 
 /**
  * QUEUE PARAMETER API
diff --git a/include/param/param_list.h b/include/param/param_list.h
index e5144a37..35906d6f 100644
--- a/include/param/param_list.h
+++ b/include/param/param_list.h
@@ -17,10 +17,10 @@ extern "C" {
 
 typedef struct param_list_iterator_s {
 	int phase;							// Hybrid iterator has multiple phases (0 == Static, 1 == Dynamic List)
-	param_t * element;
+	const param_t * element;
 } param_list_iterator;
 
-param_t * param_list_iterate(param_list_iterator * iterator);
+const param_t * param_list_iterate(param_list_iterator * iterator);
 
 int param_list_add(param_t * item);
 
@@ -40,13 +40,13 @@ int param_list_remove(int node, uint8_t verbose);
  * @param verbose Whether to print the removed parameter.
  * @return int 1 if the parameter was found and removed.
  */
-void param_list_remove_specific(param_t * param, uint8_t verbose, int destroy);
-param_t * param_list_find_id(int node, int id);
-param_t * param_list_find_name(int node, const char * name);
+void param_list_remove_specific(const param_t * param, uint8_t verbose, int destroy);
+const param_t * param_list_find_id(int node, int id);
+const param_t * param_list_find_name(int node, const char * name);
 void param_list_print(uint32_t mask, int node, const char * globstr, int verbosity);
 uint32_t param_maskstr_to_mask(const char * str);
 
-param_t * param_list_from_line(const char * line);
+const param_t * param_list_from_line(const char * line);
 
 /**
  * @brief 
@@ -64,8 +64,8 @@ param_t * param_list_from_line(const char * line);
  */
 param_t * param_list_create_remote(int id, int node, int type, uint32_t mask, int array_size, char * name, char * unit, char * help, int storage_type);
 
-void param_list_destroy(param_t * param);
-void param_print(param_t * param, int offset, int nodes[], int nodes_count, int verbose, uint32_t ref_timestamp);
+void param_list_destroy(const param_t * param);
+void param_print(const param_t * param, int offset, int nodes[], int nodes_count, int verbose, uint32_t ref_timestamp);
 
 unsigned int param_list_packed_size(int list_version);
 int param_list_unpack(int node, void * data, int length, int list_version, int include_remotes);
diff --git a/include/param/param_queue.h b/include/param/param_queue.h
index 0fc4be9d..54d29c5b 100644
--- a/include/param/param_queue.h
+++ b/include/param/param_queue.h
@@ -37,7 +37,7 @@ typedef struct param_queue_s {
 
 void param_queue_init(param_queue_t * queue, void * buffer, int buffer_size, int used, param_queue_type_e type, int version);
 
-int param_queue_add(param_queue_t *queue, param_t *param, int offset, void *value);
+int param_queue_add(param_queue_t *queue, const param_t *param, int offset, void *value);
 
 /**
  * @brief 						Applies the content of a queue to memory.
diff --git a/include/param/param_serializer.h b/include/param/param_serializer.h
index 8fb5619a..c0699bea 100644
--- a/include/param/param_serializer.h
+++ b/include/param/param_serializer.h
@@ -13,10 +13,10 @@
 #include <csp/csp.h>
 #include <mpack/mpack.h>
 
-void param_serialize_id(mpack_writer_t *writer, param_t * param, int offset, param_queue_t * queue);
+void param_serialize_id(mpack_writer_t *writer, const param_t * param, int offset, param_queue_t * queue);
 void param_deserialize_id(mpack_reader_t *reader, int *id, int *node, csp_timestamp_t *timestamp, int *offset, param_queue_t * queue);
 
-int param_serialize_to_mpack(param_t * param, int offset, mpack_writer_t * writer, void * value, param_queue_t * queue);
-void param_deserialize_from_mpack_to_param(void * context, void * queue, param_t * param, int offset, mpack_reader_t * reader);
+int param_serialize_to_mpack(const param_t * param, int offset, mpack_writer_t * writer, void * value, param_queue_t * queue);
+void param_deserialize_from_mpack_to_param(void * context, void * queue, const param_t * param, int offset, mpack_reader_t * reader);
 
 #endif /* SRC_PARAM_PARAM_SERIALIZER_H_ */
diff --git a/include/param/param_server.h b/include/param/param_server.h
index e29bf4eb..de170958 100644
--- a/include/param/param_server.h
+++ b/include/param/param_server.h
@@ -74,42 +74,3 @@ typedef enum {
  * @param packet
  */
 void param_serve(csp_packet_t * packet);
-
-#if PARAM_NUM_PUBLISHQUEUES > 4
-#error A maximum number of four param queues are supported
-#endif
-
-#if PARAM_NUM_PUBLISHQUEUES > 0
-typedef struct param_publish_s {
-	param_t * param;
-	uint32_t queue;
-} param_publish_t;
-
-typedef enum {
-	PARAM_PUBLISHQUEUE_0 = 0,
-#if PARAM_NUM_PUBLISHQUEUES >= 2
-	PARAM_PUBLISHQUEUE_1 = 1,
-#endif
-#if PARAM_NUM_PUBLISHQUEUES >= 3
-	PARAM_PUBLISHQUEUE_2 = 2,
-#endif
-#if PARAM_NUM_PUBLISHQUEUES >= 4
-	PARAM_PUBLISHQUEUE_3 = 3,
-#endif
-} param_publish_id_t;
-
-#define PARAM_ADD_PUBLISH(paramname, queueid) \
-param_publish_t __param_publish_##paramname##queueid = { \
-	.param = &paramname, \
-	.queue = queueid, \
-}; \
-__attribute__((section("param_publish"))) \
-param_publish_t const * _param_publish_##paramname##queueid = & __param_publish_##paramname##queueid;
-
-typedef bool (*param_shall_publish_t)(uint8_t queue);
-
-void param_publish_periodic(void);
-void param_publish_configure(param_publish_id_t queueid, uint16_t destination, uint16_t periodicity_ms, csp_prio_t csp_prio);
-void param_publish_init(param_shall_publish_t criteria_cb);
-
-#endif
diff --git a/include/param/param_string.h b/include/param/param_string.h
index 58287737..d5374f02 100644
--- a/include/param/param_string.h
+++ b/include/param/param_string.h
@@ -2,10 +2,10 @@
 
 #include <param/param.h>
 
-void param_value_str(param_t *param, unsigned int i, char * out, int len);
+void param_value_str(const param_t *param, unsigned int i, char * out, int len);
 int param_str_to_value(param_type_e type, char * in, void * out);
 void param_type_str(param_type_e type, char * out, int len);
-void param_print(param_t * param, int offset, int nodes[], int nodes_count, int verbose, uint32_t ref_timestamp);
+void param_print(const param_t * param, int offset, int nodes[], int nodes_count, int verbose, uint32_t ref_timestamp);
 uint32_t param_maskstr_to_mask(const char * str);
 uint32_t param_umaskstr_to_mask(const char * str);
 uint32_t param_typestr_to_typeid(const char * str);
diff --git a/include/vmem/vmem.h b/include/vmem/vmem.h
index 100cef03..8d4e10a8 100644
--- a/include/vmem/vmem.h
+++ b/include/vmem/vmem.h
@@ -35,9 +35,9 @@ enum vmem_types{
 
 typedef struct vmem_s {
 	int type;
-	void (*read)(struct vmem_s * vmem, uint64_t addr, void * dataout, uint32_t len);
-	void (*write)(struct vmem_s * vmem, uint64_t addr, const void * datain, uint32_t len);
-	int (*flush)(struct vmem_s * vmem);
+	void (*read)(const struct vmem_s * vmem, uint64_t addr, void * dataout, uint32_t len);
+	void (*write)(const struct vmem_s * vmem, uint64_t addr, const void * datain, uint32_t len);
+	int (*flush)(const struct vmem_s * vmem);
 	/* This anonymous union is needed to be able to handle 64-bit and 32-bit
 	 * systems interchangeably. Since the VMEM backend always expects 64-bit
 	 * vaddr, and we are not able to initialize the 64-bit vaddr field with
@@ -149,15 +149,6 @@ int vmem_flush(vmem_t *vmem);
  */
 void vmem_add(vmem_t * start, vmem_t * stop);
 
-/**
- * @brief linker-generated symbol for the first VMEM element in the linker "vmem" section
- */
-extern vmem_t __start_vmem __attribute__((weak));
-/**
- * @brief linker-generated symbol for the last VMEM element in the linker "vmem" section
- */
-extern vmem_t __stop_vmem __attribute__((weak));
-
 #ifdef __cplusplus
 }
 #endif
diff --git a/include/vmem/vmem_block.h b/include/vmem/vmem_block.h
index 79b068a7..222d4f4e 100644
--- a/include/vmem/vmem_block.h
+++ b/include/vmem/vmem_block.h
@@ -113,9 +113,9 @@ typedef struct vmem_block_region_s {
 		.options = options_in, \
 	}; \
 	__attribute__((section("vmem"))) \
-	__attribute__((__aligned__(__alignof__(vmem_t)))) \
+	__attribute__((__aligned__(8))) \
 	__attribute__((used)) \
-	vmem_t vmem_##name_in = { \
+	const vmem_t vmem_##name_in = { \
 		.type = VMEM_TYPE_BLOCK, \
 		.read = vmem_block_read, \
 		.write = vmem_block_write, \
diff --git a/include/vmem/vmem_file.h b/include/vmem/vmem_file.h
index 0fd6d71c..af783a97 100644
--- a/include/vmem/vmem_file.h
+++ b/include/vmem/vmem_file.h
@@ -43,9 +43,9 @@ void vmem_file_write(vmem_t * vmem, uint64_t addr, const void * datain, uint32_t
 		.filename = filename_in, \
 	}; \
 	__attribute__((section("vmem"))) \
- 	__attribute__((aligned(__alignof__(vmem_t)))) \
+ 	__attribute__((aligned(8))) \
  	__attribute__((used)) \
-	vmem_t vmem_##name_in = { \
+	const vmem_t vmem_##name_in = { \
 		.type = VMEM_TYPE_FILE, \
 		.name = strname, \
 		.size = size_in, \
@@ -63,9 +63,9 @@ void vmem_file_write(vmem_t * vmem, uint64_t addr, const void * datain, uint32_t
 		.filename = filename_in, \
 	}; \
 	__attribute__((section("vmem"))) \
- 	__attribute__((aligned(__alignof__(vmem_t)))) \
+ 	__attribute__((aligned(8))) \
  	__attribute__((used)) \
-	vmem_t vmem_##name_in = { \
+	const vmem_t vmem_##name_in = { \
 		.type = VMEM_TYPE_FILE, \
 		.name = strname, \
 		.size = size_in, \
diff --git a/include/vmem/vmem_fram.h b/include/vmem/vmem_fram.h
index 7b76cfd9..61fb79ad 100644
--- a/include/vmem/vmem_fram.h
+++ b/include/vmem/vmem_fram.h
@@ -19,9 +19,9 @@ typedef struct {
 		.fram_addr = fram_addr_in, \
 	}; \
 	__attribute__((section("vmem"))) \
-	__attribute__((__aligned__(__alignof__(vmem_t)))) \
+	__attribute__((__aligned__(8))) \
 	__attribute__((used)) \
-	vmem_t vmem_##name_in = { \
+	const vmem_t vmem_##name_in = { \
 		.type = VMEM_TYPE_FRAM, \
 		.name = strname, \
 		.size = size_in, \
@@ -32,8 +32,8 @@ typedef struct {
 		.ack_with_pull = 1, \
 	};
 
-void vmem_fram_read(vmem_t * vmem, uint64_t addr, void * dataout, uint32_t len);
-void vmem_fram_write(vmem_t * vmem, uint64_t addr, const void * datain, uint32_t len);
+void vmem_fram_read(const vmem_t * vmem, uint64_t addr, void * dataout, uint32_t len);
+void vmem_fram_write(const vmem_t * vmem, uint64_t addr, const void * datain, uint32_t len);
 
 
 #endif /* SRC_PARAM_VMEM_FRAM_H_ */
diff --git a/include/vmem/vmem_fram_cache.h b/include/vmem/vmem_fram_cache.h
index 89214aae..3f577c05 100644
--- a/include/vmem/vmem_fram_cache.h
+++ b/include/vmem/vmem_fram_cache.h
@@ -28,9 +28,9 @@ typedef struct {
 		.cache_status = 0, \
 	}; \
 	__attribute__((section("vmem"))) \
-	__attribute__((__aligned__(__alignof__(vmem_t)))) \
+	__attribute__((__aligned__(8))) \
 	__attribute__((used)) \
-	vmem_t vmem_##name_in = { \
+	const vmem_t vmem_##name_in = { \
 		.type = VMEM_TYPE_FRAM_CACHE, \
 		.name = strname, \
 		.size = size_in, \
@@ -41,5 +41,5 @@ typedef struct {
 		.ack_with_pull = 1, \
 	};
 
-void vmem_fram_cache_read(vmem_t * vmem, uint64_t addr, void * dataout, uint32_t len);
-void vmem_fram_cache_write(vmem_t * vmem, uint64_t addr, const void * datain, uint32_t len);
+void vmem_fram_cache_read(const vmem_t * vmem, uint64_t addr, void * dataout, uint32_t len);
+void vmem_fram_cache_write(const vmem_t * vmem, uint64_t addr, const void * datain, uint32_t len);
diff --git a/include/vmem/vmem_mmap.h b/include/vmem/vmem_mmap.h
index ef55247e..46d4b928 100644
--- a/include/vmem/vmem_mmap.h
+++ b/include/vmem/vmem_mmap.h
@@ -20,9 +20,9 @@ void vmem_mmap_write(vmem_t * vmem, uint64_t addr, const void * datain, uint32_t
 		.filename = filename_in, \
 	}; \
 	__attribute__((section("vmem"))) \
-	__attribute__((__aligned__(__alignof__(vmem_t)))) \
+	__attribute__((__aligned__(8))) \
 	__attribute__((used)) \
-	vmem_t vmem_mmap_##name_in = { \
+	const vmem_t vmem_mmap_##name_in = { \
 		.type = VMEM_TYPE_FILE, \
 		.name = strname, \
 		.size = size_in, \
diff --git a/include/vmem/vmem_ram.h b/include/vmem/vmem_ram.h
index 80c5ac16..6545fc34 100644
--- a/include/vmem/vmem_ram.h
+++ b/include/vmem/vmem_ram.h
@@ -40,9 +40,9 @@ typedef struct {
 		.physaddr = vmem_##name_in##_heap, \
 	}; \
 	__attribute__((section("vmem"))) \
-	__attribute__((__aligned__(__alignof__(vmem_t)))) \
+	__attribute__((__aligned__(8))) \
 	__attribute__((used)) \
-	vmem_t vmem_##name_in = { \
+	const vmem_t vmem_##name_in = { \
 		.type = VMEM_TYPE_RAM, \
 		.read = NULL, \
 		.write = NULL, \
@@ -67,9 +67,9 @@ typedef struct {
         .physaddr = mem_addr, \
     }; \
     __attribute__((section("vmem"))) \
-	__attribute__((__aligned__(__alignof__(vmem_t)))) \
+	__attribute__((__aligned__(8))) \
     __attribute__((used)) \
-    vmem_t vmem_##name_in = { \
+    const vmem_t vmem_##name_in = { \
         .type = VMEM_TYPE_RAM, \
         .read = NULL, \
         .write = NULL, \
diff --git a/include/vmem/vmem_server.h b/include/vmem/vmem_server.h
index aa1ef353..766632af 100644
--- a/include/vmem/vmem_server.h
+++ b/include/vmem/vmem_server.h
@@ -44,7 +44,6 @@ typedef struct {
 		vmem_request_hdr_t hdr;
 	};
 	union {
-		uint8_t body[0];
 		struct {
 			uint32_t address;
 			uint32_t length;
diff --git a/meson.build b/meson.build
index dcafbf82..858110dc 100644
--- a/meson.build
+++ b/meson.build
@@ -1,13 +1,11 @@
-project('param', 'c', subproject_dir:'lib')
-
-add_project_arguments(['-Wall'], language: 'c')
+project('param', 'c', subproject_dir:'lib', default_options: ['warning_level=2', 'werror=true'])
+add_project_arguments(['-Wstrict-prototypes', '-Wmissing-prototypes', '-Wmissing-declarations', '-Wcast-align', '-Wpointer-arith', '-Wshadow'], language: 'c')
 
 conf = configuration_data()
 conf.set('PARAM_HAVE_SYS_QUEUE', get_option('list_dynamic') or get_option('list_pool') > 0)
 conf.set('PARAM_LIST_DYNAMIC', get_option('list_dynamic'))
 conf.set('PARAM_LIST_POOL', get_option('list_pool'))
 conf.set('PARAM_HAVE_TIMESTAMP', get_option('have_timestamp'))
-conf.set('PARAM_NUM_PUBLISHQUEUES', get_option('num_publishqueues'))
 
 # From now on, VMEM API is 64bits, breaking earlier ABI. 
 # New user code can use the fact that this macro is defined (its value is not relevant, just the fact that it is defined)
diff --git a/meson_options.txt b/meson_options.txt
index a1c5765f..42e2cb86 100644
--- a/meson_options.txt
+++ b/meson_options.txt
@@ -5,5 +5,4 @@ option('have_timestamp', type: 'boolean', value: true, description: 'Use paramet
 option('list_dynamic', type: 'boolean', value: false, description: 'Compile support for dynamic param list (requres sys/queue.h) and dynamic memory allocation')
 option('list_pool', type: 'integer', value: 0, description: 'Compile support for pre-allocated param list (requres sys/queue.h)')
 option('have_float', type: 'boolean', value: true, description: 'Support float/double')
-option('num_publishqueues', type: 'integer', value: 0, description: 'Number of param publish queues required')
 option('test', type: 'boolean', value: false, description: 'Build GoogleTest based tests (requires gtest)')
diff --git a/src/objstore/objstore.c b/src/objstore/objstore.c
index c20bd961..2f0a93ab 100644
--- a/src/objstore/objstore.c
+++ b/src/objstore/objstore.c
@@ -22,8 +22,6 @@ static uint8_t _make_checksum(vmem_t * vmem, int offset, int length) {
 }
 
 static int _valid_checksum(vmem_t * vmem, int offset, uint16_t length, uint8_t checksum) {
-    if (length < 0)
-        return 0;
     
     uint8_t temp_checksum = _make_checksum(vmem, offset, length);
 
@@ -84,7 +82,7 @@ int objstore_alloc(vmem_t * vmem, int length, int verbose) {
     uint8_t sync_status = 0;
     int counter = 0;
 
-    for (int i = 0; i < vmem->size; i++) {
+    for (unsigned int i = 0; i < vmem->size; i++) {
         uint8_t data;
         vmem->read(vmem, i, &data, sizeof(data));
 
@@ -107,13 +105,13 @@ int objstore_alloc(vmem_t * vmem, int length, int verbose) {
 
                     
                     // read length to skip ahead
-                    int length = objstore_read_obj_length(vmem, i);
-                    if (length < 0) {
+                    int readlength = objstore_read_obj_length(vmem, i);
+                    if (readlength < 0) {
                         i += OBJ_HEADER_LENGTH;
                         break;
                     }
                     //printf("objstore_alloc skipping object of length: %u\n", length);
-                    i += length + OBJ_HEADER_LENGTH;
+                    i += readlength + OBJ_HEADER_LENGTH;
                 }
             }
         } else {
@@ -135,7 +133,7 @@ int objstore_alloc(vmem_t * vmem, int length, int verbose) {
 int objstore_scan(vmem_t * vmem, objstore_scan_callback_f callback, int verbose, void * ctx) {
     uint8_t sync_status = 0;
     
-    for (int i = 0; i < vmem->size; i++) {
+    for (unsigned int i = 0; i < vmem->size; i++) {
         uint8_t data;
         vmem->read(vmem, i, &data, sizeof(data));
 
@@ -179,14 +177,14 @@ int objstore_rm_obj(vmem_t * vmem, int offset, int verbose) {
         return -1;
     }
 
-    const uint16_t length;
+    const uint16_t length = 0;
     vmem->read(vmem, offset+5, (void *) &length, sizeof(length));
 
     const uint8_t clear_block = 0xFF;
     // clear checksum
     vmem->write(vmem, offset+length+OBJ_HEADER_LENGTH, (void *) &clear_block, sizeof(clear_block));
     // clear data field
-    for (int i = length; i > 0; i--) {
+    for (unsigned int i = length; i > 0; i--) {
         vmem->write(vmem, offset+i+OBJ_HEADER_LENGTH-1, (void *) &clear_block, sizeof(clear_block));
     }
     // clear header
@@ -213,7 +211,7 @@ int objstore_read_obj(vmem_t * vmem, int offset, void * data_buf, int verbose) {
     }
 
     /* Data buffer must be correct size, e.g. by using objstore_read_obj_length */
-    const uint16_t length;
+    const uint16_t length = 0;
     vmem->read(vmem, offset+5, (void *) &length, sizeof(length));
 
     vmem->read(vmem, offset+OBJ_HEADER_LENGTH, data_buf, length);
diff --git a/src/param/collector/param_collector_config.c b/src/param/collector/param_collector_config.c
index 7835707d..dcfa712b 100644
--- a/src/param/collector/param_collector_config.c
+++ b/src/param/collector/param_collector_config.c
@@ -18,11 +18,11 @@
 
 struct param_collector_config_s param_collector_config[16] = {0};
 
-void param_col_confstr_callback(struct param_s * param, int offset) {
+void param_col_confstr_callback(const struct param_s * param, int offset) {
 	param_collector_init();
 }
 
-extern vmem_t vmem_col;
+extern const vmem_t vmem_col;
 PARAM_DEFINE_STATIC_VMEM(PARAMID_COLLECTOR_RUN, col_run, PARAM_TYPE_UINT8, 0, sizeof(uint8_t), PM_CONF, NULL, "", col, 0x0, "Internal use");
 PARAM_DEFINE_STATIC_VMEM(PARAMID_COLLECTOR_VERBOSE, col_verbose, PARAM_TYPE_UINT8, 0, sizeof(uint8_t), PM_CONF, NULL, "", col, 0x1, "Internal use");
 PARAM_DEFINE_STATIC_VMEM(PARAMID_COLLECTOR_CNFSTR, col_cnfstr, PARAM_TYPE_STRING, 100, 0, PM_CONF, param_col_confstr_callback, "", col, 0x02, "Internal use");
diff --git a/src/param/collector/param_collector_config.h b/src/param/collector/param_collector_config.h
index 730fad8a..d39ec92b 100644
--- a/src/param/collector/param_collector_config.h
+++ b/src/param/collector/param_collector_config.h
@@ -19,9 +19,9 @@ struct param_collector_config_s {
 
 extern struct param_collector_config_s param_collector_config[];
 
-extern param_t col_run;
-extern param_t col_verbose;
-extern param_t col_cnfstr;
+extern const param_t col_run;
+extern const param_t col_verbose;
+extern const param_t col_cnfstr;
 
 void param_collector_init(void);
 
diff --git a/src/param/list/param_list.c b/src/param/list/param_list.c
index c231a3bc..6b97df2f 100644
--- a/src/param/list/param_list.c
+++ b/src/param/list/param_list.c
@@ -8,6 +8,7 @@
 #include <stdio.h>
 #include <stdlib.h>
 #include <string.h>
+#include <inttypes.h>
 #include "libparam.h"
 #ifdef PARAM_LIST_DYNAMIC
 #include <malloc.h>
@@ -28,34 +29,18 @@
 #include <sys/queue.h>
 #endif
 
-/**
- * The storage size (i.e. how closely two param_t structs are packed in memory)
- * varies from platform to platform (in example on x64 and arm32). This macro
- * defines two param_t structs and saves the storage size in a define.
- * The linker may also put padding bytes between param_t's (even in the same section),
- * but it appears that the same padding is added to the parameters below, so the macro will account for it.
- * In addition, Newer GCC versions (gcc 13.3.0 and arm-none-eabi-gcc 13.2.1, common for Ubuntu 24.04)
- * will put symbols in reverse order (when compared with gcc 11.4 and arm-none-eabi-gcc 10.3.1, common for Ubuntu 22.04).
- * So that necessitates `__attribute__((no_reorder))`, so the size doesn't become negative.
- * `__attribute__((no_reorder))` is preferred over c_args '-fno-toplevel-reorder',
- * as it doesn't require the user to modify their usage of libparam.
- */
-#ifndef PARAM_STORAGE_SIZE
-__attribute__((no_reorder))
-const param_t param_size_set0;
-__attribute__((no_reorder))
-const param_t param_size_set1;
-#define PARAM_STORAGE_SIZE ((intptr_t) &param_size_set1 - (intptr_t) &param_size_set0)
-#endif
+#define ALIGN_UP(x, a)   (((x) + ((a) - 1)) & ~((a) - 1))
+#define PARAM_STORAGE_SIZE ALIGN_UP(sizeof(param_t), 8)
+_Static_assert(__alignof__(param_t) == 8, "param_t alignment must be exactly 8 bytes");
 
 #ifdef PARAM_HAVE_SYS_QUEUE
-static SLIST_HEAD(param_list_head_s, param_s) param_list_head = {};
+static SLIST_HEAD(param_list_head_s, param_s) param_list_head = {0};
 #endif
 
-uint8_t param_is_static(param_t * param) {
+static uint8_t param_is_static(const param_t * param) {
 
-	__attribute__((weak)) extern param_t __start_param;
-	__attribute__((weak)) extern param_t __stop_param;
+	__attribute__((weak)) extern const param_t __start_param;
+	__attribute__((weak)) extern const param_t __stop_param;
 
 	if ((&__start_param != NULL) && (&__start_param != &__stop_param)) {
 		if (param >= &__start_param && param < &__stop_param)
@@ -64,14 +49,14 @@ uint8_t param_is_static(param_t * param) {
 	return 0;
 }
 
-param_t * param_list_iterate(param_list_iterator * iterator) {
+const param_t * param_list_iterate(param_list_iterator * iterator) {
 
 	/**
 	 * GNU Linker symbols. These will be autogenerate by GCC when using
 	 * __attribute__((section("param"))
 	 */
-	__attribute__((weak)) extern param_t __start_param;
-	__attribute__((weak)) extern param_t __stop_param;
+	__attribute__((weak)) extern const param_t __start_param;
+	__attribute__((weak)) extern const param_t __stop_param;
 
 	/* First element */
 	if (iterator->element == NULL) {
@@ -119,7 +104,7 @@ param_t * param_list_iterate(param_list_iterator * iterator) {
 
 int param_list_add(param_t * item) {
 
-	param_t * param;
+	const param_t * param;
 	if ((param = param_list_find_id(*item->node, item->id)) != NULL) {
 
 		/* To protect against updating local static params and ROM remote params
@@ -127,11 +112,14 @@ int param_list_add(param_t * item) {
 		   strings are readonly. This can be recognized by checking if
 		   the VMEM pointer is set */
 		if (!param_is_static(param) && param->vmem != NULL && param != item) {
-			param->mask = item->mask;
-			param->type = item->type;
-			param->array_size = item->array_size;
-			param->array_step = item->array_step;
-			param->vmem->type = item->vmem->type;
+
+			// Explicitly cast away const to allow updating the parameter after checking it resides in dynamic memory
+			param_t * param_rw = (param_t *) param;
+			param_rw->mask = item->mask;
+			param_rw->type = item->type;
+			param_rw->array_size = item->array_size;
+			param_rw->array_step = item->array_step;
+			//param_rw->vmem->type = item->vmem->type; // TODO do not support overwriting vmem type
 
 			if(param->name && item->name){
 				strcpy(param->name, item->name);
@@ -160,12 +148,12 @@ int param_list_remove(int node, uint8_t verbose) {
 
 	int count = 0;
 
-	param_list_iterator i = {};
-	param_t * iter_param = param_list_iterate(&i);
+	param_list_iterator i = {0};
+	const param_t * iter_param = param_list_iterate(&i);
 
 	while (iter_param) {
 
-		param_t * param = iter_param;  // Free the current parameter after we have used it to iterate.
+		const param_t * param = iter_param;  // Free the current parameter after we have used it to iterate.
 		iter_param = param_list_iterate(&i);
 
 		if (i.phase == 0)  // Protection against removing static parameters
@@ -188,7 +176,8 @@ int param_list_remove(int node, uint8_t verbose) {
 
 	return count;
 }
-void param_list_remove_specific(param_t * param, uint8_t verbose, int destroy) {
+
+void param_list_remove_specific(const param_t * param, uint8_t verbose, int destroy) {
 
     if (param_is_static(param)) {
         return;  /* Nothing we can do :( */
@@ -204,14 +193,14 @@ void param_list_remove_specific(param_t * param, uint8_t verbose, int destroy) {
 }
 #endif
 
-param_t * param_list_find_id(int node, int id) {
+const param_t * param_list_find_id(int node, int id) {
 
 	if (csp_iflist_get_by_addr(node) != NULL || csp_iflist_get_by_broadcast(node) != NULL)
 		node = 0;
 
-	param_t * found = NULL;
-	param_t * param;
-	param_list_iterator i = {};
+	const param_t * found = NULL;
+	const param_t * param;
+	param_list_iterator i = {0};
 
 	while ((param = param_list_iterate(&i)) != NULL) {
 
@@ -229,14 +218,14 @@ param_t * param_list_find_id(int node, int id) {
 	return found;
 }
 
-param_t * param_list_find_name(int node, const char * name) {
+const param_t * param_list_find_name(int node, const char * name) {
 
 	if (node < 0 )
 		node = 0;
 
-	param_t * found = NULL;
-	param_t * param;
-	param_list_iterator i = {};
+	const param_t * found = NULL;
+	const param_t * param;
+	param_list_iterator i = {0};
 	while ((param = param_list_iterate(&i)) != NULL) {
 
 		if (*param->node != node)
@@ -254,8 +243,8 @@ param_t * param_list_find_name(int node, const char * name) {
 }
 
 void param_list_print(uint32_t mask, int node, const char * globstr, int verbosity) {
-	param_t * param;
-	param_list_iterator i = {};
+	const param_t * param;
+	param_list_iterator i = {0};
 	while ((param = param_list_iterate(&i)) != NULL) {
 		if ((node >= 0) && (*param->node != node)) {
 			continue;
@@ -283,11 +272,11 @@ unsigned int param_list_packed_size(int list_version) {
 
 int param_list_pack(void* buf, int buf_size, int prio_only, int remote_only, int list_version) {
 
-	param_t * param;
+	const param_t * param;
 	int num_params = 0;
 
-	void* param_packed = buf;
-	param_list_iterator i = {};
+	char * param_packed = (char *) buf;
+	param_list_iterator i = {0};
 	while ((param = param_list_iterate(&i)) != NULL) {
 		if (prio_only && (param->mask & PM_PRIO_MASK) == 0)
 			continue;
@@ -301,7 +290,7 @@ int param_list_pack(void* buf, int buf_size, int prio_only, int remote_only, int
 
 		} else if (list_version == 2) {
 
-			param_transfer2_t * rparam = param_packed;
+			param_transfer2_t * rparam = (param_transfer2_t *) param_packed;
 			int node = *param->node;
 			rparam->id = htobe16(param->id);
 			rparam->node = htobe16(node);
@@ -316,7 +305,7 @@ int param_list_pack(void* buf, int buf_size, int prio_only, int remote_only, int
 
 		} else {
 
-			param_transfer3_t * rparam = param_packed;
+			param_transfer3_t * rparam = (param_transfer3_t *) param_packed;
 			int node = *param->node;
 			rparam->id = htobe16(param->id);
 			rparam->node = htobe16(node);
@@ -348,7 +337,7 @@ int param_list_pack(void* buf, int buf_size, int prio_only, int remote_only, int
 		param_packed += param_list_packed_size(list_version);
 		num_params++;
 
-		if (param_packed + param_list_packed_size(list_version) > buf + buf_size) {
+		if (param_packed + param_list_packed_size(list_version) > (char *) buf + buf_size) {
 			printf("Buffer size too small to hold parameters");
 			break;
 		}
@@ -403,12 +392,14 @@ static param_heap_t * param_list_alloc(int type, int array_size) {
 	return param;
 }
 
-void param_list_clear() {
+#if 0
+void param_list_clear(void) {
 
 	SLIST_INIT(&param_list_head);
 	param_heap_used = 0;
 	param_buffer_used = 0;
 }
+#endif
 
 /* WARNING: This function resets complete list */
 static void param_list_destroy_impl(param_t * param) {
@@ -421,13 +412,15 @@ static void param_list_destroy_impl(param_t * param) {
 
 #ifdef PARAM_LIST_DYNAMIC
 
-void param_list_clear() {
+#if 0
+void param_list_clear(void) {
 	while (!SLIST_EMPTY(&param_list_head)) {
 		struct param_s *param = SLIST_FIRST(&param_list_head);
 		SLIST_REMOVE_HEAD(&param_list_head, next);
 		param_list_destroy(param);
 	}
 }
+#endif
 
 typedef struct param_heap_s {
 	param_t param;
@@ -458,9 +451,9 @@ static param_heap_t * param_list_alloc(int type, int array_size) {
 	return param_heap;
 }
 
-static void param_list_destroy_impl(param_t * param) {
+static void param_list_destroy_impl(const param_t * param) {
 	free(param->addr);
-	free(param);
+	free((void *) param);
 }
 #endif
 
@@ -592,7 +585,7 @@ int param_list_download(int node, int timeout, int list_version, int include_rem
 	return count;
 }
 
-void param_list_destroy(param_t * param) {
+void param_list_destroy(const param_t * param) {
 	param_list_destroy_impl(param);
 }
 
@@ -632,15 +625,15 @@ param_t * param_list_create_remote(int id, int node, int type, uint32_t mask, in
 	param->array_size = array_size;
 	param->array_step = param_typesize(type);
 
-	param->vmem->ack_with_pull = false;
-	param->vmem->driver = NULL;
-	param->vmem->name = "REMOTE";
-	param->vmem->read = NULL;
-	param->vmem->size = array_size*param_typesize(type);
-	param->vmem->type = storage_type;
-	param->vmem->vaddr = (uint64_t)(uintptr_t)param_heap->buffer;
-	param->vmem->big_endian = false;
-	param->vmem->write = NULL;
+	param_heap->vmem.ack_with_pull = false;
+	param_heap->vmem.driver = NULL;
+	param_heap->vmem.name = "REMOTE";
+	param_heap->vmem.read = NULL;
+	param_heap->vmem.size = array_size*param_typesize(type);
+	param_heap->vmem.type = storage_type;
+	param_heap->vmem.vaddr = (uint64_t)(uintptr_t)param_heap->buffer;
+	param_heap->vmem.big_endian = false;
+	param_heap->vmem.write = NULL;
 
 	strlcpy(param->name, name, 36);
 	if (unit) {
@@ -769,12 +762,12 @@ void param_list_save_wildcard(const char * const filename, int node, int skip_no
         }
     }
 
-    param_t * param;
-    param_list_iterator i = {};
-    param_t* param_sorted[1024];
+    const param_t * param;
+    param_list_iterator iter = {0};
+    const param_t* param_sorted[1024];
     int param_cnt = 0;
 
-    while ((param = param_list_iterate(&i)) != NULL) {
+    while ((param = param_list_iterate(&iter)) != NULL) {
 
 		if (name_wildcard && (strmatch(param->name, name_wildcard, strlen(param->name), strlen(name_wildcard)) == 0)) {
 			continue;
diff --git a/src/param/param.c b/src/param/param.c
index 5577c2f9..8bf36eea 100644
--- a/src/param/param.c
+++ b/src/param/param.c
@@ -9,7 +9,7 @@
 
 
 #define PARAM_GET(_type, _name, _swapfct) \
-	_type param_get_##_name##_array(param_t * param, unsigned int i) { \
+	_type param_get_##_name##_array(const param_t * param, unsigned int i) { \
 		if (i >= (unsigned int) param->array_size) { \
 			return 0; \
 		} \
@@ -21,10 +21,12 @@
 			} \
 			return data; \
 		} else { \
-			return *(_type *)(param->addr + i * param->array_step); \
+			/* Increment pointer in bytes, we have static check on array step being aligned */ \
+			uintptr_t aligned_address = (uintptr_t)param->addr + (uintptr_t) i * (uintptr_t)param->array_step; \
+			return *(_type *)aligned_address; \
 		} \
 	} \
-	_type param_get_##_name(param_t * param) { \
+	_type param_get_##_name(const param_t * param) { \
 		return param_get_##_name##_array(param, 0); \
 	}
 
@@ -41,7 +43,7 @@ PARAM_GET(double, double, )
 
 #undef PARAM_GET
 
-void param_get(param_t * param, unsigned int offset, void * value) {
+void param_get(const param_t * param, unsigned int offset, void * value) {
 	switch(param->type) {
 
 #define PARAM_GET(casename, name, type) \
@@ -76,7 +78,7 @@ void param_get(param_t * param, unsigned int offset, void * value) {
     
 }
 
-void param_get_data(param_t * param, void * outbuf, int len)
+void param_get_data(const param_t * param, void * outbuf, int len)
 {
 	if (param->vmem && param->vmem->read) {
 		param->vmem->read(param->vmem, param->vaddr, outbuf, len);
@@ -90,7 +92,8 @@ void param_get_data(param_t * param, void * outbuf, int len)
 #endif
 
 #define PARAM_SET(_type, name_in, _swapfct) \
-	void __param_set_##name_in(param_t * param, _type value, bool do_callback, unsigned int i) { \
+	void __param_set_##name_in(const param_t * param, _type value, bool do_callback, unsigned int i); \
+	void __param_set_##name_in(const param_t * param, _type value, bool do_callback, unsigned int i) { \
 		if (i >= (unsigned int) param->array_size) { \
 			return; \
 		} \
@@ -99,27 +102,30 @@ void param_get_data(param_t * param, void * outbuf, int len)
 				value = _swapfct(value); \
 			vmem_write_direct(param->vmem, param->vmem->vaddr + param->vaddr + i * param->array_step, &value, sizeof(_type)); \
 		} else { \
+			/* Increment pointer in bytes, we have static check on array step being aligned */ \
+			uintptr_t aligned_write_address = (uintptr_t)param->addr + (uintptr_t) i * (uintptr_t)param->array_step; \
 			/* Aligned access directly to RAM */ \
-			*(_type*)(param->addr + i * param->array_step) = value; \
+			_type * typecasted_write_address = (_type *)aligned_write_address; \
+			*typecasted_write_address = value; \
 		} \
 		/* Callback */ \
 		if ((do_callback == true) && (param->callback)) { \
 			param->callback(param, i); \
 		} \
 	} \
-	inline void param_set_##name_in(param_t * param, _type value) \
+	inline void param_set_##name_in(const param_t * param, _type value) \
 	{ \
 		__param_set_##name_in(param, value, true, 0); \
 	} \
-	inline void param_set_##name_in##_nocallback(param_t * param, _type value) \
+	inline void param_set_##name_in##_nocallback(const param_t * param, _type value) \
 	{ \
 		__param_set_##name_in(param, value, false, 0); \
 	} \
-	inline void param_set_##name_in##_array(param_t * param, unsigned int i, _type value) \
+	inline void param_set_##name_in##_array(const param_t * param, unsigned int i, _type value) \
 	{ \
 		__param_set_##name_in(param, value, true, i); \
 	} \
-	inline void param_set_##name_in##_array_nocallback(param_t * param, unsigned int i, _type value) \
+	inline void param_set_##name_in##_array_nocallback(const param_t * param, unsigned int i, _type value) \
 	{ \
 		__param_set_##name_in(param, value, false, i); \
 	}
@@ -137,7 +143,7 @@ PARAM_SET(double, double, )
 
 #undef PARAM_SET
 
-void param_set(param_t * param, unsigned int offset, void * value) {
+void param_set(const param_t * param, unsigned int offset, void * value) {
 	switch(param->type) {
 
 #define PARAM_SET(casename, name, type) \
@@ -170,13 +176,13 @@ void param_set(param_t * param, unsigned int offset, void * value) {
 	}
 }
 
-void param_set_string(param_t * param, const char * inbuf, int len) {
+void param_set_string(const param_t * param, const char * inbuf, int len) {
 	param_set_data_nocallback(param, inbuf, len);
 	/* Termination */
 	if (param->vmem && param->vmem->write) {
 		param->vmem->write(param->vmem, param->vaddr + len, "", 1);
 	} else {
-		memcpy(param->addr + len , "", 1);
+		memcpy((uint8_t *) param->addr + len , "", 1);
 	}
 	/* Callback */
 	if (param->callback) {
@@ -184,7 +190,7 @@ void param_set_string(param_t * param, const char * inbuf, int len) {
 	}
 }
 
-void param_set_data_nocallback(param_t * param, const void * inbuf, int len) {
+void param_set_data_nocallback(const param_t * param, const void * inbuf, int len) {
 	if (param->vmem && param->vmem->write) {
 		param->vmem->write(param->vmem, param->vaddr, inbuf, len);
 	} else {
@@ -192,7 +198,7 @@ void param_set_data_nocallback(param_t * param, const void * inbuf, int len) {
 	}
 }
 
-void param_set_data(param_t * param, const void * inbuf, int len) {
+void param_set_data(const param_t * param, const void * inbuf, int len) {
 	param_set_data_nocallback(param, inbuf, len);
 	/* Callback */
 	if (param->callback) {
@@ -223,7 +229,7 @@ int param_typesize(param_type_e type) {
 	return -1;
 }
 
-int param_size(param_t * param) {
+int param_size(const param_t * param) {
 	switch(param->type) {
 	case PARAM_TYPE_STRING:
 	case PARAM_TYPE_DATA:
@@ -233,7 +239,7 @@ int param_size(param_t * param) {
 	}
 }
 
-void param_copy(param_t * dest, param_t * src) {
+void param_copy(const param_t * dest, const param_t * src) {
 
 	/* Type check */
 	if (dest->type != src->type) {
diff --git a/src/param/param_client.c b/src/param/param_client.c
index c4881695..9c82b713 100644
--- a/src/param/param_client.c
+++ b/src/param/param_client.c
@@ -9,7 +9,7 @@
 
 #include <stdio.h>
 #include <malloc.h>
-#include <inttypes.h>
+#include <string.h>
 #include <param/param.h>
 #include <csp/csp.h>
 #include <csp/arch/csp_time.h>
@@ -21,6 +21,7 @@
 #include <param/param_serializer.h>
 
 static void param_transaction_callback_pull(csp_packet_t *response, int verbose, int version, void * context) {
+	(void)context;
 
 	param_queue_t queue;
 	param_queue_init(&queue, &response->data[2], response->length - 2, response->length - 2, PARAM_QUEUE_TYPE_SET, version);
@@ -46,7 +47,7 @@ static void param_transaction_callback_pull(csp_packet_t *response, int verbose,
 		param_deserialize_id(&reader, &id, &node, &timestamp, &offset, &queue);
 		if (node == 0)
 			node = response->id.src;
-		param_t * param = param_list_find_id(node, id);
+		const param_t * param = param_list_find_id(node, id);
 
 		/* We need to discard the data field, to get to next paramid */
 		mpack_discard		(&reader);
@@ -165,7 +166,7 @@ int param_pull_queue(param_queue_t *queue, uint8_t prio, int verbose, int host,
 }
 
 
-int param_pull_single(param_t *param, int offset, int prio, int verbose, int host, int timeout, int version) {
+int param_pull_single(const param_t *param, int offset, int prio, int verbose, int host, int timeout, int version) {
 
 	csp_packet_t * packet = csp_buffer_get(PARAM_SERVER_MTU);
 	if (packet == NULL)
@@ -245,7 +246,7 @@ int param_push_queue(param_queue_t *queue, int prio, int verbose, int host, int
 	return 0;
 }
 
-int param_push_single(param_t *param, int offset, int prio, void *value, int verbose, int host, int timeout, int version, bool ack_with_pull) {
+int param_push_single(const param_t *param, int offset, int prio, void *value, int verbose, int host, int timeout, int version, bool ack_with_pull) {
 
 	csp_packet_t * packet = csp_buffer_get(PARAM_SERVER_MTU);
 	if (packet == NULL)
diff --git a/src/param/param_queue.c b/src/param/param_queue.c
index b57f5436..588363e8 100644
--- a/src/param/param_queue.c
+++ b/src/param/param_queue.c
@@ -27,7 +27,7 @@
 		int id, node, offset = -1; \
 		csp_timestamp_t timestamp = { .tv_sec = 0, .tv_nsec = 0 }; \
 		param_deserialize_id(&reader, &id, &node, &timestamp, &offset, queue); \
-		param_t * param = param_list_find_id(node, id); \
+		const param_t * param = param_list_find_id(node, id); \
 
 void param_queue_init(param_queue_t *queue, void *buffer, int buffer_size, int used, param_queue_type_e type, int version) {
 	queue->buffer = buffer;
@@ -41,7 +41,11 @@ void param_queue_init(param_queue_t *queue, void *buffer, int buffer_size, int u
 	queue->client_timestamp.tv_nsec = 0;
 }
 
-int param_queue_add(param_queue_t *queue, param_t *param, int offset, void *value) {
+int param_queue_add(param_queue_t *queue, const param_t *param, int offset, void *value) {
+
+	if (param == NULL) {
+		return -1;
+	}
 
 	/* Ensure we always send nodeid on the first element of the queue */
 	if (queue->used == 0) {
@@ -88,7 +92,7 @@ int param_queue_apply(param_queue_t *queue, int host, int verbose) {
 			node = host;
 
 		/* Search on the specified node in the request or response */
-		param_t * param = param_list_find_id(node, id);
+		const param_t * param = param_list_find_id(node, id);
 
 		if (param) {
 			if ((param->mask & PM_ATOMIC_WRITE) && (atomic_write == 0)) {
@@ -122,7 +126,7 @@ int param_queue_apply(param_queue_t *queue, int host, int verbose) {
 			switch (tag.type) {
     		case mpack_type_str:
     		case mpack_type_bin:
-    			if (reader.end - reader.data >= tag.v.l) {
+    			if ((unsigned int) (reader.end - reader.data) >= tag.v.l) {
 	    			mpack_skip_bytes(&reader, tag.v.l);
 	    		} else {
     				valid = false;
@@ -136,7 +140,7 @@ int param_queue_apply(param_queue_t *queue, int host, int verbose) {
 	    		}
     			break;
     		case mpack_type_array:
-    			for (int i = 0; i < tag.v.n; i++) {
+    			for (unsigned int i = 0; i < tag.v.n; i++) {
 					mpack_read_tag(&reader);
 					if (mpack_reader_error(&reader) != mpack_ok) {
 						valid = false;
@@ -218,7 +222,7 @@ void param_queue_print_params(param_queue_t *queue, uint32_t ref_timestamp) {
 				int _id, _node, _offset = -1;
 				csp_timestamp_t _timestamp = { .tv_sec = 0, .tv_nsec = 0 };
 				param_deserialize_id(&_reader, &_id, &_node, &_timestamp, &_offset, queue);
-				param_t * _param = param_list_find_id(_node, _id);
+				const param_t * _param = param_list_find_id(_node, _id);
 				if(queue->type == PARAM_QUEUE_TYPE_SET){
 					mpack_discard(&_reader);
 				}
diff --git a/src/param/param_serializer.c b/src/param/param_serializer.c
index 8a427515..708c15a2 100644
--- a/src/param/param_serializer.c
+++ b/src/param/param_serializer.c
@@ -34,7 +34,7 @@ static const uint16_t known_header_mask = (1 << PARAM_HEADER_ARRAY_POS)
 										| (1 << PARAM_HEADER_EXTENDEDTIMESTAMP_POS)
 										|       PARAM_HEADER_ID_MASK;
 
-static inline uint16_t param_get_short_id(param_t * param, unsigned int isarray, unsigned int reserved) {
+static inline uint16_t param_get_short_id(const param_t * param, unsigned int isarray, unsigned int reserved) {
 	uint16_t node = *param->node;
 	return (node << 11) | ((isarray & 0x1) << 10) | ((reserved & 0x1) << 2) | ((param->id) & 0x1FF);
 }
@@ -51,7 +51,7 @@ static inline uint16_t param_parse_short_id_paramid(uint16_t short_id) {
 	return short_id & 0x1FF;
 }
 
-void param_serialize_id(mpack_writer_t *writer, param_t *param, int offset, param_queue_t *queue) {
+void param_serialize_id(mpack_writer_t *writer, const param_t *param, int offset, param_queue_t *queue) {
 
 	if (queue->version == 1) {
 
@@ -198,7 +198,7 @@ void param_deserialize_id(mpack_reader_t *reader, int *id, int *node, csp_timest
 
 }
 
-int param_serialize_to_mpack(param_t * param, int offset, mpack_writer_t * writer, void * value, param_queue_t * queue) {
+int param_serialize_to_mpack(const param_t * param, int offset, mpack_writer_t * writer, void * value, param_queue_t * queue) {
 
 	/* Remember the initial position if we need to abort later due to buffer full */
 	char * init_pos = writer->position;
@@ -380,7 +380,9 @@ int param_serialize_to_mpack(param_t * param, int offset, mpack_writer_t * write
 
 }
 
-void param_deserialize_from_mpack_to_param(void * context, void * queue, param_t * param, int offset, mpack_reader_t * reader) {
+void param_deserialize_from_mpack_to_param(void * context, void * queue, const param_t * param, int offset, mpack_reader_t * reader) {
+	(void) context;
+	(void) queue;
 
 	if (offset < 0)
 		offset = 0;
diff --git a/src/param/param_server.c b/src/param/param_server.c
index 66cfe17c..a1febc29 100644
--- a/src/param/param_server.c
+++ b/src/param/param_server.c
@@ -6,6 +6,7 @@
  */
 
 #include <stdio.h>
+#include <string.h>
 #include <csp/csp.h>
 #include <csp/arch/csp_time.h>
 #include <sys/types.h>
@@ -26,7 +27,6 @@ struct param_serve_context {
 	csp_packet_t * request;
 	csp_packet_t * response;
 	param_queue_t q_response;
-	csp_conn_t * publish_conn;
 };
 
 static int __allocate(struct param_serve_context *ctx) {
@@ -39,9 +39,6 @@ static int __allocate(struct param_serve_context *ctx) {
 
 static void __send(struct param_serve_context *ctx, int end) {
 
-	ctx->response->data[1] = (end) ? PARAM_FLAG_END : 0;
-	ctx->response->length = ctx->q_response.used + 2;
-
 	if (ctx->q_response.version == 1) {
 		ctx->response->data[0] = PARAM_PULL_RESPONSE;
 	} else {
@@ -50,25 +47,10 @@ static void __send(struct param_serve_context *ctx, int end) {
 	ctx->response->data[1] = (end) ? PARAM_FLAG_END : 0;
 	ctx->response->length = ctx->q_response.used + 2;
 
-	if (ctx->publish_conn != NULL) {
-		ctx->response->data[1] |= PARAM_FLAG_NOACK;
-
-		ctx->response->id.flags = CSP_O_CRC32;
-		ctx->response->id.src = 0;
-	
-		if (ctx->publish_conn == NULL) {
-			printf("param transaction failure\n");
-			return;
-		}
-	
-		csp_send(ctx->publish_conn, ctx->response);
-		return;
-	}
-
 	csp_sendto_reply(ctx->request, ctx->response, CSP_O_SAME);
 }
 
-static int __add(struct param_serve_context *ctx, param_t * param, int offset) {
+static int __add(struct param_serve_context *ctx, const param_t * param, int offset) {
 
 	int result = param_queue_add(&ctx->q_response, param, offset, NULL);
 	if (result != 0) {
@@ -93,7 +75,6 @@ static void param_serve_pull_request(csp_packet_t * request, int all, int versio
 	ctx.q_response.version = version;
 	/* If packet->data[1] == 1 ack with pull response */
 	int ack_with_pull = request->data[1] == 1 ? 1 : 0;
-	ctx.publish_conn = NULL;
 
 	if (__allocate(&ctx) < 0) {
 		csp_buffer_free(request);
@@ -113,7 +94,7 @@ static void param_serve_pull_request(csp_packet_t * request, int all, int versio
 			int id, node, offset = -1;
 			csp_timestamp_t timestamp = { .tv_sec = 0, .tv_nsec = 0 };
 			param_deserialize_id(&reader, &id, &node, &timestamp, &offset, &q_request);
-			param_t * param = param_list_find_id(node, id);
+			const param_t * param = param_list_find_id(node, id);
 			if (param) {
 				if(ack_with_pull) {
 					/* Move reader forward to skip values as we normally use a get queue */
@@ -127,7 +108,7 @@ static void param_serve_pull_request(csp_packet_t * request, int all, int versio
 						int _id, _node, _offset = -1;
 						csp_timestamp_t _timestamp = { .tv_sec = 0, .tv_nsec = 0 };
 						param_deserialize_id(&_reader, &_id, &_node, &_timestamp, &_offset, &ctx.q_response);
-						param_t * _param = param_list_find_id(_node, _id);
+						const param_t * _param = param_list_find_id(_node, _id);
 
 						/* Move reader forward to skip values */
 						mpack_discard(&_reader);
@@ -160,8 +141,8 @@ static void param_serve_pull_request(csp_packet_t * request, int all, int versio
 	} else {
 
 		/* Loop the full parameter list */
-		param_t * param;
-		param_list_iterator i = {};
+		const param_t * param;
+		param_list_iterator i = {0};
 		while ((param = param_list_iterate(&i)) != NULL) {
 			if (param->mask & PM_HIDDEN) {
 				continue;
@@ -266,7 +247,7 @@ void param_serve(csp_packet_t * packet) {
 
 			//printf("hwid %d\n", hwid);
 			__attribute__((weak)) int serial_get(void);
-			if ((serial_get != NULL && hwid != serial_get()) && (hwid != 1234)) {
+			if ((serial_get != NULL && hwid != (uint32_t) serial_get()) && (hwid != 1234)) {
 				printf("hwid did not match\n");
 				csp_buffer_free(packet);
 				break;
diff --git a/src/param/param_string.c b/src/param/param_string.c
index af39f431..28fa355c 100644
--- a/src/param/param_string.c
+++ b/src/param/param_string.c
@@ -37,7 +37,7 @@ static	int nibble(char c) {
 	return -1;
 }
 
-void param_value_str(param_t *param, unsigned int i, char * out, int len)
+void param_value_str(const param_t *param, unsigned int i, char * out, int len)
 {
 	switch (param->type) {
 #define PARAM_SWITCH_SNPRINTF(casename, strtype, strcast, name) \
@@ -87,8 +87,8 @@ void param_value_str(param_t *param, unsigned int i, char * out, int len)
 		char data[param->array_size];
 		param_get_data(param, data, param->array_size);
 		int written;
-		for (int i = 0; i < param->array_size && len >= 2; i++) {
-			written = snprintf(out, len, "%02X", (unsigned char) data[i]);
+		for (int j = 0; j < param->array_size && len >= 2; j++) {
+			written = snprintf(out, len, "%02X", (unsigned char) data[j]);
 			len -= written;
 			out += written;
 		}
@@ -109,7 +109,7 @@ int param_str_to_value(param_type_e type, char *in, void *out) {
 
 #define PARAM_SCANFU(casename, strtype, cast, name) \
 	case casename: { \
-	    for (int i = 0; i < strlen(in); i++) if (!isdigit(in[i])) return -1; \
+	    for (unsigned int i = 0; i < strlen(in); i++) if (!isdigit(in[i])) return -1; \
 		cast obj; \
 		sscanf(in, strtype, &obj); \
 		*(cast *) out = (cast) obj; \
@@ -118,7 +118,7 @@ int param_str_to_value(param_type_e type, char *in, void *out) {
 
 #define PARAM_SCANFD(casename, strtype, cast, name) \
 	case casename: { \
-	    for (int i = 0; i < strlen(in); i++) if (!isdigit(in[i]) && in[i] != '-' && in[i] != '+') return -1; \
+	    for (unsigned int i = 0; i < strlen(in); i++) if (!isdigit(in[i]) && in[i] != '-' && in[i] != '+') return -1; \
 		cast obj; \
 		sscanf(in, strtype, &obj); \
 		*(cast *) out = (cast) obj; \
@@ -128,7 +128,7 @@ int param_str_to_value(param_type_e type, char *in, void *out) {
 #define PARAM_SCANFX(casename, strtype, cast, name) \
 	case casename: { \
 	    if (in[0] != '0' || in[1] != 'x' || strlen(in) < 3) return -1; \
-	    for (int i = 2; i < strlen(in); i++) if (!isxdigit(in[i])) return -1; \
+	    for (unsigned int i = 2; i < strlen(in); i++) if (!isxdigit(in[i])) return -1; \
 		cast obj; \
 		sscanf(in, strtype, &obj); \
 		*(cast *) out = (cast) obj; \
@@ -138,7 +138,7 @@ int param_str_to_value(param_type_e type, char *in, void *out) {
 #define PARAM_SCANFF(casename, strtype, cast, name) \
 	case casename: { \
 		int numdots = 0; \
-		for (int i = 0; i < strlen(in); i++) { \
+		for (unsigned int i = 0; i < strlen(in); i++) { \
 			if (in[i] == ',') in[i] = '.'; \
 			if (in[i] == '.') numdots++; \
 	    	if (!isdigit(in[i]) && in[i] != '-' && in[i] != '+' && in[i] != '.' && in[i] != 'e' && in[i] != 'E') return -1; \
@@ -172,12 +172,12 @@ int param_str_to_value(param_type_e type, char *in, void *out) {
 		return strlen(in);
 
 	case PARAM_TYPE_DATA: {
-		int len = strlen(in) / 2;
+		unsigned int len = strlen(in) / 2;
 
 		if (2*len != strlen(in))
 			return -1;
 
-		for (int i = 0; i < len; i++) {
+		for (unsigned int i = 0; i < len; i++) {
 			int nibble1 = nibble(in[i*2]);
 			int nibble2 = nibble(in[i*2+1]);
 			if (nibble1 < 0 || nibble2 < 0) return -1;
@@ -222,7 +222,7 @@ void param_type_str(param_type_e type, char * out, int len)
 	}
 }
 
-static void param_print_value(FILE * file, param_t * param, int offset) {
+static void param_print_value(FILE * file, const param_t * param, int offset) {
 
 	if (param == NULL) {
 		return;
@@ -246,7 +246,7 @@ static void param_print_value(FILE * file, param_t * param, int offset) {
 		offset = 0;
 	}
 
-	char value_str[1024] = {};
+	char value_str[1024] = {0};
 
 	if (count > 1) {
 		strcat(value_str, "[");
@@ -291,8 +291,8 @@ static void param_print_value(FILE * file, param_t * param, int offset) {
 
 }
 
-void param_print_file(FILE* file, param_t * param, int offset, int nodes[], int nodes_count, int verbose, uint32_t ref_timestamp)
-{
+static void param_print_file(FILE* file, const param_t * param, int offset, int nodes[], int nodes_count, int verbose, uint32_t ref_timestamp) {
+
 	if (param == NULL)
 		return;
 
@@ -303,6 +303,7 @@ void param_print_file(FILE* file, param_t * param, int offset, int nodes[], int
 		fprintf(file, "%s", param_mask_color(param));
 	}
 #else
+	(void) ref_timestamp;
 	fprintf(file, "%s", param_mask_color(param));
 #endif
 
@@ -318,7 +319,7 @@ void param_print_file(FILE* file, param_t * param, int offset, int nodes[], int
 	/* Value table */
 	if (nodes_count > 0 && nodes != NULL) {
 		for(int i = 0; i < nodes_count; i++) {
-			param_t * specific_param = param_list_find_id(nodes[i], param->id);
+			const param_t * specific_param = param_list_find_id(nodes[i], param->id);
 			param_print_value(file, specific_param, offset);
 		}
 
@@ -329,7 +330,7 @@ void param_print_file(FILE* file, param_t * param, int offset, int nodes[], int
 
 	if (verbose >= 2) {
 		/* Type */
-		char type_str[11] = {};
+		char type_str[11] = {0};
 		param_type_str(param->type, type_str, 10);
 		fprintf(file, " %s", type_str);
 
@@ -444,7 +445,7 @@ void param_print_file(FILE* file, param_t * param, int offset, int nodes[], int
 
 }
 
-void param_print(param_t * param, int offset, int nodes[], int nodes_count, int verbose, uint32_t ref_timestamp) {
+void param_print(const param_t * param, int offset, int nodes[], int nodes_count, int verbose, uint32_t ref_timestamp) {
 
 	param_print_file(stdout, param, offset, nodes, nodes_count, verbose, ref_timestamp);
 }
@@ -488,7 +489,7 @@ uint32_t param_umaskstr_to_mask(const char * str) {
 
 	uint32_t mask = 0;
 
-	for (int i = 0; i < strlen(str); i++) {
+	for (unsigned int i = 0; i < strlen(str); i++) {
 
 		if (str[i] == '0') {
 			/* strtol returns 0 for invalid characters, therefore handled independent */
diff --git a/src/param/param_wildcard.c b/src/param/param_wildcard.c
index 531aa975..7633ddd6 100644
--- a/src/param/param_wildcard.c
+++ b/src/param/param_wildcard.c
@@ -1,3 +1,5 @@
+#include <param/param_wildcard.h>
+
 #include <stdio.h>
 #include <string.h>
 #include <param/param.h>
@@ -56,7 +58,8 @@ int strmatch(const char *str, const char *pattern, int n, int m)  // Source: htt
 }
 
 int has_wildcard(const char * str, int len) {
-    for (int i = 0; i < strlen(str); i++)
+    (void)len;
+    for (unsigned int i = 0; i < strlen(str); i++)
 		if (str[i] == '*' || str[i] == '?')
 			return 1;
     return 0;
diff --git a/src/vmem/vmem.c b/src/vmem/vmem.c
index 74102817..06289162 100644
--- a/src/vmem/vmem.c
+++ b/src/vmem/vmem.c
@@ -22,7 +22,7 @@ void * vmem_memcpy(void * to, const void * from, uint32_t size) {
 	return vmem_cpy((uint64_t)(uintptr_t)to, (uint64_t)(uintptr_t)from, (uint64_t)size);
 }
 
-void * vmem_write_direct(vmem_t * vmem, uint64_t to, const void * from, uint32_t size) {
+void * vmem_write_direct(const vmem_t * vmem, uint64_t to, const void * from, uint32_t size) {
 
 	/* Write to VMEM */
 	if ((to >= vmem->vaddr) && (to + (uint64_t)size <= vmem->vaddr + vmem->size)) {
@@ -36,7 +36,7 @@ void * vmem_write_direct(vmem_t * vmem, uint64_t to, const void * from, uint32_t
 	return NULL;
 }
 
-void * vmem_read_direct(vmem_t * vmem, void * to, uint64_t from, uint32_t size) {
+void * vmem_read_direct(const vmem_t * vmem, void * to, uint64_t from, uint32_t size) {
 
 	/* Read */
 	if ((from >= vmem->vaddr) && (from + (uint64_t)size <= vmem->vaddr + vmem->size)) {
@@ -163,6 +163,9 @@ int vmem_ptr_to_index(vmem_t * vmem) {
 	return -1;
 }
 
+extern const vmem_t __start_vmem __attribute__((weak));
+extern const vmem_t __stop_vmem __attribute__((weak));
+
 #ifdef PARAM_LIST_DYNAMIC
 static vmem_iter_t g_start = {
 #else
@@ -227,7 +230,7 @@ void vmem_add(vmem_t * start, vmem_t * stop) {
 		* of VMEM blocks
 		*/
 		if(start != g_start.start) {
-			vmem_iter_t *new_vmem = calloc(sizeof(vmem_iter_t), 1);
+			vmem_iter_t *new_vmem = calloc(1, sizeof(vmem_iter_t));
 			if(new_vmem) {
 				new_vmem->start = start;
 				new_vmem->stop = stop;
diff --git a/src/vmem/vmem_client.c b/src/vmem/vmem_client.c
index 258d92b7..8d3d3bc8 100644
--- a/src/vmem/vmem_client.c
+++ b/src/vmem/vmem_client.c
@@ -6,16 +6,17 @@
  */
 
 #include <stdio.h>
+#include <string.h>
 #include <csp/arch/csp_time.h>
 #include <sys/types.h>
 #include <unistd.h>
 
 #include <vmem/vmem_client.h>
 
-static int abort = 0;
+static int client_abort = 0;
 
 void vmem_client_abort(void) {
-	abort = 1;
+	client_abort = 1;
 }
 
 int vmem_download(int node, int timeout, uint64_t address, uint32_t length, char * dataout, int version, int use_rdp) {
@@ -27,7 +28,7 @@ int vmem_download(int node, int timeout, uint64_t address, uint32_t length, char
 int vmem_download_progress(int node, int timeout, uint64_t address, uint32_t length, char * dataout, int version, int use_rdp, vmem_progress_cb cb)
 {
 	uint32_t time_begin = csp_get_ms();
-	abort = 0;
+	client_abort = 0;
 
 	/* Establish RDP connection */
 	uint32_t opts = CSP_O_CRC32;
@@ -70,7 +71,7 @@ int vmem_download_progress(int node, int timeout, uint64_t address, uint32_t len
 		if (packet == NULL)
 			break;
 
-		if (abort) {
+		if (client_abort) {
 			csp_buffer_free(packet);
 			break;
 		}
@@ -108,6 +109,7 @@ int vmem_download_progress(int node, int timeout, uint64_t address, uint32_t len
 }
 
 void vmem_progress(uint32_t total, uint32_t sofar) {
+	(void) total;
 
 	if ((sofar / VMEM_SERVER_MTU) % 32 == 0) {
 		printf("  ");
@@ -127,7 +129,7 @@ int vmem_upload(int node, int timeout, uint64_t address, char * datain, uint32_t
 
 int vmem_upload_progress(int node, int timeout, uint64_t address, char * datain, uint32_t length, int version, vmem_progress_cb cb) {
 
-	abort = 0;
+	client_abort = 0;
 
 	/* Establish RDP connection */
 	csp_conn_t * conn = csp_connect(CSP_PRIO_HIGH, node, VMEM_PORT_SERVER, timeout, CSP_O_RDP | CSP_O_CRC32);
@@ -158,7 +160,7 @@ int vmem_upload_progress(int node, int timeout, uint64_t address, char * datain,
 	uint32_t count = 0;
 	while((count < length) && csp_conn_is_active(conn)) {
 
-		if (abort) {
+		if (client_abort) {
 			csp_buffer_free(packet);
 			break;
 		}
@@ -167,7 +169,7 @@ int vmem_upload_progress(int node, int timeout, uint64_t address, char * datain,
 		}
 
 		/* Prepare packet */
-		csp_packet_t * packet = csp_buffer_get(VMEM_SERVER_MTU);
+		packet = csp_buffer_get(VMEM_SERVER_MTU);
 		packet->length = VMEM_MIN(VMEM_SERVER_MTU, length - count);
 
 		/* Copy data */
@@ -216,7 +218,7 @@ static csp_packet_t * vmem_client_list_get(int node, int timeout, int version) {
 		resp->length = 0;
 		/* Keep receiving until we got everything or we got a timeout */
 		while ((packet = csp_read(conn, timeout)) != NULL) {
-			if (packet->data[0] & 0b01000000) {
+			if (packet->data[0] & 0x40) {
 				/* First packet */
 				resp->length = 0;
 			}
@@ -225,7 +227,7 @@ static csp_packet_t * vmem_client_list_get(int node, int timeout, int version) {
 			memcpy(&resp->data[resp->length], &packet->data[1], (packet->length - 1));
 			resp->length += (packet->length - 1);
 
-			if (packet->data[0] & 0b10000000) {
+			if (packet->data[0] & 0x80) {
 				/* Last packet, break the loop */
 				csp_buffer_free(packet);
 				break;
@@ -282,7 +284,7 @@ int vmem_client_find(int node, int timeout, void * dataout, int version, char *
 		return -1;
 
 	if (version == 3) {
-		vmem_list3_t ret = {};
+		vmem_list3_t ret = {0};
 		for (vmem_list3_t * vmem = (void *)packet->data; (intptr_t)vmem < (intptr_t)packet->data + packet->length; vmem++) {
 			if (strncmp(vmem->name, name, namelen) == 0) {
 				ret.vmem_id = vmem->vmem_id;
@@ -294,7 +296,7 @@ int vmem_client_find(int node, int timeout, void * dataout, int version, char *
 		}
 		memcpy(dataout, &ret, sizeof(vmem_list3_t));
 	} else if (version == 2) {
-		vmem_list2_t ret = {};
+		vmem_list2_t ret = {0};
 		for (vmem_list2_t * vmem = (void *)packet->data; (intptr_t)vmem < (intptr_t)packet->data + packet->length; vmem++) {
 			if (strncmp(vmem->name, name, namelen) == 0) {
 				ret.vmem_id = vmem->vmem_id;
@@ -306,7 +308,7 @@ int vmem_client_find(int node, int timeout, void * dataout, int version, char *
 		}
 		memcpy(dataout, &ret, sizeof(vmem_list2_t));
 	} else {
-		vmem_list_t ret = {};
+		vmem_list_t ret = {0};
 		for (vmem_list_t * vmem = (void *)packet->data; (intptr_t)vmem < (intptr_t)packet->data + packet->length; vmem++) {
 			if (strncmp(vmem->name, name, namelen) == 0) {
 				ret.vmem_id = vmem->vmem_id;
diff --git a/src/vmem/vmem_file.c b/src/vmem/vmem_file.c
index a357c8c9..e577125d 100644
--- a/src/vmem/vmem_file.c
+++ b/src/vmem/vmem_file.c
@@ -44,7 +44,7 @@ void vmem_file_write(vmem_t * vmem, uint64_t addr, const void * datain, uint32_t
 		/* Flush back to file */
 		int res = fseek(driver->stream, addr, SEEK_SET);
 		(void)res;
-		int written = fwrite(driver->physaddr + addr, len, 1, driver->stream);
+		int written = fwrite((char *) driver->physaddr + addr, len, 1, driver->stream);
 		fflush(driver->stream);
 		(void) written;
 	}
diff --git a/src/vmem/vmem_fram.c b/src/vmem/vmem_fram.c
index 1cd14358..1386aaec 100644
--- a/src/vmem/vmem_fram.c
+++ b/src/vmem/vmem_fram.c
@@ -18,11 +18,11 @@ void fram_write_data(uint32_t addr, const void *data, uint32_t len);
 void fram_read_data(uint32_t addr, void *data, uint32_t len);
 
 
-void vmem_fram_read(vmem_t * vmem, uint64_t addr, void * dataout, uint32_t len) {
+void vmem_fram_read(const vmem_t * vmem, uint64_t addr, void * dataout, uint32_t len) {
 	fram_read_data(((uintptr_t) ((vmem_fram_driver_t*) vmem->driver)->fram_addr) + (uintptr_t)addr, dataout, len);
 }
 
-void vmem_fram_write(vmem_t * vmem, uint64_t addr, const void * datain, uint32_t len) {
+void vmem_fram_write(const vmem_t * vmem, uint64_t addr, const void * datain, uint32_t len) {
 	fram_write_data(((uintptr_t) ((vmem_fram_driver_t*) vmem->driver)->fram_addr) + (uintptr_t)addr, datain, len);
 }
 
diff --git a/src/vmem/vmem_fram_cache.c b/src/vmem/vmem_fram_cache.c
index baca6799..7d7f36bc 100644
--- a/src/vmem/vmem_fram_cache.c
+++ b/src/vmem/vmem_fram_cache.c
@@ -18,7 +18,7 @@ void fram_write_data(uint32_t addr, const void *data, uint32_t len);
 void fram_read_data(uint32_t addr, void *data, uint32_t len);
 
 
-void vmem_fram_cache_read(vmem_t * vmem, uint64_t addr, void * dataout, uint32_t len) {
+void vmem_fram_cache_read(const vmem_t * vmem, uint64_t addr, void * dataout, uint32_t len) {
 
 	vmem_fram_cache_driver_t * driver = vmem->driver;
 
@@ -34,7 +34,7 @@ void vmem_fram_cache_read(vmem_t * vmem, uint64_t addr, void * dataout, uint32_t
 
 }
 
-void vmem_fram_cache_write(vmem_t * vmem, uint64_t addr, const void * datain, uint32_t len) {
+void vmem_fram_cache_write(const vmem_t * vmem, uint64_t addr, const void * datain, uint32_t len) {
 
 	vmem_fram_cache_driver_t * driver = vmem->driver;
 
diff --git a/src/vmem/vmem_internal.h b/src/vmem/vmem_internal.h
index fc2e8644..6608f98a 100644
--- a/src/vmem/vmem_internal.h
+++ b/src/vmem/vmem_internal.h
@@ -37,7 +37,7 @@ vmem_t *vmem_from_iter(vmem_iter_t * iter);
  * @param size Number of bytes to transfer
  * @return void* always NULL, no error detection possible at this time
  */
-void * vmem_write_direct(vmem_t * vmem, uint64_t to, const void * from, uint32_t size);
+void * vmem_write_direct(const vmem_t * vmem, uint64_t to, const void * from, uint32_t size);
 
 /**
  * @brief Read chunk of data from VMEM to physical memory
@@ -47,4 +47,4 @@ void * vmem_write_direct(vmem_t * vmem, uint64_t to, const void * from, uint32_t
  * @param size Number of bytes to transfer
  * @return void* always NULL, no error detection possible at this time
  */
-void * vmem_read_direct(vmem_t * vmem, void * to, uint64_t from, uint32_t size);
+void * vmem_read_direct(const vmem_t * vmem, void * to, uint64_t from, uint32_t size);
diff --git a/src/vmem/vmem_mmap.c b/src/vmem/vmem_mmap.c
index 5d341a68..e60fbd7d 100644
--- a/src/vmem/vmem_mmap.c
+++ b/src/vmem/vmem_mmap.c
@@ -43,7 +43,7 @@ void vmem_mmap_read(vmem_t *vmem, uint64_t addr, void *dataout, uint32_t len)
 {
 	vmem_mmap_driver_t *drv = (vmem_mmap_driver_t *)vmem->driver;
 	ensure_init(drv, &vmem->size);
-	memcpy(dataout, ((vmem_mmap_driver_t *)vmem->driver)->physaddr + addr, len);
+	memcpy(dataout, (char *) ((vmem_mmap_driver_t *)vmem->driver)->physaddr + addr, len);
 }
 
 void vmem_mmap_write(vmem_t *vmem, uint64_t addr, const void *datain, uint32_t len)
@@ -59,5 +59,5 @@ void vmem_mmap_write(vmem_t *vmem, uint64_t addr, const void *datain, uint32_t l
 		drv->physaddr = 0;
 		ensure_init(drv, &vmem->size);
 	}
-	memcpy(drv->physaddr + addr, datain, len);
+	memcpy((char *)drv->physaddr + addr, datain, len);
 }
diff --git a/src/vmem/vmem_server.c b/src/vmem/vmem_server.c
index 96c73862..a5ef7102 100644
--- a/src/vmem/vmem_server.c
+++ b/src/vmem/vmem_server.c
@@ -7,6 +7,7 @@
 
 #include <stdio.h>
 #include <stdlib.h>
+#include <string.h>
 #include <csp/csp.h>
 #include <sys/types.h>
 #include <csp/arch/csp_time.h>
@@ -23,6 +24,9 @@
 #include <param/param_server.h>
 #include "vmem_internal.h"
 
+/* Statically allocate a listener socket */
+static csp_socket_t vmem_server_socket = {0};
+
 #ifdef PARAM_LIST_DYNAMIC
 
 SLIST_HEAD(vmem_handler_obj_list_s, vmem_handler_obj_s);
@@ -115,7 +119,7 @@ void vmem_server_handler(csp_conn_t * conn)
 
 			while((count < length) && csp_conn_is_active(conn)) {
 				/* Prepare packet */
-				csp_packet_t * packet = csp_buffer_get(VMEM_SERVER_MTU);
+				packet = csp_buffer_get(VMEM_SERVER_MTU);
 				if (packet == NULL) {
 					break;
 				}
@@ -227,7 +231,7 @@ void vmem_server_handler(csp_conn_t * conn)
 
 			/* The first byte of each packet contains the flag signalling the first and last packet */
 			packet->length = 1;
-			packet->data[0] = 0b01000000; /* First packet */
+			packet->data[0] = 0x40; /* First packet */
 			list = (vmem_list3_t *)&packet->data[packet->length];
 
 			vmem_t *vmem;
@@ -243,7 +247,7 @@ void vmem_server_handler(csp_conn_t * conn)
 						break;
 					}
 					packet->length = 1;
-					packet->data[0] = 0b00000000;
+					packet->data[0] = 0;
 					list = (vmem_list3_t *)&packet->data[packet->length];
 				}
 
@@ -260,7 +264,7 @@ void vmem_server_handler(csp_conn_t * conn)
 				list++;
 			}
 
-			packet->data[0] |= 0b10000000; /* Last packet */
+			packet->data[0] |= 0x80; /* Last packet */
 			csp_send(conn, packet);
 		}
 
@@ -291,8 +295,8 @@ void vmem_server_handler(csp_conn_t * conn)
 
 static void rparam_list_handler(csp_conn_t * conn)
 {
-	param_t * param;
-	param_list_iterator i = {};
+	const param_t * param;
+	param_list_iterator i = {0};
 	while ((param = param_list_iterate(&i)) != NULL) {
 		if (param->mask & PM_HIDDEN) {
 			continue;
@@ -333,9 +337,7 @@ static void rparam_list_handler(csp_conn_t * conn)
 }
 
 void vmem_server_loop(void * param) {
-
-	/* Statically allocate a listener socket */
-	static csp_socket_t vmem_server_socket = {0};
+	(void)param;
 
 	/* Bind all ports to socket */
 	csp_bind(&vmem_server_socket, VMEM_PORT_SERVER);