653 lines
No EOL
19 KiB
C
653 lines
No EOL
19 KiB
C
/*
|
|
* This program source code file is part of the KTag project, a DIY laser tag
|
|
* game with customizable features and wide interoperability.
|
|
*
|
|
* 🛡 <https://ktag.clubk.club> 🃞
|
|
*
|
|
* Copyright © 2026 Joseph P. Kearney and the KTag developers.
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify it under
|
|
* the terms of the GNU Affero General Public License as published by the Free
|
|
* Software Foundation, either version 3 of the License, or (at your option) any
|
|
* later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful, but WITHOUT
|
|
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
|
|
* FOR A PARTICULAR PURPOSE. See the GNU Affero General Public License for more
|
|
* details.
|
|
*
|
|
* There should be a copy of the GNU Affero General Public License in the LICENSE
|
|
* file in the root of this repository. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#include "esp_console.h"
|
|
#include "esp_system.h"
|
|
#include "esp_chip_info.h"
|
|
#include "esp_flash.h"
|
|
#include "esp_partition.h"
|
|
#include "esp_ota_ops.h"
|
|
#include "esp_app_desc.h"
|
|
#include "esp_idf_version.h"
|
|
#include "esp_pm.h"
|
|
#include "esp_sleep.h"
|
|
#include "esp_timer.h"
|
|
#include "esp_heap_caps.h"
|
|
#include "esp_mac.h"
|
|
#include "esp_netif.h"
|
|
#include "esp_core_dump.h"
|
|
#include "nvs_flash.h"
|
|
#include "linenoise/linenoise.h"
|
|
#include "freertos/FreeRTOS.h"
|
|
#include "freertos/task.h"
|
|
#include "git_version.h" // Generated during the build process.
|
|
#include <string.h>
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
#include <SystemK.h>
|
|
|
|
static void print_usage(void)
|
|
{
|
|
printf(
|
|
"Usage:\n"
|
|
" system chip-info - Show chip and system information\n"
|
|
" system uptime - Display system uptime\n"
|
|
" system tasks - List FreeRTOS tasks\n"
|
|
" system reset-reason - Show last reset reason\n"
|
|
" system RAM - Display heap memory usage\n"
|
|
" system flash - Show flash information\n"
|
|
" system partition - List partition table\n"
|
|
" system heap-caps - Show heap by capability\n"
|
|
" system stats - Combined system statistics\n"
|
|
" system backtrace - Print current backtrace\n"
|
|
" system coredump - Check coredump status\n"
|
|
" system sleep <ms> - Enter light sleep\n"
|
|
" system mac - Show MAC addresses\n"
|
|
" system hostname [name]- Show/set hostname\n"
|
|
" system version - Show firmware version\n"
|
|
" system idf-version - Show ESP-IDF version\n"
|
|
" system factory-reset - Clear NVS and restart\n"
|
|
" system reboot - Reboot the device\n");
|
|
}
|
|
|
|
static int system_cmd_chip_info(void)
|
|
{
|
|
esp_chip_info_t chip_info;
|
|
esp_chip_info(&chip_info);
|
|
|
|
printf("Chip Information:\n");
|
|
printf(" Model: %s\n", CONFIG_IDF_TARGET);
|
|
printf(" Cores: %d\n", chip_info.cores);
|
|
printf(" Revision: %d\n", chip_info.revision);
|
|
printf(" Features: %s%s%s%s\n",
|
|
(chip_info.features & CHIP_FEATURE_WIFI_BGN) ? "WiFi " : "",
|
|
(chip_info.features & CHIP_FEATURE_BT) ? "BT " : "",
|
|
(chip_info.features & CHIP_FEATURE_BLE) ? "BLE " : "",
|
|
(chip_info.features & CHIP_FEATURE_IEEE802154) ? "802.15.4 " : "");
|
|
|
|
uint32_t flash_size;
|
|
if (esp_flash_get_size(NULL, &flash_size) == ESP_OK)
|
|
{
|
|
printf(" Flash: %lu MB %s\n",
|
|
flash_size / (1024 * 1024),
|
|
(chip_info.features & CHIP_FEATURE_EMB_FLASH) ? "(embedded)" : "(external)");
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int system_cmd_uptime(void)
|
|
{
|
|
int64_t uptime_us = esp_timer_get_time();
|
|
int64_t uptime_s = uptime_us / 1000000;
|
|
|
|
int days = uptime_s / 86400;
|
|
int hours = (uptime_s % 86400) / 3600;
|
|
int minutes = (uptime_s % 3600) / 60;
|
|
int seconds = uptime_s % 60;
|
|
|
|
printf("Uptime: %d days, %02d:%02d:%02d\n", days, hours, minutes, seconds);
|
|
printf(" (%lld seconds)\n", uptime_s);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int system_cmd_tasks(void)
|
|
{
|
|
#if (configUSE_TRACE_FACILITY == 1)
|
|
uint32_t task_count = uxTaskGetNumberOfTasks();
|
|
TaskStatus_t *task_array = malloc(task_count * sizeof(TaskStatus_t));
|
|
|
|
if (task_array == NULL)
|
|
{
|
|
printf("Failed to allocate memory for task list\n");
|
|
return 1;
|
|
}
|
|
|
|
uint32_t total_runtime;
|
|
task_count = uxTaskGetSystemState(task_array, task_count, &total_runtime);
|
|
|
|
printf("Tasks (%lu total):\n", task_count);
|
|
printf("%-16s %5s %8s %5s", "Name", "State", "Priority", "Stack");
|
|
#if (configGENERATE_RUN_TIME_STATS == 1)
|
|
printf(" %s", "CPU%%");
|
|
#endif
|
|
printf("\n");
|
|
printf("-----------------------------------------------------------\n");
|
|
|
|
for (uint32_t i = 0; i < task_count; i++)
|
|
{
|
|
const char *state_str;
|
|
switch (task_array[i].eCurrentState)
|
|
{
|
|
case eRunning: state_str = "RUN "; break;
|
|
case eReady: state_str = "READY"; break;
|
|
case eBlocked: state_str = "BLOCK"; break;
|
|
case eSuspended: state_str = "SUSP "; break;
|
|
case eDeleted: state_str = "DEL "; break;
|
|
default: state_str = "? "; break;
|
|
}
|
|
|
|
uint32_t stack_remaining = task_array[i].usStackHighWaterMark;
|
|
|
|
printf("%-16s %5s %8u %5lu",
|
|
task_array[i].pcTaskName,
|
|
state_str,
|
|
task_array[i].uxCurrentPriority,
|
|
stack_remaining);
|
|
|
|
#if (configGENERATE_RUN_TIME_STATS == 1)
|
|
float cpu_percent = 0.0;
|
|
if (total_runtime > 0)
|
|
{
|
|
cpu_percent = (100.0 * task_array[i].ulRunTimeCounter) / total_runtime;
|
|
}
|
|
printf(" %5.1f%%", cpu_percent);
|
|
#endif
|
|
printf("\n");
|
|
}
|
|
|
|
free(task_array);
|
|
#else
|
|
printf("Task listing not available (configUSE_TRACE_FACILITY not enabled)\n");
|
|
printf("Enable in menuconfig: Component config -> FreeRTOS -> Kernel\n");
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
static int system_cmd_reset_reason(void)
|
|
{
|
|
esp_reset_reason_t reason = esp_reset_reason();
|
|
|
|
printf("Reset reason: ");
|
|
switch (reason)
|
|
{
|
|
case ESP_RST_UNKNOWN: printf("Unknown\n"); break;
|
|
case ESP_RST_POWERON: printf("Power-on reset\n"); break;
|
|
case ESP_RST_EXT: printf("External pin reset\n"); break;
|
|
case ESP_RST_SW: printf("Software reset\n"); break;
|
|
case ESP_RST_PANIC: printf("Exception/panic\n"); break;
|
|
case ESP_RST_INT_WDT: printf("Interrupt watchdog\n"); break;
|
|
case ESP_RST_TASK_WDT: printf("Task watchdog\n"); break;
|
|
case ESP_RST_WDT: printf("Other watchdog\n"); break;
|
|
case ESP_RST_DEEPSLEEP: printf("Deep sleep reset\n"); break;
|
|
case ESP_RST_BROWNOUT: printf("Brownout reset\n"); break;
|
|
case ESP_RST_SDIO: printf("SDIO reset\n"); break;
|
|
default: printf("Code %d\n", reason); break;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int system_cmd_ram(void)
|
|
{
|
|
size_t free_heap = esp_get_free_heap_size();
|
|
size_t min_free_heap = esp_get_minimum_free_heap_size();
|
|
size_t largest_block = heap_caps_get_largest_free_block(MALLOC_CAP_DEFAULT);
|
|
|
|
printf("Heap Memory:\n");
|
|
printf(" Free: %u bytes (%.2f KB)\n", free_heap, free_heap / 1024.0);
|
|
printf(" Minimum free: %u bytes (%.2f KB)\n", min_free_heap, min_free_heap / 1024.0);
|
|
printf(" Largest free block: %u bytes (%.2f KB)\n", largest_block, largest_block / 1024.0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int system_cmd_flash(void)
|
|
{
|
|
uint32_t flash_size;
|
|
if (esp_flash_get_size(NULL, &flash_size) != ESP_OK)
|
|
{
|
|
printf("Failed to get flash size\n");
|
|
return 1;
|
|
}
|
|
|
|
printf("Flash Information:\n");
|
|
printf(" Total size: %lu bytes (%.2f MB)\n", flash_size, flash_size / (1024.0 * 1024.0));
|
|
|
|
const esp_partition_t *running = esp_ota_get_running_partition();
|
|
if (running)
|
|
{
|
|
printf(" Running partition: %s (offset 0x%lx, size %lu KB)\n",
|
|
running->label, running->address, running->size / 1024);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int system_cmd_partition(void)
|
|
{
|
|
printf("Partition Table:\n");
|
|
printf("%-16s %-10s %-10s %10s %10s\n", "Label", "Type", "SubType", "Offset", "Size");
|
|
printf("------------------------------------------------------------------------\n");
|
|
|
|
esp_partition_iterator_t it = esp_partition_find(ESP_PARTITION_TYPE_ANY, ESP_PARTITION_SUBTYPE_ANY, NULL);
|
|
|
|
while (it != NULL)
|
|
{
|
|
const esp_partition_t *part = esp_partition_get(it);
|
|
|
|
const char *type_str = "?";
|
|
if (part->type == ESP_PARTITION_TYPE_APP) type_str = "app";
|
|
else if (part->type == ESP_PARTITION_TYPE_DATA) type_str = "data";
|
|
|
|
printf("%-16s %-10s 0x%-8x 0x%08lx %8lu KB\n",
|
|
part->label,
|
|
type_str,
|
|
part->subtype,
|
|
part->address,
|
|
part->size / 1024);
|
|
|
|
it = esp_partition_next(it);
|
|
}
|
|
|
|
esp_partition_iterator_release(it);
|
|
return 0;
|
|
}
|
|
|
|
static int system_cmd_heap_caps(void)
|
|
{
|
|
printf("Heap by Capability:\n");
|
|
|
|
size_t internal_free = heap_caps_get_free_size(MALLOC_CAP_INTERNAL);
|
|
size_t internal_total = heap_caps_get_total_size(MALLOC_CAP_INTERNAL);
|
|
printf(" Internal: %u / %u bytes free (%.1f%%)\n",
|
|
internal_free, internal_total,
|
|
internal_total > 0 ? 100.0 * internal_free / internal_total : 0);
|
|
|
|
size_t spiram_free = heap_caps_get_free_size(MALLOC_CAP_SPIRAM);
|
|
size_t spiram_total = heap_caps_get_total_size(MALLOC_CAP_SPIRAM);
|
|
if (spiram_total > 0)
|
|
{
|
|
printf(" SPIRAM: %u / %u bytes free (%.1f%%)\n",
|
|
spiram_free, spiram_total, 100.0 * spiram_free / spiram_total);
|
|
}
|
|
|
|
size_t dma_free = heap_caps_get_free_size(MALLOC_CAP_DMA);
|
|
size_t dma_total = heap_caps_get_total_size(MALLOC_CAP_DMA);
|
|
printf(" DMA capable: %u / %u bytes free (%.1f%%)\n",
|
|
dma_free, dma_total,
|
|
dma_total > 0 ? 100.0 * dma_free / dma_total : 0);
|
|
|
|
size_t exec_free = heap_caps_get_free_size(MALLOC_CAP_EXEC);
|
|
size_t exec_total = heap_caps_get_total_size(MALLOC_CAP_EXEC);
|
|
printf(" Executable: %u / %u bytes free (%.1f%%)\n",
|
|
exec_free, exec_total,
|
|
exec_total > 0 ? 100.0 * exec_free / exec_total : 0);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int system_cmd_stats(void)
|
|
{
|
|
printf("=== System Statistics ===\n\n");
|
|
|
|
system_cmd_uptime();
|
|
printf("\n");
|
|
system_cmd_ram();
|
|
printf("\n");
|
|
|
|
uint32_t task_count = uxTaskGetNumberOfTasks();
|
|
printf("Active tasks: %lu\n\n", task_count);
|
|
|
|
system_cmd_reset_reason();
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int system_cmd_coredump(void)
|
|
{
|
|
esp_core_dump_summary_t summary;
|
|
esp_err_t err = esp_core_dump_get_summary(&summary);
|
|
|
|
if (err == ESP_ERR_NOT_FOUND)
|
|
{
|
|
printf("No coredump found in flash\n");
|
|
return 0;
|
|
}
|
|
else if (err != ESP_OK)
|
|
{
|
|
printf("Failed to read coredump: %s\n", esp_err_to_name(err));
|
|
return 1;
|
|
}
|
|
|
|
printf("Coredump found:\n");
|
|
printf(" Program counter: 0x%08lx\n", summary.exc_pc);
|
|
printf(" Exception cause: %lu\n", summary.ex_info.exc_cause);
|
|
printf(" Exception vaddr: 0x%08lx\n", summary.ex_info.exc_vaddr);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int system_cmd_sleep(int argc, char **argv)
|
|
{
|
|
if (argc < 3)
|
|
{
|
|
printf("Usage: system sleep <milliseconds>\n");
|
|
return 0;
|
|
}
|
|
|
|
int sleep_ms = atoi(argv[2]);
|
|
printf("Entering light sleep for %d ms...\n", sleep_ms);
|
|
|
|
esp_sleep_enable_timer_wakeup(sleep_ms * 1000);
|
|
esp_light_sleep_start();
|
|
|
|
printf("Woke up from sleep\n");
|
|
return 0;
|
|
}
|
|
|
|
static int system_cmd_mac(void)
|
|
{
|
|
uint8_t mac[6];
|
|
|
|
printf("MAC Addresses:\n");
|
|
|
|
if (esp_read_mac(mac, ESP_MAC_WIFI_STA) == ESP_OK)
|
|
{
|
|
printf(" WiFi STA: %02x:%02x:%02x:%02x:%02x:%02x\n",
|
|
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
|
|
}
|
|
|
|
if (esp_read_mac(mac, ESP_MAC_WIFI_SOFTAP) == ESP_OK)
|
|
{
|
|
printf(" WiFi AP: %02x:%02x:%02x:%02x:%02x:%02x\n",
|
|
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
|
|
}
|
|
|
|
if (esp_read_mac(mac, ESP_MAC_BT) == ESP_OK)
|
|
{
|
|
printf(" BT: %02x:%02x:%02x:%02x:%02x:%02x\n",
|
|
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
|
|
}
|
|
|
|
if (esp_read_mac(mac, ESP_MAC_ETH) == ESP_OK)
|
|
{
|
|
printf(" Ethernet: %02x:%02x:%02x:%02x:%02x:%02x\n",
|
|
mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
typedef struct {
|
|
const char **hostname_out;
|
|
bool success;
|
|
} hostname_get_ctx_t;
|
|
|
|
typedef struct {
|
|
const char *hostname_in;
|
|
esp_err_t result;
|
|
} hostname_set_ctx_t;
|
|
|
|
static esp_err_t get_hostname_tcpip(void *ctx)
|
|
{
|
|
hostname_get_ctx_t *context = (hostname_get_ctx_t *)ctx;
|
|
esp_netif_t *netif = esp_netif_next_unsafe(NULL);
|
|
|
|
if (netif)
|
|
{
|
|
esp_netif_get_hostname(netif, context->hostname_out);
|
|
context->success = true;
|
|
}
|
|
else
|
|
{
|
|
context->success = false;
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
static esp_err_t set_hostname_tcpip(void *ctx)
|
|
{
|
|
hostname_set_ctx_t *context = (hostname_set_ctx_t *)ctx;
|
|
esp_netif_t *netif = esp_netif_next_unsafe(NULL);
|
|
|
|
if (netif)
|
|
{
|
|
context->result = esp_netif_set_hostname(netif, context->hostname_in);
|
|
}
|
|
else
|
|
{
|
|
context->result = ESP_ERR_NOT_FOUND;
|
|
}
|
|
|
|
return ESP_OK;
|
|
}
|
|
|
|
static int system_cmd_hostname(int argc, char **argv)
|
|
{
|
|
if (argc < 3)
|
|
{
|
|
const char *hostname = NULL;
|
|
hostname_get_ctx_t ctx = {
|
|
.hostname_out = &hostname,
|
|
.success = false
|
|
};
|
|
|
|
esp_err_t err = esp_netif_tcpip_exec(get_hostname_tcpip, &ctx);
|
|
|
|
if (err != ESP_OK)
|
|
{
|
|
printf("Failed to access network interface: %s\n", esp_err_to_name(err));
|
|
return 1;
|
|
}
|
|
|
|
if (ctx.success)
|
|
{
|
|
if (hostname)
|
|
{
|
|
printf("Hostname: %s\n", hostname);
|
|
}
|
|
else
|
|
{
|
|
printf("No hostname set\n");
|
|
}
|
|
}
|
|
else
|
|
{
|
|
printf("No network interface available\n");
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
hostname_set_ctx_t ctx = {
|
|
.hostname_in = argv[2],
|
|
.result = ESP_FAIL
|
|
};
|
|
|
|
esp_err_t err = esp_netif_tcpip_exec(set_hostname_tcpip, &ctx);
|
|
|
|
if (err != ESP_OK)
|
|
{
|
|
printf("Failed to access network interface: %s\n", esp_err_to_name(err));
|
|
return 1;
|
|
}
|
|
|
|
if (ctx.result == ESP_ERR_NOT_FOUND)
|
|
{
|
|
printf("No network interface available\n");
|
|
}
|
|
else if (ctx.result == ESP_OK)
|
|
{
|
|
printf("Hostname set to: %s\n", argv[2]);
|
|
}
|
|
else
|
|
{
|
|
printf("Failed to set hostname: %s\n", esp_err_to_name(ctx.result));
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int system_cmd_version(void)
|
|
{
|
|
const esp_app_desc_t *app_desc = esp_app_get_description();
|
|
|
|
printf("Firmware Information:\n");
|
|
printf(" Version: %s\n", app_desc->version);
|
|
printf(" Project: %s\n", app_desc->project_name);
|
|
printf(" IDF version: %s\n", app_desc->idf_ver);
|
|
printf(" SystemK version: %s\n", SYSTEMK_VERSION_STRING);
|
|
printf(" Git commit: %s\n", GIT_COMMIT_HASH_LONG);
|
|
printf(" Compile time: %s %s\n", app_desc->date, app_desc->time);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int system_cmd_idf_version(void)
|
|
{
|
|
printf("ESP-IDF Version: %s\n", IDF_VER);
|
|
printf(" Major: %d\n", ESP_IDF_VERSION_MAJOR);
|
|
printf(" Minor: %d\n", ESP_IDF_VERSION_MINOR);
|
|
printf(" Patch: %d\n", ESP_IDF_VERSION_PATCH);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int system_cmd_factory_reset(void)
|
|
{
|
|
printf("WARNING: This will erase all NVS data!\n");
|
|
printf("Type 'yes' to confirm: ");
|
|
|
|
char confirm[10];
|
|
if (fgets(confirm, sizeof(confirm), stdin) == NULL)
|
|
{
|
|
printf("\nCancelled\n");
|
|
return 0;
|
|
}
|
|
|
|
// Remove newline
|
|
confirm[strcspn(confirm, "\n")] = 0;
|
|
|
|
if (strcmp(confirm, "yes") != 0)
|
|
{
|
|
printf("Cancelled\n");
|
|
return 0;
|
|
}
|
|
|
|
printf("Erasing NVS...\n");
|
|
esp_err_t err = nvs_flash_erase();
|
|
if (err != ESP_OK)
|
|
{
|
|
printf("Failed to erase NVS: %s\n", esp_err_to_name(err));
|
|
return 1;
|
|
}
|
|
|
|
printf("Factory reset complete. Rebooting...\n");
|
|
vTaskDelay(pdMS_TO_TICKS(1000));
|
|
esp_restart();
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int system_cmd_reboot(void)
|
|
{
|
|
printf("Rebooting...\n");
|
|
vTaskDelay(pdMS_TO_TICKS(100));
|
|
esp_restart();
|
|
return 0;
|
|
}
|
|
|
|
static int cmd_system(int argc, char **argv)
|
|
{
|
|
if (argc < 2)
|
|
{
|
|
print_usage();
|
|
return 0;
|
|
}
|
|
|
|
if (!strcmp(argv[1], "chip-info"))
|
|
return system_cmd_chip_info();
|
|
if (!strcmp(argv[1], "uptime"))
|
|
return system_cmd_uptime();
|
|
if (!strcmp(argv[1], "tasks"))
|
|
return system_cmd_tasks();
|
|
if (!strcmp(argv[1], "reset-reason"))
|
|
return system_cmd_reset_reason();
|
|
if (!strcmp(argv[1], "RAM"))
|
|
return system_cmd_ram();
|
|
if (!strcmp(argv[1], "flash"))
|
|
return system_cmd_flash();
|
|
if (!strcmp(argv[1], "partition"))
|
|
return system_cmd_partition();
|
|
if (!strcmp(argv[1], "heap-caps"))
|
|
return system_cmd_heap_caps();
|
|
if (!strcmp(argv[1], "stats"))
|
|
return system_cmd_stats();
|
|
if (!strcmp(argv[1], "coredump"))
|
|
return system_cmd_coredump();
|
|
if (!strcmp(argv[1], "sleep"))
|
|
return system_cmd_sleep(argc, argv);
|
|
if (!strcmp(argv[1], "mac"))
|
|
return system_cmd_mac();
|
|
if (!strcmp(argv[1], "hostname"))
|
|
return system_cmd_hostname(argc, argv);
|
|
if (!strcmp(argv[1], "version"))
|
|
return system_cmd_version();
|
|
if (!strcmp(argv[1], "idf-version"))
|
|
return system_cmd_idf_version();
|
|
if (!strcmp(argv[1], "factory-reset"))
|
|
return system_cmd_factory_reset();
|
|
if (!strcmp(argv[1], "reboot"))
|
|
return system_cmd_reboot();
|
|
|
|
printf("Unknown command\n");
|
|
print_usage();
|
|
return 0;
|
|
}
|
|
|
|
static void system_completion(const char *buf, linenoiseCompletions *lc)
|
|
{
|
|
if (!strncmp(buf, "system", 6))
|
|
{
|
|
linenoiseAddCompletion(lc, "system chip-info");
|
|
linenoiseAddCompletion(lc, "system uptime");
|
|
linenoiseAddCompletion(lc, "system tasks");
|
|
linenoiseAddCompletion(lc, "system reset-reason");
|
|
linenoiseAddCompletion(lc, "system RAM");
|
|
linenoiseAddCompletion(lc, "system flash");
|
|
linenoiseAddCompletion(lc, "system partition");
|
|
linenoiseAddCompletion(lc, "system heap-caps");
|
|
linenoiseAddCompletion(lc, "system stats");
|
|
linenoiseAddCompletion(lc, "system coredump");
|
|
linenoiseAddCompletion(lc, "system sleep");
|
|
linenoiseAddCompletion(lc, "system mac");
|
|
linenoiseAddCompletion(lc, "system hostname");
|
|
linenoiseAddCompletion(lc, "system version");
|
|
linenoiseAddCompletion(lc, "system idf-version");
|
|
linenoiseAddCompletion(lc, "system factory-reset");
|
|
linenoiseAddCompletion(lc, "system reboot");
|
|
}
|
|
}
|
|
|
|
void Register_System_Command(void)
|
|
{
|
|
linenoiseSetCompletionCallback(system_completion);
|
|
|
|
const esp_console_cmd_t cmd = {
|
|
.command = "system",
|
|
.help = "System management and diagnostic commands",
|
|
.func = &cmd_system,
|
|
};
|
|
|
|
ESP_ERROR_CHECK(esp_console_cmd_register(&cmd));
|
|
} |