Memfault Firmware SDK 0.24.2 (Build 294635)

Author: Memfault Inc

CHANGES.md

@@ -1,3 +1,15 @@
+### Changes between Memfault SDK 0.24.2 and SDK 0.24.1 - August 17, 2021
+
+#### :chart_with_upwards_trend: Improvements
+
+- Added a new utility API, `memfault_packetizer_set_active_sources`, to the
+  [data_packetizer](components/include/memfault/core/data_packetizer.h) module,
+  which let's one control the exact data sources that will get packetized. See
+  description in the header for more details
+- Port Improvements:
+  - NXP i.MX RT102x
+    - [rich reboot reason info derived from SRC_SRSR register](ports/nxp/rt1021/src_reboot_tracking.c)
+
 ### Changes between Memfault SDK 0.24.1 and SDK 0.24.0 - August 9, 2021
 
 #### :chart_with_upwards_trend: Improvements

VERSION

@@ -1,2 +1,2 @@
-BUILD ID: 290406
-GIT COMMIT: e752751b3
+BUILD ID: 294635
+GIT COMMIT: 0276687c3

components/core/src/memfault_data_packetizer.c

@@ -72,8 +72,19 @@ typedef enum {
   kMfltMessageType_Coredump = 1,
   kMfltMessageType_Event = 2,
   kMfltMessageType_Log = 3,
+  kMfltMessageType_NumTypes
 } eMfltMessageType;
 
