Commander1024/ESP32_Serial_Swiss_Army_Knife
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
ece4ba77e3ae85939100a0437b873063448a08d0
ESP32_Serial_Swiss_Army_Knife/src/local_ui_hw_test.c
T

608 lines
20 KiB
C
Raw Blame History

/* SPDX-License-Identifier: GPL-3.0-only */
/* Phase 7A diagnostics built on the Phase 7B local display service. */
#include "local_ui_hw_test.h"
#include <errno.h>
#include <stdbool.h>
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "board_pins.h"
#include "driver/gpio.h"
#include "esp_err.h"
#include "esp_timer.h"
#include "freertos/FreeRTOS.h"
#include "freertos/task.h"
#include "local_display.h"
#include "local_status_ui.h"
#define BUTTON_POLL_MS 10U
#define BUTTON_DEBOUNCE_MS 30U
#define BUTTON_LONG_PRESS_MS 1000U
#define BUTTON_TEST_DEFAULT_SECONDS 10U
#define BUTTON_TEST_MAX_SECONDS 30U
typedef struct {
const char *name;
gpio_num_t gpio;
} button_definition_t;
typedef struct {
int raw_level;
int stable_level;
int64_t raw_changed_us;
int64_t pressed_us;
bool long_reported;
uint32_t short_presses;
uint32_t long_presses;
uint32_t stable_transitions;
} button_test_state_t;
static const button_definition_t s_buttons[] = {
{.name = "previous/back", .gpio = LOCAL_UI_BUTTON_PREVIOUS_GPIO},
{.name = "select/confirm", .gpio = LOCAL_UI_BUTTON_SELECT_GPIO},
{.name = "next", .gpio = LOCAL_UI_BUTTON_NEXT_GPIO},
};
static bool s_buttons_ready;
static esp_err_t s_button_initialization_error = ESP_ERR_INVALID_STATE;
static TickType_t milliseconds_to_ticks(uint32_t milliseconds)
{
TickType_t ticks = pdMS_TO_TICKS(milliseconds);
return (milliseconds > 0U && ticks == 0U) ? 1U : ticks;
}
static bool parse_unsigned(const char *text,
unsigned long minimum,
unsigned long maximum,
unsigned long *value)
{
if (text == NULL || value == NULL) {
return false;
}
char *end = NULL;
errno = 0;
unsigned long parsed = strtoul(text, &end, 10);
if (errno != 0 || end == text || *end != '\0' ||
parsed < minimum || parsed > maximum) {
return false;
}
*value = parsed;
return true;
}
static bool parse_display_address(const char *text, uint8_t *address)
{
if (text == NULL || address == NULL) {
return false;
}
char *end = NULL;
errno = 0;
unsigned long parsed = strtoul(text, &end, 0);
if (errno != 0 || end == text || *end != '\0') {
return false;
}
if (parsed == 0x3cU || parsed == 0x78U || parsed == 0x79U) {
*address = 0x3cU;
return true;
}
if (parsed == 0x3dU || parsed == 0x7aU || parsed == 0x7bU) {
*address = 0x3dU;
return true;
}
return false;
}
static int report_error(const char *operation, esp_err_t error)
{
printf("%s failed: %s\n", operation, esp_err_to_name(error));
return 1;
}
static esp_err_t configure_buttons(void)
{
const gpio_config_t config = {
.pin_bit_mask = (1ULL << LOCAL_UI_BUTTON_PREVIOUS_GPIO) |
(1ULL << LOCAL_UI_BUTTON_SELECT_GPIO) |
(1ULL << LOCAL_UI_BUTTON_NEXT_GPIO),
.mode = GPIO_MODE_INPUT,
.pull_up_en = GPIO_PULLUP_ENABLE,
.pull_down_en = GPIO_PULLDOWN_DISABLE,
.intr_type = GPIO_INTR_DISABLE,
};
esp_err_t error = gpio_config(&config);
if (error == ESP_OK) {
s_buttons_ready = true;
}
return error;
}
static void print_address(uint8_t address)
{
printf("7-bit 0x%02x (8-bit 0x%02x write / 0x%02x read)",
address, (unsigned int)(address << 1U),
(unsigned int)((address << 1U) | 1U));
}
static void print_display_usage(void)
{
printf("Usage:\n");
printf(" debug display status|probe\n");
printf(" debug display scan --force\n");
printf(" debug display init [0x3c|0x3d|0x78|0x79|0x7a|0x7b]\n");
printf(" debug display off\n");
printf(" debug display pattern <clear|fill|checker|grid|corners|layout>\n");
printf(" debug display row <0..63>\n");
printf(" debug display contrast <0..255>\n");
printf(" debug display invert <on|off>\n");
}
static int command_display_status(int argc, char **argv)
{
(void)argv;
if (argc != 1) {
print_display_usage();
return 1;
}
local_display_snapshot_t snapshot;
esp_err_t error = local_display_get_snapshot(&snapshot);
if (error != ESP_OK) {
return report_error("Display status", error);
}
printf("Local display: bus=%s initialized=%s last-error=%s dirty-pages=0x%02x\n",
snapshot.bus_ready ? "ready" : "unavailable",
snapshot.initialized ? "yes" : "no",
esp_err_to_name(snapshot.last_error),
snapshot.dirty_page_mask);
if (snapshot.address_7bit != 0U) {
printf("OLED: ");
print_address(snapshot.address_7bit);
printf(" contrast=%u inverted=%s\n", (unsigned int)snapshot.contrast,
snapshot.inverted ? "yes" : "no");
} else {
printf("OLED: no selected address\n");
}
printf("Panels: status=128x16 rows 0..15; content=128x48 rows 16..63; physical black divider between them\n");
printf("Pins: SDA=%d level=%d SCL=%d level=%d; buttons previous=%d select=%d next=%d\n",
LOCAL_UI_DISPLAY_SDA_GPIO, gpio_get_level(LOCAL_UI_DISPLAY_SDA_GPIO),
LOCAL_UI_DISPLAY_SCL_GPIO, gpio_get_level(LOCAL_UI_DISPLAY_SCL_GPIO),
LOCAL_UI_BUTTON_PREVIOUS_GPIO, LOCAL_UI_BUTTON_SELECT_GPIO,
LOCAL_UI_BUTTON_NEXT_GPIO);
return snapshot.bus_ready && s_buttons_ready ? 0 : 1;
}
static int command_display_probe(int argc, char **argv)
{
(void)argv;
if (argc != 1) {
print_display_usage();
return 1;
}
uint8_t address = 0U;
esp_err_t error = local_display_probe_expected(&address);
if (error != ESP_OK) {
printf("No OLED response at expected 7-bit addresses 0x3c or 0x3d.\n");
return report_error("Display probe", error);
}
printf("OLED response at ");
print_address(address);
printf(".\n");
return 0;
}
static void scan_print_callback(uint8_t address, void *context)
{
(void)context;
printf(" response: ");
print_address(address);
printf("\n");
}
static int command_display_scan(int argc, char **argv)
{
if (argc != 2 || strcmp(argv[1], "--force") != 0) {
printf("A full usable-address scan sends an address probe to every 7-bit address from 0x08 through 0x77.\n");
print_display_usage();
return 1;
}
size_t found = 0U;
printf("Scanning usable 7-bit I2C addresses 0x08..0x77 at 100000 Hz.\n");
esp_err_t error = local_display_scan(scan_print_callback, NULL, &found);
printf("I2C scan complete: %u responding address%s.\n", (unsigned int)found,
found == 1U ? "" : "es");
return error == ESP_OK ? 0 : report_error("Display scan", error);
}
static int command_display_init(int argc, char **argv)
{
if (argc > 2) {
print_display_usage();
return 1;
}
uint8_t address = 0U;
esp_err_t error;
if (argc == 2) {
if (!parse_display_address(argv[1], &address)) {
printf("Display address must be 7-bit 0x3c/0x3d or their 8-bit write/read forms.\n");
return 1;
}
error = local_display_start_at(address);
} else {
error = local_display_start();
if (error == ESP_OK) {
local_display_snapshot_t snapshot;
error = local_display_get_snapshot(&snapshot);
address = snapshot.address_7bit;
}
}
if (error != ESP_OK) {
return report_error("Display initialization", error);
}
printf("SSD1315-compatible 128x64 display initialized at ");
print_address(address);
printf(".\n");
return 0;
}
static int command_display_off(int argc, char **argv)
{
(void)argv;
if (argc != 1) {
print_display_usage();
return 1;
}
esp_err_t error = local_display_stop();
if (error != ESP_OK) {
return report_error("Display off", error);
}
printf("Display switched off; run 'debug display init' to reinitialize it.\n");
return 0;
}
static bool pattern_name_valid(const char *name)
{
return strcmp(name, "clear") == 0 || strcmp(name, "fill") == 0 ||
strcmp(name, "checker") == 0 || strcmp(name, "grid") == 0 ||
strcmp(name, "corners") == 0 || strcmp(name, "layout") == 0;
}
static void set_global_pixel(uint8_t x, uint8_t y, bool on)
{
if (y < LOCAL_DISPLAY_STATUS_HEIGHT) {
local_display_frame_set_pixel(LOCAL_DISPLAY_PANEL_STATUS, x, y, on);
} else {
local_display_frame_set_pixel(LOCAL_DISPLAY_PANEL_CONTENT, x,
(uint8_t)(y - LOCAL_DISPLAY_STATUS_HEIGHT), on);
}
}
static void draw_pattern(const char *name)
{
local_display_frame_clear_all();
if (strcmp(name, "clear") == 0) {
return;
}
if (strcmp(name, "fill") == 0) {
for (uint8_t y = 0U; y < LOCAL_DISPLAY_HEIGHT; ++y) {
for (uint8_t x = 0U; x < LOCAL_DISPLAY_WIDTH; ++x) {
set_global_pixel(x, y, true);
}
}
return;
}
if (strcmp(name, "checker") == 0 || strcmp(name, "grid") == 0) {
bool checker = strcmp(name, "checker") == 0;
for (uint8_t y = 0U; y < LOCAL_DISPLAY_HEIGHT; ++y) {
for (uint8_t x = 0U; x < LOCAL_DISPLAY_WIDTH; ++x) {
bool on = checker ? (((x + y) & 1U) == 0U)
: ((x % 8U) == 0U || (y % 8U) == 0U);
if (on) {
set_global_pixel(x, y, true);
}
}
}
return;
}
if (strcmp(name, "corners") == 0) {
for (uint8_t x = 0U; x < LOCAL_DISPLAY_WIDTH; ++x) {
set_global_pixel(x, 0U, true);
set_global_pixel(x, LOCAL_DISPLAY_HEIGHT - 1U, true);
}
for (uint8_t y = 0U; y < LOCAL_DISPLAY_HEIGHT; ++y) {
set_global_pixel(0U, y, true);
set_global_pixel(LOCAL_DISPLAY_WIDTH - 1U, y, true);
}
return;
}
local_display_frame_clear(LOCAL_DISPLAY_PANEL_STATUS);
local_display_frame_clear(LOCAL_DISPLAY_PANEL_CONTENT);
local_display_frame_draw_text(LOCAL_DISPLAY_PANEL_STATUS, 0U, 0U, "SER OK");
local_display_frame_draw_text(LOCAL_DISPLAY_PANEL_STATUS, 0U, 8U, "WR NONE");
local_display_frame_draw_text(LOCAL_DISPLAY_PANEL_CONTENT, 0U, 0U, "DISPLAY DRIVER");
local_display_frame_draw_text(LOCAL_DISPLAY_PANEL_CONTENT, 0U, 8U, "STATUS 16 PX");
local_display_frame_draw_text(LOCAL_DISPLAY_PANEL_CONTENT, 0U, 24U, "CONTENT 48 PX");
local_display_frame_draw_text(LOCAL_DISPLAY_PANEL_CONTENT, 0U, 40U, "SEPARATE PANELS");
}
static int command_display_pattern(int argc, char **argv)
{
if (argc != 2 || !pattern_name_valid(argv[1])) {
print_display_usage();
return 1;
}
esp_err_t error = local_display_frame_begin();
if (error != ESP_OK) {
return report_error("Display pattern", error);
}
draw_pattern(argv[1]);
error = local_display_frame_end();
if (error != ESP_OK) {
return report_error("Display pattern", error);
}
printf("Displayed '%s' test pattern.\n", argv[1]);
return 0;
}
static int command_display_row(int argc, char **argv)
{
unsigned long row = 0U;
if (argc != 2 || !parse_unsigned(argv[1], 0U, LOCAL_DISPLAY_HEIGHT - 1U, &row)) {
print_display_usage();
return 1;
}
esp_err_t error = local_display_frame_begin();
if (error != ESP_OK) {
return report_error("Display row", error);
}
local_display_frame_clear_all();
for (uint8_t x = 0U; x < LOCAL_DISPLAY_WIDTH; ++x) {
set_global_pixel(x, (uint8_t)row, true);
}
error = local_display_frame_end();
if (error != ESP_OK) {
return report_error("Display row", error);
}
printf("Displayed one-pixel horizontal line at row %lu.\n", row);
return 0;
}
static int command_display_contrast(int argc, char **argv)
{
unsigned long contrast = 0U;
if (argc != 2 || !parse_unsigned(argv[1], 0U, 255U, &contrast)) {
print_display_usage();
return 1;
}
esp_err_t error = local_display_set_contrast((uint8_t)contrast);
if (error != ESP_OK) {
return report_error("Display contrast", error);
}
printf("Display contrast set to %lu.\n", contrast);
return 0;
}
static int command_display_invert(int argc, char **argv)
{
if (argc != 2 || (strcmp(argv[1], "on") != 0 && strcmp(argv[1], "off") != 0)) {
print_display_usage();
return 1;
}
bool inverted = strcmp(argv[1], "on") == 0;
esp_err_t error = local_display_set_inverted(inverted);
if (error != ESP_OK) {
return report_error("Display inversion", error);
}
printf("Display inversion %s.\n", inverted ? "enabled" : "disabled");
return 0;
}
static int command_display(int argc, char **argv)
{
if (argc < 2 || strcmp(argv[1], "help") == 0) {
print_display_usage();
return argc < 2 || argc == 2 ? 0 : 1;
}
/* Keep diagnostic output visible instead of immediately redrawing status pages. */
local_status_ui_hold_for_diagnostics();
if (strcmp(argv[1], "status") == 0) {
return command_display_status(argc - 1, argv + 1);
}
if (strcmp(argv[1], "probe") == 0) {
return command_display_probe(argc - 1, argv + 1);
}
if (strcmp(argv[1], "scan") == 0) {
return command_display_scan(argc - 1, argv + 1);
}
if (strcmp(argv[1], "init") == 0) {
return command_display_init(argc - 1, argv + 1);
}
if (strcmp(argv[1], "off") == 0) {
return command_display_off(argc - 1, argv + 1);
}
if (strcmp(argv[1], "pattern") == 0) {
return command_display_pattern(argc - 1, argv + 1);
}
if (strcmp(argv[1], "row") == 0) {
return command_display_row(argc - 1, argv + 1);
}
if (strcmp(argv[1], "contrast") == 0) {
return command_display_contrast(argc - 1, argv + 1);
}
if (strcmp(argv[1], "invert") == 0) {
return command_display_invert(argc - 1, argv + 1);
}
printf("Unknown display diagnostic '%s'.\n", argv[1]);
print_display_usage();
return 1;
}
static void print_buttons_usage(void)
{
printf("Usage:\n");
printf(" debug buttons status\n");
printf(" debug buttons test [seconds] (1..30, default 10)\n");
}
static int command_buttons_status(int argc, char **argv)
{
(void)argv;
if (argc != 1) {
print_buttons_usage();
return 1;
}
if (!s_buttons_ready) {
return report_error("Button status", s_button_initialization_error);
}
printf("Buttons are active-low with internal pull-ups:\n");
for (size_t index = 0U; index < sizeof(s_buttons) / sizeof(s_buttons[0]); ++index) {
int level = gpio_get_level(s_buttons[index].gpio);
printf(" %-14s GPIO%d level=%d %s\n", s_buttons[index].name,
s_buttons[index].gpio, level, level == 0 ? "pressed" : "released");
}
return 0;
}
static int command_buttons_test(int argc, char **argv)
{
unsigned long seconds = BUTTON_TEST_DEFAULT_SECONDS;
if (argc > 2 ||
(argc == 2 && !parse_unsigned(argv[1], 1U, BUTTON_TEST_MAX_SECONDS, &seconds))) {
print_buttons_usage();
return 1;
}
if (!s_buttons_ready) {
return report_error("Button test", s_button_initialization_error);
}
button_test_state_t states[sizeof(s_buttons) / sizeof(s_buttons[0])];
int64_t now = esp_timer_get_time();
for (size_t index = 0U; index < sizeof(s_buttons) / sizeof(s_buttons[0]); ++index) {
states[index] = (button_test_state_t){
.raw_level = gpio_get_level(s_buttons[index].gpio),
.stable_level = 1,
.raw_changed_us = now,
};
}
int64_t deadline = now + (int64_t)seconds * 1000000LL;
printf("Testing buttons for %lu second%s; short press each button and hold one for at least %u ms.\n",
seconds, seconds == 1U ? "" : "s", (unsigned int)BUTTON_LONG_PRESS_MS);
while ((now = esp_timer_get_time()) < deadline) {
for (size_t index = 0U; index < sizeof(s_buttons) / sizeof(s_buttons[0]); ++index) {
button_test_state_t *state = &states[index];
int raw = gpio_get_level(s_buttons[index].gpio);
if (raw != state->raw_level) {
state->raw_level = raw;
state->raw_changed_us = now;
}
if (raw != state->stable_level &&
now - state->raw_changed_us >= (int64_t)BUTTON_DEBOUNCE_MS * 1000LL) {
state->stable_level = raw;
++state->stable_transitions;
if (raw == 0) {
state->pressed_us = now;
state->long_reported = false;
printf("%-14s pressed\n", s_buttons[index].name);
} else {
int64_t duration_ms = state->pressed_us == 0 ? 0 :
(now - state->pressed_us) / 1000LL;
if (!state->long_reported) {
++state->short_presses;
printf("%-14s short release after %lld ms\n",
s_buttons[index].name, (long long)duration_ms);
} else {
printf("%-14s released after %lld ms\n",
s_buttons[index].name, (long long)duration_ms);
}
state->pressed_us = 0;
}
}
if (state->stable_level == 0 && !state->long_reported &&
state->pressed_us != 0 &&
now - state->pressed_us >= (int64_t)BUTTON_LONG_PRESS_MS * 1000LL) {
state->long_reported = true;
++state->long_presses;
printf("%-14s long press\n", s_buttons[index].name);
}
}
vTaskDelay(milliseconds_to_ticks(BUTTON_POLL_MS));
}
printf("Button test summary:\n");
bool stuck = false;
for (size_t index = 0U; index < sizeof(s_buttons) / sizeof(s_buttons[0]); ++index) {
bool pressed = gpio_get_level(s_buttons[index].gpio) == 0;
printf(" %-14s short=%u long=%u transitions=%u final=%s\n",
s_buttons[index].name, (unsigned int)states[index].short_presses,
(unsigned int)states[index].long_presses,
(unsigned int)states[index].stable_transitions,
pressed ? "PRESSED" : "released");
stuck |= pressed;
}
if (stuck) {
printf("Warning: one or more buttons remained asserted; check for a held or stuck input.\n");
}
return 0;
}
static int command_buttons(int argc, char **argv)
{
if (argc < 2 || strcmp(argv[1], "help") == 0) {
print_buttons_usage();
return argc < 2 || argc == 2 ? 0 : 1;
}
if (strcmp(argv[1], "status") == 0) {
return command_buttons_status(argc - 1, argv + 1);
}
if (strcmp(argv[1], "test") == 0) {
return command_buttons_test(argc - 1, argv + 1);
}
printf("Unknown button diagnostic '%s'.\n", argv[1]);
print_buttons_usage();
return 1;
}
esp_err_t local_ui_hw_test_init(void)
{
if (s_buttons_ready) {
return ESP_ERR_INVALID_STATE;
}
s_button_initialization_error = configure_buttons();
return s_button_initialization_error;
}
int local_ui_hw_test_execute(int argc, char **argv)
{
if (argc < 1 || argv == NULL || argv[0] == NULL) {
return 1;
}
if (strcmp(argv[0], "display") == 0) {
return command_display(argc, argv);
}
if (strcmp(argv[0], "buttons") == 0) {
return command_buttons(argc, argv);
}
return 1;
}
void local_ui_hw_test_print_usage(void)
{
printf(" debug display [status|probe|scan|init|off|pattern|row|contrast|invert]\n");
printf(" debug buttons [status|test]\n");
}
Reference in New Issue View Git Blame Copy Permalink