ESPHome 2026.11.0b6
Loading...
Searching...
No Matches
debug_zephyr.cpp
Go to the documentation of this file.
1#include "debug_component.h"
2#ifdef USE_ZEPHYR
3#include <cinttypes>
4#include <climits>
6#include "esphome/core/log.h"
8#include <zephyr/drivers/hwinfo.h>
9#include <zephyr/kernel.h>
10#include <hal/nrf_power.h>
11#include <cstdint>
12#include <zephyr/storage/flash_map.h>
13
14#define BOOTLOADER_VERSION_REGISTER NRF_TIMER2->CC[0]
15
16namespace esphome::debug {
17
18ESPHOME_LOG_TAG(TAG, "debug");
19constexpr std::uintptr_t MBR_PARAM_PAGE_ADDR = 0xFFC;
20constexpr std::uintptr_t MBR_BOOTLOADER_ADDR = 0xFF8;
21
22static inline uint32_t read_mem_u32(uintptr_t addr) {
23 // NOLINTNEXTLINE(performance-no-int-to-ptr,clang-analyzer-core.FixedAddressDereference)
24 return *reinterpret_cast<volatile uint32_t *>(addr);
25}
26
27static inline uint8_t read_mem_u8(uintptr_t addr) {
28 // NOLINTNEXTLINE(performance-no-int-to-ptr,clang-analyzer-core.FixedAddressDereference)
29 return *reinterpret_cast<volatile uint8_t *>(addr);
30}
31
32// defines from https://github.com/adafruit/Adafruit_nRF52_Bootloader which prints those information
33constexpr uint32_t SD_MAGIC_NUMBER = 0x51B1E5DB;
34constexpr uintptr_t MBR_SIZE = 0x1000;
35constexpr uintptr_t SOFTDEVICE_INFO_STRUCT_OFFSET = 0x2000;
36constexpr uintptr_t SD_ID_OFFSET = SOFTDEVICE_INFO_STRUCT_OFFSET + 0x10;
38
39static inline bool is_sd_present() {
40 return read_mem_u32(SOFTDEVICE_INFO_STRUCT_OFFSET + MBR_SIZE + 4) == SD_MAGIC_NUMBER;
41}
42static inline uint32_t sd_id_get() {
44 return read_mem_u32(MBR_SIZE + SD_ID_OFFSET);
45 }
46 return 0;
47}
48static inline uint32_t sd_version_get() {
50 return read_mem_u32(MBR_SIZE + SD_VERSION_OFFSET);
51 }
52 return 0;
53}
54
55const char *DebugComponent::get_reset_reason_(std::span<char, RESET_REASON_BUFFER_SIZE> buffer) {
56 const char *buf = zephyr::get_reset_reason(buffer);
57 ESP_LOGD(TAG, "Reset Reason: %s", buf);
58 return buf;
59}
60
61const char *DebugComponent::get_wakeup_cause_(std::span<char, WAKEUP_CAUSE_BUFFER_SIZE> buffer) {
62 // Zephyr doesn't have detailed wakeup cause like ESP32
63 return "";
64}
65
66uint32_t DebugComponent::get_free_heap_() { return INT_MAX; }
67
68static void fa_cb(const struct flash_area *fa, void *user_data) {
69#if CONFIG_FLASH_MAP_LABELS
70 const char *fa_label = flash_area_label(fa);
71
72 if (fa_label == nullptr) {
73 fa_label = "-";
74 }
75 ESP_LOGCONFIG(TAG, "%2d 0x%0*" PRIxPTR " %-26s %-24.24s 0x%-10x 0x%-12x", (int) fa->fa_id,
76 sizeof(uintptr_t) * 2, (uintptr_t) fa->fa_dev, fa->fa_dev->name, fa_label, (uint32_t) fa->fa_off,
77 fa->fa_size);
78#else
79 ESP_LOGCONFIG(TAG, "%2d 0x%0*" PRIxPTR " %-26s 0x%-10x 0x%-12x", (int) fa->fa_id, sizeof(uintptr_t) * 2,
80 (uintptr_t) fa->fa_dev, fa->fa_dev->name, (uint32_t) fa->fa_off, fa->fa_size);
81#endif
82}
83
85#if CONFIG_FLASH_MAP_LABELS
86 ESP_LOGCONFIG(TAG, "ID | Device | Device Name "
87 "| Label | Offset | Size");
88 ESP_LOGCONFIG(TAG, "--------------------------------------------"
89 "-----------------------------------------------");
90#else
91 ESP_LOGCONFIG(TAG, "ID | Device | Device Name "
92 "| Offset | Size");
93 ESP_LOGCONFIG(TAG, "-----------------------------------------"
94 "------------------------------");
95#endif
96 flash_area_foreach(fa_cb, nullptr);
97}
98
99#ifdef ESPHOME_LOG_HAS_VERBOSE
100// Check if an nRF peripheral's ENABLE register indicates it is enabled.
101// periph: peripheral register prefix (e.g. USBD, UARTE, SPI)
102// reg: register block pointer (e.g. NRF_USBD, NRF_UARTE0)
103#define NRF_PERIPH_ENABLED(periph, reg) \
104 YESNO(((reg)->ENABLE & periph##_ENABLE_ENABLE_Msk) == (periph##_ENABLE_ENABLE_Enabled << periph##_ENABLE_ENABLE_Pos))
105
106// NOLINTBEGIN(clang-analyzer-core.FixedAddressDereference) -- nRF peripheral registers are MMIO at fixed addresses
107static void log_peripherals_info() {
108 // most peripherals are enabled only when in use so ESP_LOGV is enough
109 ESP_LOGV(TAG, "Peripherals status:");
110 ESP_LOGV(TAG, " USBD: %-3s| UARTE0: %-3s| UARTE1: %-3s| UART0: %-3s", //
111 NRF_PERIPH_ENABLED(USBD, NRF_USBD), NRF_PERIPH_ENABLED(UARTE, NRF_UARTE0),
112 NRF_PERIPH_ENABLED(UARTE, NRF_UARTE1), NRF_PERIPH_ENABLED(UART, NRF_UART0));
113 ESP_LOGV(TAG, " TWIS0: %-3s| TWIS1: %-3s| TWIM0: %-3s| TWIM1: %-3s", //
114 NRF_PERIPH_ENABLED(TWIS, NRF_TWIS0), NRF_PERIPH_ENABLED(TWIS, NRF_TWIS1),
115 NRF_PERIPH_ENABLED(TWIM, NRF_TWIM0), NRF_PERIPH_ENABLED(TWIM, NRF_TWIM1));
116 ESP_LOGV(TAG, " TWI0: %-3s| TWI1: %-3s| COMP: %-3s| CCM: %-3s", //
117 NRF_PERIPH_ENABLED(TWI, NRF_TWI0), NRF_PERIPH_ENABLED(TWI, NRF_TWI1), NRF_PERIPH_ENABLED(COMP, NRF_COMP),
118 NRF_PERIPH_ENABLED(CCM, NRF_CCM));
119 ESP_LOGV(TAG, " PDM: %-3s| SPIS0: %-3s| SPIS1: %-3s| SPIS2: %-3s", //
120 NRF_PERIPH_ENABLED(PDM, NRF_PDM), NRF_PERIPH_ENABLED(SPIS, NRF_SPIS0), NRF_PERIPH_ENABLED(SPIS, NRF_SPIS1),
121 NRF_PERIPH_ENABLED(SPIS, NRF_SPIS2));
122 ESP_LOGV(TAG, " SPIM0: %-3s| SPIM1: %-3s| SPIM2: %-3s| SPIM3: %-3s", //
123 NRF_PERIPH_ENABLED(SPIM, NRF_SPIM0), NRF_PERIPH_ENABLED(SPIM, NRF_SPIM1),
124 NRF_PERIPH_ENABLED(SPIM, NRF_SPIM2), NRF_PERIPH_ENABLED(SPIM, NRF_SPIM3));
125 ESP_LOGV(TAG, " SPI0: %-3s| SPI1: %-3s| SPI2: %-3s| SAADC: %-3s", //
126 NRF_PERIPH_ENABLED(SPI, NRF_SPI0), NRF_PERIPH_ENABLED(SPI, NRF_SPI1), NRF_PERIPH_ENABLED(SPI, NRF_SPI2),
127 NRF_PERIPH_ENABLED(SAADC, NRF_SAADC));
128 ESP_LOGV(TAG, " QSPI: %-3s| QDEC: %-3s| LPCOMP: %-3s| I2S: %-3s", //
129 NRF_PERIPH_ENABLED(QSPI, NRF_QSPI), NRF_PERIPH_ENABLED(QDEC, NRF_QDEC),
130 NRF_PERIPH_ENABLED(LPCOMP, NRF_LPCOMP), NRF_PERIPH_ENABLED(I2S, NRF_I2S));
131 ESP_LOGV(TAG, " PWM0: %-3s| PWM1: %-3s| PWM2: %-3s| PWM3: %-3s", //
132 NRF_PERIPH_ENABLED(PWM, NRF_PWM0), NRF_PERIPH_ENABLED(PWM, NRF_PWM1), NRF_PERIPH_ENABLED(PWM, NRF_PWM2),
133 NRF_PERIPH_ENABLED(PWM, NRF_PWM3));
134 ESP_LOGV(TAG, " AAR: %-3s| QSPI deep power-down:%-3s| CRYPTOCELL: %-3s", NRF_PERIPH_ENABLED(AAR, NRF_AAR),
135 YESNO((NRF_QSPI->IFCONFIG0 & QSPI_IFCONFIG0_DPMENABLE_Msk) ==
136 (QSPI_IFCONFIG0_DPMENABLE_Enable << QSPI_IFCONFIG0_DPMENABLE_Pos)),
137 YESNO((NRF_CRYPTOCELL->ENABLE & CRYPTOCELL_ENABLE_ENABLE_Msk) ==
138 (CRYPTOCELL_ENABLE_ENABLE_Enabled << CRYPTOCELL_ENABLE_ENABLE_Pos)));
139}
140// NOLINTEND(clang-analyzer-core.FixedAddressDereference)
141#undef NRF_PERIPH_ENABLED
142#endif
143
144static const char *regout0_to_str(uint32_t value) {
145 switch (value) {
146 case (UICR_REGOUT0_VOUT_DEFAULT):
147 return "1.8V (default)";
148 case (UICR_REGOUT0_VOUT_1V8):
149 return "1.8V";
150 case (UICR_REGOUT0_VOUT_2V1):
151 return "2.1V";
152 case (UICR_REGOUT0_VOUT_2V4):
153 return "2.4V";
154 case (UICR_REGOUT0_VOUT_2V7):
155 return "2.7V";
156 case (UICR_REGOUT0_VOUT_3V0):
157 return "3.0V";
158 case (UICR_REGOUT0_VOUT_3V3):
159 return "3.3V";
160 default:
161 break;
162 }
163 return "???V";
164}
165
166size_t DebugComponent::get_device_info_(std::span<char, DEVICE_INFO_BUFFER_SIZE> buffer, size_t pos) {
167 constexpr size_t size = DEVICE_INFO_BUFFER_SIZE;
168 char *buf = buffer.data();
169
170 // Main supply status
171 // NOLINTNEXTLINE(clang-analyzer-core.FixedAddressDereference) -- NRF_POWER is MMIO at a fixed address
172 auto regstatus = nrf_power_mainregstatus_get(NRF_POWER);
173 const char *supply_status = (regstatus == NRF_POWER_MAINREGSTATUS_NORMAL) ? "Normal voltage." : "High voltage.";
174 ESP_LOGD(TAG, "Main supply status: %s", supply_status);
175 pos = buf_append_str(buf, size, pos, "|Main supply status: ");
176 pos = buf_append_str(buf, size, pos, supply_status);
177
178 // Regulator stage 0
179 if (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_HIGH) {
180 const char *reg0_type = nrf_power_dcdcen_vddh_get(NRF_POWER) ? "DC/DC" : "LDO";
181 const char *reg0_voltage = regout0_to_str((NRF_UICR->REGOUT0 & UICR_REGOUT0_VOUT_Msk) >> UICR_REGOUT0_VOUT_Pos);
182 ESP_LOGD(TAG, "Regulator stage 0: %s, %s", reg0_type, reg0_voltage);
183 pos = buf_append_str(buf, size, pos, "|Regulator stage 0: ");
184 pos = buf_append_str(buf, size, pos, reg0_type);
185 pos = buf_append_str(buf, size, pos, ", ");
186 pos = buf_append_str(buf, size, pos, reg0_voltage);
187#ifdef USE_NRF52_REG0_VOUT
188 if ((NRF_UICR->REGOUT0 & UICR_REGOUT0_VOUT_Msk) >> UICR_REGOUT0_VOUT_Pos != USE_NRF52_REG0_VOUT) {
189 ESP_LOGE(TAG, "Regulator stage 0: expected %s", regout0_to_str(USE_NRF52_REG0_VOUT));
190 }
191#endif
192 } else {
193 ESP_LOGD(TAG, "Regulator stage 0: disabled");
194 pos = buf_append_str(buf, size, pos, "|Regulator stage 0: disabled");
195 }
196
197 // Regulator stage 1
198 const char *reg1_type = nrf_power_dcdcen_get(NRF_POWER) ? "DC/DC" : "LDO";
199 ESP_LOGD(TAG, "Regulator stage 1: %s", reg1_type);
200 pos = buf_append_str(buf, size, pos, "|Regulator stage 1: ");
201 pos = buf_append_str(buf, size, pos, reg1_type);
202
203 // USB power state
204 const char *usb_state;
205 if (nrf_power_usbregstatus_vbusdet_get(NRF_POWER)) {
206 if (nrf_power_usbregstatus_outrdy_get(NRF_POWER)) {
207 usb_state = "ready";
208 } else {
209 usb_state = "connected (regulator is not ready)";
210 }
211 } else {
212 usb_state = "disconnected";
213 }
214 ESP_LOGD(TAG, "USB power state: %s", usb_state);
215 pos = buf_append_str(buf, size, pos, "|USB power state: ");
216 pos = buf_append_str(buf, size, pos, usb_state);
217
218 // Power-fail comparator
219 bool enabled;
220 nrf_power_pof_thr_t pof_thr = nrf_power_pofcon_get(NRF_POWER, &enabled);
221 if (enabled) {
222 const char *pof_voltage;
223 switch (pof_thr) {
224 case POWER_POFCON_THRESHOLD_V17:
225 pof_voltage = "1.7V";
226 break;
227 case POWER_POFCON_THRESHOLD_V18:
228 pof_voltage = "1.8V";
229 break;
230 case POWER_POFCON_THRESHOLD_V19:
231 pof_voltage = "1.9V";
232 break;
233 case POWER_POFCON_THRESHOLD_V20:
234 pof_voltage = "2.0V";
235 break;
236 case POWER_POFCON_THRESHOLD_V21:
237 pof_voltage = "2.1V";
238 break;
239 case POWER_POFCON_THRESHOLD_V22:
240 pof_voltage = "2.2V";
241 break;
242 case POWER_POFCON_THRESHOLD_V23:
243 pof_voltage = "2.3V";
244 break;
245 case POWER_POFCON_THRESHOLD_V24:
246 pof_voltage = "2.4V";
247 break;
248 case POWER_POFCON_THRESHOLD_V25:
249 pof_voltage = "2.5V";
250 break;
251 case POWER_POFCON_THRESHOLD_V26:
252 pof_voltage = "2.6V";
253 break;
254 case POWER_POFCON_THRESHOLD_V27:
255 pof_voltage = "2.7V";
256 break;
257 case POWER_POFCON_THRESHOLD_V28:
258 pof_voltage = "2.8V";
259 break;
260 default:
261 pof_voltage = "???V";
262 break;
263 }
264
265 if (nrf_power_mainregstatus_get(NRF_POWER) == NRF_POWER_MAINREGSTATUS_HIGH) {
266 const char *vddh_voltage;
267 switch (nrf_power_pofcon_vddh_get(NRF_POWER)) {
268 case NRF_POWER_POFTHRVDDH_V27:
269 vddh_voltage = "2.7V";
270 break;
271 case NRF_POWER_POFTHRVDDH_V28:
272 vddh_voltage = "2.8V";
273 break;
274 case NRF_POWER_POFTHRVDDH_V29:
275 vddh_voltage = "2.9V";
276 break;
277 case NRF_POWER_POFTHRVDDH_V30:
278 vddh_voltage = "3.0V";
279 break;
280 case NRF_POWER_POFTHRVDDH_V31:
281 vddh_voltage = "3.1V";
282 break;
283 case NRF_POWER_POFTHRVDDH_V32:
284 vddh_voltage = "3.2V";
285 break;
286 case NRF_POWER_POFTHRVDDH_V33:
287 vddh_voltage = "3.3V";
288 break;
289 case NRF_POWER_POFTHRVDDH_V34:
290 vddh_voltage = "3.4V";
291 break;
292 case NRF_POWER_POFTHRVDDH_V35:
293 vddh_voltage = "3.5V";
294 break;
295 case NRF_POWER_POFTHRVDDH_V36:
296 vddh_voltage = "3.6V";
297 break;
298 case NRF_POWER_POFTHRVDDH_V37:
299 vddh_voltage = "3.7V";
300 break;
301 case NRF_POWER_POFTHRVDDH_V38:
302 vddh_voltage = "3.8V";
303 break;
304 case NRF_POWER_POFTHRVDDH_V39:
305 vddh_voltage = "3.9V";
306 break;
307 case NRF_POWER_POFTHRVDDH_V40:
308 vddh_voltage = "4.0V";
309 break;
310 case NRF_POWER_POFTHRVDDH_V41:
311 vddh_voltage = "4.1V";
312 break;
313 case NRF_POWER_POFTHRVDDH_V42:
314 vddh_voltage = "4.2V";
315 break;
316 default:
317 vddh_voltage = "???V";
318 break;
319 }
320 ESP_LOGD(TAG, "Power-fail comparator: %s, VDDH: %s", pof_voltage, vddh_voltage);
321 pos = buf_append_str(buf, size, pos, "|Power-fail comparator: ");
322 pos = buf_append_str(buf, size, pos, pof_voltage);
323 pos = buf_append_str(buf, size, pos, ", VDDH: ");
324 pos = buf_append_str(buf, size, pos, vddh_voltage);
325 } else {
326 ESP_LOGD(TAG, "Power-fail comparator: %s", pof_voltage);
327 pos = buf_append_str(buf, size, pos, "|Power-fail comparator: ");
328 pos = buf_append_str(buf, size, pos, pof_voltage);
329 }
330 } else {
331 ESP_LOGD(TAG, "Power-fail comparator: disabled");
332 pos = buf_append_str(buf, size, pos, "|Power-fail comparator: disabled");
333 }
334
335 auto package = [](uint32_t value) {
336 switch (value) {
337 case 0x2004:
338 return "QIxx - 7x7 73-pin aQFN";
339 case 0x2000:
340 return "QFxx - 6x6 48-pin QFN";
341 case 0x2005:
342 return "CKxx - 3.544 x 3.607 WLCSP";
343 default:
344 break;
345 }
346 return "Unspecified";
347 };
348
349 char mac_pretty[MAC_ADDRESS_PRETTY_BUFFER_SIZE];
351 ESP_LOGD(TAG,
352 "nRF debug info:\n"
353 " Code page size: %u, code size: %u, device id: 0x%08x%08x\n"
354 " Encryption root: 0x%08x%08x%08x%08x, Identity Root: 0x%08x%08x%08x%08x\n"
355 " Device address type: %s, address: %s\n"
356 " Part code: nRF%x, version: %c%c%c%c, package: %s\n"
357 " RAM: %ukB, Flash: %ukB, production test: %sdone",
358 NRF_FICR->CODEPAGESIZE, NRF_FICR->CODESIZE, NRF_FICR->DEVICEID[1], NRF_FICR->DEVICEID[0], NRF_FICR->ER[0],
359 NRF_FICR->ER[1], NRF_FICR->ER[2], NRF_FICR->ER[3], NRF_FICR->IR[0], NRF_FICR->IR[1], NRF_FICR->IR[2],
360 NRF_FICR->IR[3], (NRF_FICR->DEVICEADDRTYPE & 0x1 ? "Random" : "Public"), mac_pretty, NRF_FICR->INFO.PART,
361 NRF_FICR->INFO.VARIANT >> 24 & 0xFF, NRF_FICR->INFO.VARIANT >> 16 & 0xFF, NRF_FICR->INFO.VARIANT >> 8 & 0xFF,
362 NRF_FICR->INFO.VARIANT & 0xFF, package(NRF_FICR->INFO.PACKAGE), NRF_FICR->INFO.RAM, NRF_FICR->INFO.FLASH,
363 (NRF_FICR->PRODTEST[0] == 0xBB42319F ? "" : "not "));
364 bool n_reset_enabled = NRF_UICR->PSELRESET[0] == NRF_UICR->PSELRESET[1] &&
365 (NRF_UICR->PSELRESET[0] & UICR_PSELRESET_CONNECT_Msk) == UICR_PSELRESET_CONNECT_Connected
366 << UICR_PSELRESET_CONNECT_Pos;
367 ESP_LOGD(
368 TAG, " GPIO as NFC pins: %s, GPIO as nRESET pin: %s",
369 YESNO((NRF_UICR->NFCPINS & UICR_NFCPINS_PROTECT_Msk) == (UICR_NFCPINS_PROTECT_NFC << UICR_NFCPINS_PROTECT_Pos)),
370 YESNO(n_reset_enabled));
371 if (n_reset_enabled) {
372 uint8_t port = (NRF_UICR->PSELRESET[0] & UICR_PSELRESET_PORT_Msk) >> UICR_PSELRESET_PORT_Pos;
373 uint8_t pin = (NRF_UICR->PSELRESET[0] & UICR_PSELRESET_PIN_Msk) >> UICR_PSELRESET_PIN_Pos;
374 ESP_LOGD(TAG, " nRESET port P%u.%02u", port, pin);
375 }
376#ifdef USE_BOOTLOADER_MCUBOOT
377 ESP_LOGD(TAG, " Bootloader: mcuboot");
378#else
379 ESP_LOGD(TAG, " Bootloader: Adafruit, version %u.%u.%u", (BOOTLOADER_VERSION_REGISTER >> 16) & 0xFF,
380 (BOOTLOADER_VERSION_REGISTER >> 8) & 0xFF, BOOTLOADER_VERSION_REGISTER & 0xFF);
381 ESP_LOGD(TAG, " MBR bootloader addr 0x%08x, UICR bootloader addr 0x%08x", read_mem_u32(MBR_BOOTLOADER_ADDR),
382 NRF_UICR->NRFFW[0]);
383 ESP_LOGD(TAG, " MBR param page addr 0x%08x, UICR param page addr 0x%08x", read_mem_u32(MBR_PARAM_PAGE_ADDR),
384 NRF_UICR->NRFFW[1]);
385 if (is_sd_present()) {
386 uint32_t const sd_id = sd_id_get();
387 uint32_t const sd_version = sd_version_get();
388
389 uint32_t ver[3];
390 ver[0] = sd_version / 1000000;
391 ver[1] = (sd_version - ver[0] * 1000000) / 1000;
392 ver[2] = (sd_version - ver[0] * 1000000 - ver[1] * 1000);
393
394 ESP_LOGD(TAG, " SoftDevice: S%u %u.%u.%u", sd_id, ver[0], ver[1], ver[2]);
395#ifdef USE_SOFTDEVICE_ID
396#ifdef USE_SOFTDEVICE_VERSION
397 if (USE_SOFTDEVICE_ID != sd_id || USE_SOFTDEVICE_VERSION != ver[0]) {
398 ESP_LOGE(TAG, "Built for SoftDevice S%u %u.x.y. It may crash due to mismatch of bootloader version.",
399 USE_SOFTDEVICE_ID, USE_SOFTDEVICE_VERSION);
400 }
401#else
402 if (USE_SOFTDEVICE_ID != sd_id) {
403 ESP_LOGE(TAG, "Built for SoftDevice S%u. It may crash due to mismatch of bootloader version.", USE_SOFTDEVICE_ID);
404 }
405#endif
406#endif
407 }
408#endif
409 // 13 words of 8 hex digits, separated by spaces
410 char uicr_buf[13 * 9];
411 auto uicr = [&uicr_buf](volatile uint32_t *data, uint8_t size) {
412 size_t len = 0;
413 for (size_t i = 0; i < size; i++) {
414 len = buf_append_printf(uicr_buf, sizeof(uicr_buf), len, i > 0 ? " %08" PRIX32 : "%08" PRIX32, data[i]);
415 }
416 return uicr_buf;
417 };
418 ESP_LOGD(TAG, " NRFFW %s", uicr(NRF_UICR->NRFFW, 13));
419 ESP_LOGD(TAG, " NRFHW %s", uicr(NRF_UICR->NRFHW, 12));
420#ifdef ESPHOME_LOG_HAS_VERBOSE
421 log_peripherals_info();
422#endif
423 return pos;
424}
425
426// The Python side enables the statistics only for a verbose logger
427#ifdef CONFIG_SCHED_THREAD_USAGE_ANALYSIS
428static void log_thread_usage(const struct k_thread *thread, void *user_data) {
429 const auto cpu_cycles = *static_cast<const uint64_t *>(user_data);
430 auto *tid = const_cast<k_tid_t>(thread); // NOLINT(cppcoreguidelines-pro-type-const-cast)
431 k_thread_runtime_stats_t stats;
432 if (k_thread_runtime_stats_get(tid, &stats) != 0)
433 return;
434 char state[32];
435 const char *name = k_thread_name_get(tid);
436 ESP_LOGV(TAG, " %-16s prio %3d %-10s %3u%% peak %" PRIu32 " avg %" PRIu32, name != nullptr ? name : "?",
437 thread->base.prio, k_thread_state_str(tid, state, sizeof(state)),
438 static_cast<unsigned>(stats.execution_cycles * 100 / cpu_cycles),
439 static_cast<uint32_t>(k_cyc_to_us_floor64(stats.peak_cycles)),
440 static_cast<uint32_t>(k_cyc_to_us_floor64(stats.average_cycles)));
441}
442#endif
443
444void DebugComponent::update_platform_() {
445#ifdef CONFIG_SCHED_THREAD_USAGE_ANALYSIS
446 k_thread_runtime_stats_t cpu;
447 if (k_thread_runtime_stats_all_get(&cpu) != 0 || cpu.execution_cycles == 0)
448 return;
449 ESP_LOGV(TAG, "Thread CPU usage since boot (peak and average us per time slice):");
450 // The unlocked walk lets the log output inside the callback block
451 k_thread_foreach_unlocked(log_thread_usage, &cpu.execution_cycles);
452#endif
453}
454
455} // namespace esphome::debug
456#endif
Heap-allocating helper functions.
const char * get_wakeup_cause_(std::span< char, WAKEUP_CAUSE_BUFFER_SIZE > buffer)
void log_partition_info_()
Logs information about the device's partition table.
size_t get_device_info_(std::span< char, DEVICE_INFO_BUFFER_SIZE > buffer, size_t pos)
const char * get_reset_reason_(std::span< char, RESET_REASON_BUFFER_SIZE > buffer)
bool state
Definition fan.h:2
uint32_t buffer
Definition gif.cpp:50
constexpr std::uintptr_t MBR_PARAM_PAGE_ADDR
constexpr uintptr_t SD_ID_OFFSET
ESPHOME_LOG_TAG(TAG, "debug")
constexpr std::uintptr_t MBR_BOOTLOADER_ADDR
constexpr uintptr_t MBR_SIZE
constexpr uintptr_t SOFTDEVICE_INFO_STRUCT_OFFSET
constexpr uintptr_t SD_VERSION_OFFSET
constexpr uint32_t SD_MAGIC_NUMBER
std::span< const uint8_t > data
const char * get_reset_reason(std::span< char, RESET_REASON_BUFFER_SIZE > buffer)
size_t buf_append_str(char *buf, size_t size, size_t pos, const char *str)
Safely append a string to buffer, returning new position (capped at size).
Definition helpers.h:1382
uint32_t value
Definition hal.cpp:41
const void size_t len
Definition hal.h:68
uint16_t size
Definition helpers.cpp:34
size_t size_t pos
Definition helpers.h:1333
const char * get_mac_address_pretty_into_buffer(std::span< char, MAC_ADDRESS_PRETTY_BUFFER_SIZE > buf)
Get the device MAC address into the given buffer, in colon-separated uppercase hex notation.
Definition helpers.cpp:854
static void uint32_t