+//! Make sure our externally facing types match the internal ones
+MEMFAULT_STATIC_ASSERT((1 << kMfltMessageType_Coredump) == kMfltDataSourceMask_Coredump,
+                       "kMfltDataSourceMask_Coredump is incorrectly defined");
+MEMFAULT_STATIC_ASSERT((1 << kMfltMessageType_Event) == kMfltDataSourceMask_Event,
+                       "kMfltDataSourceMask_Event, is incorrectly defined");
+MEMFAULT_STATIC_ASSERT((1 << kMfltMessageType_Log) == kMfltDataSourceMask_Log,
+                       "kMfltDataSourceMask_Log is incorrectly defined");
+MEMFAULT_STATIC_ASSERT(kMfltMessageType_NumTypes == 4, "eMfltDataSourceMask needs to be updated");
+
+
 typedef struct MemfaultDataSource {
   eMfltMessageType type;
   bool use_rle;
@@ -115,6 +126,13 @@ typedef MEMFAULT_PACKED_STRUCT {
 
 static sMfltTransportState s_mflt_packetizer_state;
 
+static eMfltDataSourceMask s_active_data_sources = kMfltDataSourceMask_All;
+
+void memfault_packetizer_set_active_sources(uint32_t mask) {
+  memfault_packetizer_abort();
+  s_active_data_sources = mask;
+}
+
 static void prv_reset_packetizer_state(void) {
   s_mflt_packetizer_state = (sMfltTransportState) {
     .active_message = false,
@@ -167,6 +185,13 @@ static void prv_data_source_chunk_transport_msg_reader(uint32_t offset, void *bu
 static bool prv_get_source_with_data(size_t *total_size, sMemfaultDataSource *active_source) {
   for (size_t i = 0; i < MEMFAULT_ARRAY_SIZE(s_memfault_data_source); i++) {
     const sMemfaultDataSource *data_source = &s_memfault_data_source[i];
+
+    const bool disabled_source = (((1 << data_source->type) & s_active_data_sources) == 0);
+    if (disabled_source) {
+      // sdk user has disabled extraction of data for specified source
+      continue;
+    }
+
     const bool rle_enabled = data_source->use_rle &&
         memfault_data_source_rle_encoder_set_active(data_source->impl);
 

components/include/memfault/core/data_packetizer.h

@@ -123,8 +123,59 @@ eMemfaultPacketizerStatus memfault_packetizer_get_next(void *buf, size_t *buf_le
 //!
 //! @note This will cause any partially written pieces of data to be re-transmitted in their
 //! entirety (i.e coredump)
+//! @note This is a no-op when called and memfault_packetizer_get_next() is already returning
+//! kMemfaultPacketizerStatus_NoMoreData or memfault_packetizer_get_chunk() is already returning
+//! false
 void memfault_packetizer_abort(void);
 
+typedef enum {
+  kMfltDataSourceMask_None = (1 << 0),
+
+  // Coredumps recorded when the system crashes
+  kMfltDataSourceMask_Coredump = (1 << 1),
+
+  // All "events" collected by the SDK (reboot, traces, heartbeats)
+  kMfltDataSourceMask_Event = (1 << 2),
+  // Any "triggered" log captures: https://mflt.io/logging
+  kMfltDataSourceMask_Log = (1 << 3),
+
+  // A convenience mask which enables all active sources
+  kMfltDataSourceMask_All =
+    (kMfltDataSourceMask_Coredump | kMfltDataSourceMask_Event | kMfltDataSourceMask_Log)
+} eMfltDataSourceMask;
+
+//! Set the data sources which will be drained by the packetizer
+//!
+//! @param mask A mask representing the data sources to drain
+//!
+//! @note By default, all data sources are active.
+//!
+//! @note This API can be used to prioritize the data source drained from the packetizer.
+//! This can be useful for use cases such as:
+//!  - Devices with multi connectivity toplogies (i.e BLE & WiFi) For example, in this situation a
+//!    user in this situation could choose to only enable Event and Log transfer when connected to
+//!    BLE and enable all sources when connected to WiFi
+//!  - Devices with extended periods where there is no connection to the internet In this
+//!    situation, an end user may want to store data buffered in RAM (i.e events & logs) on flash
+//!    to minimize the RAM footprint and prevent data from being lost by an unexpected reset.
+//!    If an end user is already using a flash region to save coredumps, pre-encoded chunks
+//!    can of just events can be saved, i.e
+//!
+//!     1. Only enable draining of events with the following API call:
+//!        memfault_packetizer_set_active_sources(kMfltDataSourceMask_Event);
+//!     2. Using memfault_packetizer_get_chunk() API, now read out events and
+//!        save to flash or a filesystem (https://mflt.io/data-to-cloud)
+//!     3. When a connection becomes available
+//!       a) send pre-saved chunks from flash over your transport
+//!       b) call memfault_packetizer_get_chunk() and send data until no more data is available
+//!       c) re-enable all sources with memfault_packetizer_get_chunk(kMfltDataSourceMask_All) and
+//!          then call memfault_packetizer_get_chunk() to drain and send any data from other
+//!          sources that is now available (i.e coredumps)
+//!
+//! @note Calling this API invokes memfault_packetizer_abort(). This means any in-progress message
+//! packetization will be restarted when you next attempt to drain data.
+void memfault_packetizer_set_active_sources(uint32_t mask);
+
 #ifdef __cplusplus
 }
 #endif

components/include/memfault/version.h

@@ -0,0 +1,23 @@
+#pragma once
+
+//! @file
+//!
+//! Contains Memfault SDK version information.
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#include <stdint.h>
+
+typedef struct {
+  uint16_t major;
+  uint16_t minor;
+  uint16_t patch;
+} sMfltSdkVersion;
+
+#define MEMFAULT_SDK_VERSION   { .major = 0, .minor = 24, .patch = 2 }
+
+#ifdef __cplusplus
+}
+#endif

examples/esp32/README.md

@@ -34,26 +34,27 @@ Make sure you have read the instructions in the `README.md` in the root of the
 SDK and performed the installation steps that are mentioned there.
 
 We assume you have a working setup for the
-[v3.3.5 SDK](https://docs.espressif.com/projects/esp-idf/en/v3.3.5/):
+[v4.2.2 SDK](https://docs.espressif.com/projects/esp-idf/en/v4.2.2/):
 
 - have a version of CMAKE installed
 - installed the xtensa
-  [toolchain](https://docs.espressif.com/projects/esp-idf/en/v3.3.5/get-started/index.html#setup-toolchain)
+  [toolchain](https://docs.espressif.com/projects/esp-idf/en/v4.2.2/get-started/index.html#setup-toolchain)
   and added it to your path
 
 <a name="adding-memfault"></a>
 
 ### Adding Memfault to the ESP-IDF SDK
 
 1. Delete the dummy esp-idf directory (if present) and clone a copy of the
-   v3.3.5 SDK.
+   v4.2.2 SDK.
 
    ```bash
    cd examples/esp32/
    rm -rf esp-idf
-   git clone -b v3.3.5 --recursive https://github.com/espressif/esp-idf.git esp-idf
+   git clone -b v4.2.2 --recursive https://github.com/espressif/esp-idf.git esp-idf
    cd esp-idf
    export IDF_TOOLS_PATH=$(pwd)
+   # you may need to install the sdk tools by running ./install.sh here
    source ./export.sh
    ```
 

ports/nxp/rt1021/src_reboot_tracking.c

@@ -0,0 +1,75 @@
+//! @file
+//!
+//! Copyright (c) Memfault, Inc.
+//! See License.txt for details
+//!
+//! A port for recovering reset reason information by reading the "System Reset
+//! Controller" (SRC)'s "Reset Status Register" (SRC_SRSR).
+//!
+//! More details can be found in the chapter "21.8.3 SRC Reset Status Register
+//! (SRC_SRSR)" in the RT1021 Reference Manual
+
+#include <inttypes.h>
+
+#include "MIMXRT1021.h"
+#include "memfault/components.h"
+#include "memfault/ports/reboot_reason.h"
+
+#if MEMFAULT_ENABLE_REBOOT_DIAG_DUMP
+#define MEMFAULT_PRINT_RESET_INFO(...) MEMFAULT_LOG_INFO(__VA_ARGS__)
+#else
+#define MEMFAULT_PRINT_RESET_INFO(...)
+#endif
+
+void memfault_reboot_reason_get(sResetBootupInfo *info) {
+  const uint32_t reset_cause = SRC->SRSR & (SRC_SRSR_W1C_BITS_MASK | SRC_SRSR_TEMPSENSE_RST_B_MASK);
+  eMemfaultRebootReason reset_reason = kMfltRebootReason_Unknown;
+
+  // clear the SRC Reset Status Register by writing a 1 to each bit
+#if MEMFAULT_REBOOT_REASON_CLEAR
+  SRC->SRSR = SRC_SRSR_W1C_BITS_MASK;
+#endif
+
+  MEMFAULT_LOG_INFO("Reset Reason, SRC_SRSR=0x%" PRIx32, reset_cause);
+
+  MEMFAULT_PRINT_RESET_INFO("Reset Cause: ");
+  if (reset_cause & SRC_SRSR_JTAG_SW_RST_MASK) {
+    MEMFAULT_PRINT_RESET_INFO(" Software");
+    reset_reason = kMfltRebootReason_SoftwareReset;
+  } else if (reset_cause & SRC_SRSR_TEMPSENSE_RST_B_MASK) {
+    MEMFAULT_PRINT_RESET_INFO(" Temp Sensor");
+    reset_reason = kMfltRebootReason_UnknownError;
+  } else if (reset_cause & SRC_SRSR_WDOG3_RST_B_MASK) {
+    MEMFAULT_PRINT_RESET_INFO(" HW Watchdog3");
+    reset_reason = kMfltRebootReason_HardwareWatchdog;
+  } else if (reset_cause & SRC_SRSR_WDOG_RST_B_MASK) {
+    MEMFAULT_PRINT_RESET_INFO(" HW Watchdog");
+    // reset_cause can be use to disambiguate the watchdog types
+    reset_reason = kMfltRebootReason_HardwareWatchdog;
+  } else if (reset_cause & SRC_SRSR_JTAG_RST_B_MASK) {
+    MEMFAULT_PRINT_RESET_INFO(" Debugger");
+    reset_reason = kMfltRebootReason_DebuggerHalted;
+  } else if (reset_cause & SRC_SRSR_IPP_USER_RESET_B_MASK) {
+    MEMFAULT_PRINT_RESET_INFO(" Button");
+    reset_reason = kMfltRebootReason_ButtonReset;
+  } else if (reset_cause & SRC_SRSR_CSU_RESET_B_MASK) {
+    // Central Security Unit triggered the reset (see Security Reference
+    // Manual)
+    MEMFAULT_PRINT_RESET_INFO(" CSU");
+    reset_reason = kMfltRebootReason_UnknownError;
+  } else if (reset_cause & SRC_SRSR_LOCKUP_SYSRESETREQ_MASK) {
+    MEMFAULT_PRINT_RESET_INFO(" Lockup");
+    reset_reason = kMfltRebootReason_Lockup;
+  } else if (reset_cause & SRC_SRSR_IPP_RESET_B_MASK) {
+    // TODO this might be equivalent to POR...
+    MEMFAULT_PRINT_RESET_INFO(" Pin Reset");
+    reset_reason = kMfltRebootReason_PinReset;
+  } else {
+    MEMFAULT_PRINT_RESET_INFO(" Unknown");
+  }
+
+  *info = (sResetBootupInfo){
+    .reset_reason_reg = reset_cause,
+    .reset_reason = reset_reason,
+  };
+}