EM-290: create watchdog that monitors other micro-controllers connected via the serial protocol

Author: Bart Jonkers

stack/framework/CMakeLists.txt

@@ -85,6 +85,9 @@ FRAMEWORK_HEADER_DEFINE(BOOL FRAMEWORK_MODEM_INTERFACE_USE_DMA)
 SET(FRAMEWORK_MODEM_INTERFACE_USE_INTERRUPT_LINES "FALSE" CACHE BOOL "Enable interrupt lines to wake up modem and MCU for signaling serial communication")
 FRAMEWORK_HEADER_DEFINE(BOOL FRAMEWORK_MODEM_INTERFACE_USE_INTERRUPT_LINES)
 
+SET(FRAMEWORK_SERIAL_PROTOCOL_WATCHDOG_LOG_ENABLED "FALSE" CACHE BOOL "Select whether to enable or disable the generation of logs from the serial protocol watchdog component")
+FRAMEWORK_HEADER_DEFINE(BOOL FRAMEWORK_SERIAL_PROTOCOL_WATCHDOG_LOG_ENABLED)
+
 SET(FRAMEWORK_POWER_TRACKING_LOG_ENABLED "FALSE" CACHE BOOL "Select whether to enable or disable the generation of logs from the power tracking component")
 FRAMEWORK_HEADER_DEFINE(BOOL FRAMEWORK_POWER_TRACKING_LOG_ENABLED)
 

stack/framework/components/serial_protocol/serial_protocol.c

@@ -62,7 +62,7 @@
 #endif
 
 #ifdef FRAMEWORK_SERIAL_PROTOCOL_SUPPORT_INTERRUPT_LINES
-#define SERIAL_PROTOCOL_TIMEOUT            (5 * TIMER_TICKS_PER_SEC)
+#define SERIAL_PROTOCOL_TIMEOUT            (15 * TIMER_TICKS_PER_SEC) // Same as PING_TIMEOUT of serial protocol monitor, longer than the boot time of the other party
 #define SERIAL_PROTOCOL_TIMEOUT_BLOCK_TIME (5 * TIMER_TICKS_PER_MINUTE)
 
 #endif

stack/framework/components/serial_protocol_watchdog/CMakeLists.txt

@@ -0,0 +1,22 @@
+#[[
+Copyright (c) 2015-2021 University of Antwerp, Aloxy NV.
+
+This file is part of Sub-IoT.
+See https://github.com/Sub-IoT/Sub-IoT-Stack for further info.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+]]
+
+#Each Framework component must generate a single OBJECT library named
+#'${COMPONENT_LIBRARY_NAME}'
+ADD_LIBRARY(${COMPONENT_LIBRARY_NAME} OBJECT serial_protocol_watchdog.c)

stack/framework/components/serial_protocol_watchdog/serial_protocol_watchdog.c

@@ -0,0 +1,82 @@
+#include "serial_protocol_watchdog.h"
+
+#include "debug.h"
+#include "fifo.h"
+#include "log.h"
+#include "scheduler.h"
+
+#if defined(FRAMEWORK_LOG_ENABLED) && defined(FRAMEWORK_SERIAL_PROTOCOL_WATCHDOG_LOG_ENABLED)
+  #define DPRINT(...) log_print_string(__VA_ARGS__)
+  #define DPRINT_DATA(...) log_print_data(__VA_ARGS__)
+#else
+  #define DPRINT(...)
+  #define DPRINT_DATA(...)
+#endif
+
+#define PING_TIMEOUT (15 * TIMER_TICKS_PER_SEC) // Same as SERIAL_PROTOCOL_TIMEOUT, longer than the boot time of the other party
+#define PING_DATA 0xCC
+
+typedef struct 
+{
+    serial_protocol_handle_t* sp_handle;
+    reset_function_t reset_function;
+} priv_serial_protocol_watchdog_handle_t;
+
+void timeout(void *arg)
+{
+    assert(arg!=NULL);
+    priv_serial_protocol_watchdog_handle_t* phandle = (priv_serial_protocol_watchdog_handle_t*)arg;
+    DPRINT("No ping response received. Reset!!!");
+    phandle->reset_function();
+}
+
+void send_ping(void *arg)
+{
+    assert(arg!=NULL);
+    priv_serial_protocol_watchdog_handle_t* phandle = (priv_serial_protocol_watchdog_handle_t*)arg;
+    timer_post_task_prio(&timeout, timer_get_counter_value() + PING_TIMEOUT, DEFAULT_PRIORITY, 0, arg);
+    uint8_t data = PING_DATA;
+    phandle->sp_handle->driver->serial_protocol_transfer_bytes(phandle->sp_handle, &data, 1, SERIAL_MESSAGE_TYPE_PING_REQUEST);
+}
+
+void ping_response_handler(serial_protocol_handle_t* handle, serial_message_type_t type, fifo_t* cmd_fifo)
+{
+    if(type != SERIAL_MESSAGE_TYPE_PING_RESPONSE)
+    {
+        return;
+    }
+    if(fifo_get_size(cmd_fifo) == 1)
+    {
+        uint8_t data;
+        fifo_pop(cmd_fifo, &data, 1);
+        if(data == PING_DATA)
+        {
+            timer_cancel_task(&timeout);
+        }
+    }
+}
+
+void serial_protocol_watchdog_init(serial_protocol_watchdog_handle_t* spw_handle,
+    serial_protocol_handle_t* sp_handle, reset_function_t reset_function, timer_tick_t check_interval)
+{
+    assert(sp_handle != NULL);
+    assert(spw_handle != NULL);
+    assert(reset_function != NULL);
+    assert(check_interval > PING_TIMEOUT);
+
+    priv_serial_protocol_watchdog_handle_t* phandle = (priv_serial_protocol_watchdog_handle_t*)spw_handle->priv_data;
+
+    phandle->sp_handle = sp_handle;
+    phandle->reset_function = reset_function;
+
+    // The timer doesn't support multiple timers for the same function.
+    // This functionality is needed if we want multiple instances of the serial_protocol_watchdog
+    // Change the following register tasks to true if this functionality comes available
+    sched_register_task_allow_multiple(send_ping, false);
+    sched_register_task_allow_multiple(timeout, false);
+
+    sp_handle->driver->serial_protocol_register_handler(sp_handle, &ping_response_handler, SERIAL_MESSAGE_TYPE_PING_RESPONSE);
+
+    timer_post_task_prio(&send_ping, timer_get_counter_value() + check_interval, DEFAULT_PRIORITY, check_interval, phandle);
+}
+

stack/framework/inc/serial_protocol_watchdog.h

@@ -0,0 +1,22 @@
+#ifndef SERIAL_PROTOCOL_WATCHDOG_H
+#define SERIAL_PROTOCOL_WATCHDOG_H
+
+#include "serial_protocol.h"
+#include "timer.h"
+
+typedef void (*reset_function_t)(void);
+
+#define WATCHDOG_PRIV_BUF_SIZE (2*(sizeof(void *)/4))
+
+typedef struct 
+{
+    uint32_t priv_data[WATCHDOG_PRIV_BUF_SIZE];
+}serial_protocol_watchdog_handle_t;
+
+void serial_protocol_watchdog_init(serial_protocol_watchdog_handle_t* spw_handle,
+    serial_protocol_handle_t* handle, reset_function_t reset_function, timer_tick_t check_interval);
+
+void start(serial_protocol_watchdog_handle_t* spw_handle);
+void stop(serial_protocol_watchdog_handle_t* spw_handle);
+
+#endif // SERIAL_PROTOCOL_WATCHDOG_H