Memfault Firmware SDK 1.21.0 (Build 12963)

Author: Memfault Inc

CHANGELOG.md

@@ -6,6 +6,60 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to
 [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.21.0] - 2025-03-06
+
+### 📈 Added
+
+- General:
+
+  - Logs captured by Memfault now include a timestamp by default, when the
+    platform implements `memfault_platform_time_get_current()`. This feature can
+    be disabled by setting `#define MEMFAULT_LOG_TIMESTAMPS_ENABLE 0` in
+    `memfault_platform_config.h`.
+
+- ESP-IDF:
+
+  - Add new built-in Wi-Fi metrics:
+
+    - `wifi_primary_channel` - the primary channel ID of the associated Wi-Fi
+      access point
+    - `wifi_auth_mode` - the authentication mode of the associated Wi-Fi access
+      point, for example `WPA2_PSK`
+    - `wifi_standard_version` - the Wi-Fi version of the associated Wi-Fi access
+      point, for example `802.11n`
+
+    These metrics are enabled by default and can be disabled (along with other
+    built-in Wi-Fi metrics) with the Kconfig option
+    `CONFIG_MEMFAULT_ESP_WIFI_METRICS`
+
+### 🛠️ Changed
+
+- ESP-IDF:
+
+  - Support cases where the `IDF_VER` build variable is set to
+    `"HEAD-HASH-NOTFOUND"` (i.e. using an ESP-IDF SDK that is not a git repo),
+    when setting the built-in metric `MemfaultSdkMetric_os_version`. In this
+    case, the value is taken from the `ESP_IDF_VERSION_x` macros, which are less
+    precise.
+
+  - Use more specific Memfault reset reason codes for these watchdog reset
+    types, previously all categorized as `HardwareWatchdog`
+
+    - `ESP_RST_INT_WDT` -> `SoftwareWatchdog`
+    - `ESP_RST_TASK_WDT` -> `TaskWatchdog`
+    - `ESP_RST_WDT` (RTC watchdog, the real hardware watchdog), stays as
+      `HardwareWatchdog`
+
+### 🐛 Fixed
+
+- ESP-IDF:
+
+  - Correctly set the Memfault Firmware SDK version inside the
+    [espressif component](https://components.espressif.com/components/memfault/memfault-firmware-sdk)
+    version of the SDK. Prior to this fix, the SDK version reports as
+    `"MemfaultSdkMetric_sdk_version": "0.0.0"`. No change to the SDK, only a
+    tooling/release change.
+
 ## [1.20.0] - 2025-02-06
 
 ### 📈 Added
@@ -142,6 +196,19 @@ and this project adheres to
     Thanks to [@JordanYates](https://github.com/JordanYates) for reporting this
     issue in [#81](https://github.com/memfault/memfault-firmware-sdk/issues/85)!
 
+  - Fix a configuration issue when building for any of the following parts, but
+    NOT using nRF-Connect SDK (i.e. using Zephyr instead):
+
+    - SOC_SERIES_NRF52X
+    - SOC_SERIES_NRF53X
+    - SOC_SERIES_NRF54LX
+    - SOC_SERIES_NRF91X
+
+    The Memfault SDK now correctly enables nRF-Connect-SDK-specific
+    functionality ONLY when that SDK is included as a Zephyr module. Thanks to
+    [@JordanYates](https://github.com/JordanYates) for reporting this issue in
+    [#81](https://github.com/memfault/memfault-firmware-sdk/issues/89)!
+
 - nRF Connect SDK:
 
   - Remove use of child and parent image functionality in the nRF9160 sample

VERSION

@@ -1,3 +1,3 @@
-BUILD ID: 12555
-GIT COMMIT: 7fcaa50c87
-VERSION: 1.20.0
+BUILD ID: 12963
+GIT COMMIT: 3dabeb442c
+VERSION: 1.21.0

components/core/src/memfault_build_id.c

@@ -30,19 +30,28 @@
       #include <version.h>
       #define MEMFAULT_OS_VERSION_NAME "zephyr"
       #define MEMFAULT_OS_VERSION_STRING KERNEL_VERSION_STRING
-    #endif /* __has_include("ncs_version.h") */
+    #endif  // __has_include("ncs_version.h")
 
   #elif defined(ESP_PLATFORM)
-    // ESP-IDF, use the command-line defined IDF_VER string
+    // ESP-IDF, prefer the command-line provided IDF_VER if set. In rare cases,
+    // IDF_VER will be set to "HEAD-HASH-NOTFOUND", in which case we fall back
+    // to the version provided by esp_idf_version.h.
     #define MEMFAULT_OS_VERSION_NAME "esp-idf"
-    #define MEMFAULT_OS_VERSION_STRING IDF_VER
+    #define STRINGIFY(x) #x
+    #define XSTRINGIFY(s) STRINGIFY(s)
+    #include "esp_idf_version.h"
+    #define MEMFAULT_OS_VERSION_STRING                          \
+      ((__builtin_strcmp(IDF_VER, "HEAD-HASH-NOTFOUND") != 0) ? \
+         (IDF_VER) :                                            \
+         ("" XSTRINGIFY(ESP_IDF_VERSION_MAJOR) "." XSTRINGIFY(  \
+           ESP_IDF_VERSION_MINOR) "." XSTRINGIFY(ESP_IDF_VERSION_PATCH) ""))
+
   #else
     // No OS version information available
     #define MEMFAULT_OS_VERSION_NAME ""
     #define MEMFAULT_OS_VERSION_STRING ""
-  #endif /* defined(__ZEPHYR__) */
-#endif   /* defined(MEMFAULT_OS_VERSION_NAME) ^ defined(MEMFAULT_OS_VERSION_STRING) \
-          */
+  #endif  // defined(__ZEPHYR__)
+#endif    // defined(MEMFAULT_OS_VERSION_NAME) ^ defined(MEMFAULT_OS_VERSION_STRING)
 
 #if MEMFAULT_USE_GNU_BUILD_ID
 

components/core/src/memfault_log.c

@@ -21,6 +21,7 @@
 #include "memfault/core/math.h"
 #include "memfault/core/platform/debug_log.h"
 #include "memfault/core/platform/overrides.h"
+#include "memfault/core/platform/system_time.h"
 #include "memfault/core/sdk_assert.h"
 #include "memfault/util/base64.h"
 #include "memfault/util/circular_buffer.h"
@@ -97,15 +98,17 @@ bool memfault_log_get_regions(sMemfaultLogRegions *regions) {
   return true;
 }
 
-static uint8_t prv_build_header(eMemfaultPlatformLogLevel level, eMemfaultLogRecordType type) {
+static uint8_t prv_build_header(eMemfaultPlatformLogLevel level, eMemfaultLogRecordType type,
+                                bool timestamped) {
   MEMFAULT_STATIC_ASSERT(kMemfaultPlatformLogLevel_NumLevels <= 8,
                          "Number of log levels exceed max number that log module can track");
   MEMFAULT_STATIC_ASSERT(kMemfaultLogRecordType_NumTypes <= 2,
                          "Number of log types exceed max number that log module can track");
 
   const uint8_t level_field = (level << MEMFAULT_LOG_HDR_LEVEL_POS) & MEMFAULT_LOG_HDR_LEVEL_MASK;
   const uint8_t type_field = (type << MEMFAULT_LOG_HDR_TYPE_POS) & MEMFAULT_LOG_HDR_TYPE_MASK;
-  return level_field | type_field;
+  const uint8_t timestamped_field = timestamped ? MEMFAULT_LOG_HDR_TIMESTAMPED_MASK : 0;
+  return level_field | type_field | timestamped_field;
 }
 
 void memfault_log_set_min_save_level(eMemfaultPlatformLogLevel min_log_level) {
@@ -225,10 +228,21 @@ static bool prv_read_log_iter_callback(sMfltLogIterator *iter) {
     return false;
   }
 
-  ctx->log->msg[iter->entry.len] = '\0';
   ctx->log->level = memfault_log_get_level_from_hdr(iter->entry.hdr);
   ctx->log->type = memfault_log_get_type_from_hdr(iter->entry.hdr);
   ctx->log->msg_len = iter->entry.len;
+#if MEMFAULT_LOG_TIMESTAMPS_ENABLE
+  const size_t timestamp_len = sizeof(ctx->log->timestamp);
+  if (memfault_log_hdr_is_timestamped(iter->entry.hdr) && (iter->entry.len >= timestamp_len)) {
+    memcpy(&ctx->log->timestamp, ctx->log->msg, timestamp_len);
+    // shift the message over to remove the timestamp
+    memmove(ctx->log->msg, &ctx->log->msg[timestamp_len], ctx->log->msg_len - timestamp_len);
+    ctx->log->msg_len -= timestamp_len;
+  } else {
+    ctx->log->timestamp = 0;
+  }
+#endif
+  ctx->log->msg[ctx->log->msg_len] = '\0';
   ctx->has_log = true;
   return false;
 }
@@ -402,8 +416,25 @@ static void prv_log_save(eMemfaultPlatformLogLevel level, const void *log, size_
   }
 
   bool log_written = false;
-  const size_t truncated_log_len = MEMFAULT_MIN(log_len, MEMFAULT_LOG_MAX_LINE_SAVE_LEN);
-  const size_t bytes_needed = sizeof(sMfltRamLogEntry) + truncated_log_len;
+#if MEMFAULT_LOG_TIMESTAMPS_ENABLE
+  sMemfaultCurrentTime timestamp;
+  const bool timestamped = memfault_platform_time_get_current(&timestamp);
+  uint32_t timestamp_val;  // forward declaration for sizeof()
+  const size_t timestamped_len = timestamped ? sizeof(timestamp_val) : 0;
+#else
+  const bool timestamped = false;
+  const size_t timestamped_len = 0;
+#endif
+
+  // maximum msg length is truncated by timestamp, when enabled and valid.
+  const size_t max_log_msg_len = MEMFAULT_LOG_MAX_LINE_SAVE_LEN - timestamped_len;
+
+  const size_t truncated_log_len = MEMFAULT_MIN(log_len, max_log_msg_len);
+  // total log length for the log entry .len field includes the timestamp.
+  const uint8_t total_log_len = (uint8_t)(truncated_log_len + timestamped_len);
+  // circular buffer space needed includes the metadata (hdr + len) and msg
+  const size_t bytes_needed = sizeof(sMfltRamLogEntry) + total_log_len;
+
   if (should_lock) {
     memfault_lock();
   }
@@ -413,10 +444,16 @@ static void prv_log_save(eMemfaultPlatformLogLevel level, const void *log, size_
     if (space_free) {
       s_memfault_ram_logger.recorded_msg_count++;
       sMfltRamLogEntry entry = {
-        .len = (uint8_t)truncated_log_len,
-        .hdr = prv_build_header(level, log_type),
+        .hdr = prv_build_header(level, log_type, timestamped),
+        .len = total_log_len,
       };
       memfault_circular_buffer_write(circ_bufp, &entry, sizeof(entry));
+#if MEMFAULT_LOG_TIMESTAMPS_ENABLE
+      if (timestamped) {
+        timestamp_val = timestamp.info.unix_timestamp_secs;
+        memfault_circular_buffer_write(circ_bufp, &timestamp_val, sizeof(timestamp_val));
+      }
+#endif
       memfault_circular_buffer_write(circ_bufp, log, truncated_log_len);
       log_written = true;
     } else {

components/core/src/memfault_log_data_source.c

@@ -155,7 +155,7 @@ static bool prv_encode(sMemfaultCborEncoder *encoder, void *iter) {
   }
   // To save space, all logs are encoded into a single array (as opposed to using a map or
   // array per log):
-  const size_t elements_per_log = 2;  // level, msg
+  const size_t elements_per_log = 2;  // hdr, msg
   if (!memfault_cbor_encode_array_begin(encoder, elements_per_log * ctx->num_logs)) {
     return false;
   }

components/core/src/memfault_log_private.h

@@ -27,11 +27,12 @@ extern "C" {
 // standard.
 //
 // Header Layout:
-// 0brsxx.tlll
+// 0brsxT.tlll
 // where
 //  r = read (1 if the message has been read, 0 otherwise)
 //  s = sent (1 if the message has been sent, 0 otherwise)
-//  x = rsvd
+//  x = reserved
+//  T = timestamped (1 if the first 4 bytes of the message is a timestamp, 0 otherwise)
 //  t = type (0 = formatted log, 1 = compact log)
 //  l = log level (eMemfaultPlatformLogLevel)
 
@@ -41,6 +42,7 @@ extern "C" {
 #define MEMFAULT_LOG_HDR_TYPE_MASK 0x08u
 #define MEMFAULT_LOG_HDR_READ_MASK 0x80u  // Log has been read through memfault_log_read()
 #define MEMFAULT_LOG_HDR_SENT_MASK 0x40u  // Log has been sent through g_memfault_log_data_source
+#define MEMFAULT_LOG_HDR_TIMESTAMPED_MASK 0x10u  // Log payload includes a leading 4-byte timestamp
 
 static inline eMemfaultPlatformLogLevel memfault_log_get_level_from_hdr(uint8_t hdr) {
   return (eMemfaultPlatformLogLevel)((hdr & MEMFAULT_LOG_HDR_LEVEL_MASK) >>
@@ -51,16 +53,37 @@ static inline eMemfaultLogRecordType memfault_log_get_type_from_hdr(uint8_t hdr)
   return (eMemfaultLogRecordType)((hdr & MEMFAULT_LOG_HDR_TYPE_MASK) >> MEMFAULT_LOG_HDR_TYPE_POS);
 }
 
+static inline bool memfault_log_hdr_is_timestamped(uint8_t hdr) {
+  return (hdr & MEMFAULT_LOG_HDR_TIMESTAMPED_MASK) != 0;
+}
+
+// A log entry has the following layout:
+//
+// [ 1 byte ][ 1 byte ][ len bytes ]
+// [ hdr    ][ len    ][ msg       ]
+//
+// If the timestamped bit is set in the header, the first 4 bytes of the message
+// will be a little-endian UNIX timestamp:
+//
+// [ 1 byte ][ 1 byte ][ 4 bytes   ][ len - 4 bytes]
+// [ hdr    ][ len    ][ timestamp ][ msg          ]
+
 typedef MEMFAULT_PACKED_STRUCT {
   // data about the message stored (details below)
   uint8_t hdr;
   // the length of the msg
   uint8_t len;
-  // underlying message
+  // underlying message. note that if the timestamped bit is set, the first 4
+  // bytes of the message will be the little-endian UNIX timestamp.
   uint8_t msg[];
 }
 sMfltRamLogEntry;
 
+// In the current version of the log entry structure, the maximum length of a
+// log message is 255 bytes due to the width of the 'len' field.
+MEMFAULT_STATIC_ASSERT(MEMFAULT_LOG_MAX_LINE_SAVE_LEN <= 255,
+                       "MEMFAULT_LOG_MAX_LINE_SAVE_LEN must be <= 255");
+
 typedef struct {
   uint32_t read_offset;
   void *user_ctx;

components/include/memfault/core/log.h

@@ -144,6 +144,10 @@ typedef struct {
   eMemfaultLogRecordType type;
   // the length of the msg (not including NUL character)
   uint32_t msg_len;
+#if MEMFAULT_LOG_TIMESTAMPS_ENABLE
+  // if non-zero, the timestamp of the log
+  uint32_t timestamp;
+#endif
   // the message to print which will always be NUL terminated when a preformatted log is returned
   // (so it is always safe to call printf without copying the log into another buffer yourself)
   char msg[MEMFAULT_LOG_MAX_LINE_SAVE_LEN + 1 /* '\0' */];

components/include/memfault/default_config.h

@@ -165,6 +165,12 @@ extern "C" {
   #define MEMFAULT_COMPACT_LOG_ENABLE 0
 #endif
 
+//! Enable log line timestamps, when memfault_platform_time_get_current() is
+//! available.
+#ifndef MEMFAULT_LOG_TIMESTAMPS_ENABLE
+  #define MEMFAULT_LOG_TIMESTAMPS_ENABLE 1
+#endif
+
 //! Controls whether or not multiple events will be batched into a single
 //! message when reading information via the event storage data source.
 //!

components/include/memfault/version.h

@@ -20,8 +20,8 @@ typedef struct {
 } sMfltSdkVersion;
 
 #define MEMFAULT_SDK_VERSION \
-  { .major = 1, .minor = 20, .patch = 0 }
-#define MEMFAULT_SDK_VERSION_STR "1.20.0"
+  { .major = 1, .minor = 21, .patch = 0 }
+#define MEMFAULT_SDK_VERSION_STR "1.21.0"
 
 #ifdef __cplusplus
 }

examples/freertos/src/console.c

@@ -154,6 +154,20 @@ static int prv_leak_memory(int argc, char *argv[]) {
   return 0;
 }
 
+static int prv_assert_with_reason(int argc, char *argv[]) {
+  eMemfaultRebootReason reason = kMfltRebootReason_Assert;
+  if (argc >= 2) {
+    // integer argument that should be used for trace reason
+    reason = (eMemfaultRebootReason)strtoul(argv[1], NULL, 0);
+  }
+
+  MEMFAULT_LOG_ERROR("Triggering assert with reason code %d", reason);
+
+  MEMFAULT_ASSERT_WITH_REASON(0, reason);
+
+  return 0;
+}
+
 static const sMemfaultShellCommand s_freertos_example_shell_extension_list[] = {
   {
     .command = "freertos_vassert",
@@ -189,6 +203,11 @@ static const sMemfaultShellCommand s_freertos_example_shell_extension_list[] = {
     .command = "leak",
     .handler = prv_leak_memory,
     .help = "Allocate memory and leak it. Usage: leak <num_bytes>",
+  },
+  {
+    .command = "assert_with_reason",
+    .handler = prv_assert_with_reason,
+    .help = "Execute an assert with a custom reason code",
   }
 };
 #endif

ports/esp_idf/memfault/common/memfault_platform_core.c

@@ -103,7 +103,11 @@ static void prv_record_reboot_reason(void) {
       reboot_reason = kMfltRebootReason_SoftwareReset;
       break;
     case ESP_RST_INT_WDT:
+      reboot_reason = kMfltRebootReason_SoftwareWatchdog;
+      break;
     case ESP_RST_TASK_WDT:
+      reboot_reason = kMfltRebootReason_TaskWatchdog;
+      break;
     case ESP_RST_WDT:
       reboot_reason = kMfltRebootReason_HardwareWatchdog;
       break;