Зафиксировать рабочий BreathMonitor v1 и сервер

This commit is contained in:
AidarKC
2026-10-25 14:14:27 +03:00
parent 370f4ae94e
commit d5a37d3009
43 changed files with 2490 additions and 1522 deletions
@@ -0,0 +1,5 @@
# AGENTS
`manual_monitor_lvgl_v2.ino` is the dedicated LVGL version of the manual two-button breath monitor for Waveshare ESP32-S3-Touch-AMOLED-2.16.
Keep every on-screen string in English. When behavior, pins, settings, alert cadence, pause, or UI changes, update this folder's `README.md` and `../../../../reference/usb_contact_sensor_test_spec.md` in the same change.
@@ -0,0 +1,30 @@
# Manual Monitor LVGL v2
Dedicated LVGL firmware for the Waveshare ESP32-S3-Touch-AMOLED-2.16 manual breath monitor. It is separate from the legacy multi-mode GFX sketch and does not use USB D+/D- as sensor inputs.
## Controls
- `KEY2 / GPIO18`: `INHALE`, active LOW. Hold for about 1.2 seconds to open or close settings; this still accepts the INHALE phase.
- `KEY3 / GPIO0`: `EXHALE`, active LOW. Do not hold it during reset/boot.
- Short EXHALE completes a valid inhale/exhale cycle. Repeated INHALE or EXHALE presses are ignored.
- Hold `KEY3 / EXHALE` for about 1.2 seconds to enter or leave conscious pause. Hold does not create an EXHALE event. Paused time is removed from the phase and cycle timers; reminders and automatic power-off are suspended.
## Functionality
- Full-screen LVGL UI with a non-flickering partial draw buffer and the board's proven built-in LVGL font path.
- AXP2101 battery percentage, drawn battery icon, and charging marker at top right.
- Four numeric monitor cards are label-free; the spaced `HISTORY` row shows the last five completed cycles and their exact average is rendered to tenths of a second.
- Numeric cards use the display's straight built-in GFX digits; when AXP2101 reports an invalid `0%` while battery voltage is at least 3.3 V, the displayed percentage falls back to a voltage-derived estimate.
- Settings for limit, confirmation tick volume, alert volume, and screen timeout (`10 / 30 / 60 sec / Always on`), stored in NVS.
- The screen turns off after its selected idle timeout while monitoring continues. A touch or physical button wakes it.
- After a valid phase, reminders are silent for 30 seconds, quiet every 5 seconds through 60 seconds, loud every 5 seconds through 90 seconds, and loud every 15 seconds until 6:30. Then AXP2101 shuts down the device.
- A short average is evaluated at EXHALE, after the cycle is accepted. Consecutive short averages increase the warning sequence from one beep to five.
## Build or flash
From this folder:
```bash
NO_UPLOAD=1 ./burn.sh
./burn.sh
```
+43
View File
@@ -0,0 +1,43 @@
#!/usr/bin/env bash
set -euo pipefail
ROOT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
WORKSPACE_DIR="$(cd "$ROOT_DIR/../../../" && pwd)"
DEMO_BASE="$WORKSPACE_DIR/SHiNE-product/ESP32/esp32/ESP32-S3-Touch-AMOLED-2.16/official-demo/examples/Arduino-v3.3.5"
PORT="${PORT:-}"
FQBN="${FQBN:-esp32:esp32:esp32s3:USBMode=hwcdc,CDCOnBoot=cdc,UploadSpeed=921600,CPUFreq=240,FlashMode=dio,FlashSize=16M,PartitionScheme=app3M_fat9M_16MB,PSRAM=opi}"
BUILD_DIR="$ROOT_DIR/../../.arduino-build/manual-monitor-lvgl-v2"
OUT_DIR="$ROOT_DIR/../../.arduino-build/out-manual-monitor-lvgl-v2"
if [[ ! -d "$DEMO_BASE/libraries" ]]; then
echo "Missing Waveshare libraries: $DEMO_BASE/libraries" >&2
exit 1
fi
compile_args=(
--fqbn "$FQBN"
--build-path "$BUILD_DIR"
--output-dir "$OUT_DIR"
--library "$DEMO_BASE/libraries/GFX_Library_for_Arduino"
--library "$DEMO_BASE/libraries/SensorLib"
--library "$DEMO_BASE/libraries/XPowersLib"
--library "$DEMO_BASE/libraries/lvgl"
--library "$DEMO_BASE/libraries/Mylibrary"
"$ROOT_DIR"
)
if ! arduino-cli compile "${compile_args[@]}"; then
arduino-cli compile --clean "${compile_args[@]}"
fi
if [[ "${NO_UPLOAD:-0}" == "1" ]]; then
exit 0
fi
if [[ -z "$PORT" ]]; then
PORT="$(arduino-cli board list | awk '/ttyACM|ttyUSB/ {print $1; exit}')"
fi
if [[ -z "$PORT" ]]; then
echo "Set PORT=/dev/ttyACM0 or use NO_UPLOAD=1." >&2
exit 1
fi
arduino-cli upload --fqbn "$FQBN" -p "$PORT" --input-dir "$OUT_DIR" "$ROOT_DIR"
@@ -0,0 +1,28 @@
#!/usr/bin/env python3
"""Download append-only events.bin over ESP32 USB serial. pip install pyserial"""
import argparse, serial, time
p=argparse.ArgumentParser()
p.add_argument('port',help='e.g. /dev/ttyACM0')
p.add_argument('-o','--output',default='events.bin')
p.add_argument('--baud',type=int,default=115200)
a=p.parse_args()
with serial.Serial(a.port,a.baud,timeout=10) as dev:
time.sleep(4)
dev.reset_input_buffer()
dev.write(b'LOG DOWNLOAD\n')
header=''
for _ in range(20):
header=dev.readline().decode(errors='replace').strip()
if header.startswith('LOG BEGIN '): break
if header.startswith('LOG ERROR '): raise SystemExit(header)
else: raise SystemExit('Device did not respond: '+repr(header))
expected=int(header.split()[-1]); result=bytearray()
while True:
line=dev.readline().strip().decode(errors='replace')
if line=='LOG END': break
if not line: raise SystemExit('Timeout during transfer')
try: result.extend(bytes.fromhex(line))
except ValueError: raise SystemExit('Invalid transfer line: '+repr(line))
if len(result)!=expected: raise SystemExit(f'Incomplete transfer: {len(result)} of {expected}')
with open(a.output,'wb') as file: file.write(result)
print(f'Saved {len(result)} bytes into {a.output}')
@@ -0,0 +1,443 @@
/*
* SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <string.h>
#include "es8311.h"
#include "driver/gpio.h"
#include "esp_log.h"
#include "esp_err.h"
#include "esp_check.h"
#include "es8311_reg.h"
#include "esp32-hal-i2c.h"
typedef struct {
unsigned int port;
uint16_t dev_addr;
} es8311_dev_t;
/*
* Clock coefficient structure
*/
struct _coeff_div {
uint32_t mclk; /* mclk frequency */
uint32_t rate; /* sample rate */
uint8_t pre_div; /* the pre divider with range from 1 to 8 */
uint8_t pre_multi; /* the pre multiplier with 0: 1x, 1: 2x, 2: 4x, 3: 8x selection */
uint8_t adc_div; /* adcclk divider */
uint8_t dac_div; /* dacclk divider */
uint8_t fs_mode; /* double speed or single speed, =0, ss, =1, ds */
uint8_t lrck_h; /* adclrck divider and daclrck divider */
uint8_t lrck_l;
uint8_t bclk_div; /* sclk divider */
uint8_t adc_osr; /* adc osr */
uint8_t dac_osr; /* dac osr */
};
/* codec hifi mclk clock divider coefficients */
static const struct _coeff_div coeff_div[] = {
/*!<mclk rate pre_div mult adc_div dac_div fs_mode lrch lrcl bckdiv osr */
/* 8k */
{12288000, 8000, 0x06, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{18432000, 8000, 0x03, 0x01, 0x03, 0x03, 0x00, 0x05, 0xff, 0x18, 0x10, 0x10},
{16384000, 8000, 0x08, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{8192000, 8000, 0x04, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{6144000, 8000, 0x03, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{4096000, 8000, 0x02, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{3072000, 8000, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{2048000, 8000, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1536000, 8000, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1024000, 8000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
/* 11.025k */
{11289600, 11025, 0x04, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{5644800, 11025, 0x02, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{2822400, 11025, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1411200, 11025, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
/* 12k */
{12288000, 12000, 0x04, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{6144000, 12000, 0x02, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{3072000, 12000, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1536000, 12000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
/* 16k */
{12288000, 16000, 0x03, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{18432000, 16000, 0x03, 0x01, 0x03, 0x03, 0x00, 0x02, 0xff, 0x0c, 0x10, 0x10},
{16384000, 16000, 0x04, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{8192000, 16000, 0x02, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{6144000, 16000, 0x03, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{4096000, 16000, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{3072000, 16000, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{2048000, 16000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1536000, 16000, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1024000, 16000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
/* 22.05k */
{11289600, 22050, 0x02, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{5644800, 22050, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{2822400, 22050, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1411200, 22050, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{705600, 22050, 0x01, 0x03, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
/* 24k */
{12288000, 24000, 0x02, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{18432000, 24000, 0x03, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{6144000, 24000, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{3072000, 24000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1536000, 24000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
/* 32k */
{12288000, 32000, 0x03, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{18432000, 32000, 0x03, 0x02, 0x03, 0x03, 0x00, 0x02, 0xff, 0x0c, 0x10, 0x10},
{16384000, 32000, 0x02, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{8192000, 32000, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{6144000, 32000, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{4096000, 32000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{3072000, 32000, 0x03, 0x03, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{2048000, 32000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1536000, 32000, 0x03, 0x03, 0x01, 0x01, 0x01, 0x00, 0x7f, 0x02, 0x10, 0x10},
{1024000, 32000, 0x01, 0x03, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
/* 44.1k */
{11289600, 44100, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{5644800, 44100, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{2822400, 44100, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1411200, 44100, 0x01, 0x03, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
/* 48k */
{12288000, 48000, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{18432000, 48000, 0x03, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{6144000, 48000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{3072000, 48000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1536000, 48000, 0x01, 0x03, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
/* 64k */
{12288000, 64000, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{18432000, 64000, 0x03, 0x02, 0x03, 0x03, 0x01, 0x01, 0x7f, 0x06, 0x10, 0x10},
{16384000, 64000, 0x01, 0x00, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{8192000, 64000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{6144000, 64000, 0x01, 0x02, 0x03, 0x03, 0x01, 0x01, 0x7f, 0x06, 0x10, 0x10},
{4096000, 64000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{3072000, 64000, 0x01, 0x03, 0x03, 0x03, 0x01, 0x01, 0x7f, 0x06, 0x10, 0x10},
{2048000, 64000, 0x01, 0x03, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1536000, 64000, 0x01, 0x03, 0x01, 0x01, 0x01, 0x00, 0xbf, 0x03, 0x18, 0x18},
{1024000, 64000, 0x01, 0x03, 0x01, 0x01, 0x01, 0x00, 0x7f, 0x02, 0x10, 0x10},
/* 88.2k */
{11289600, 88200, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{5644800, 88200, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{2822400, 88200, 0x01, 0x03, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1411200, 88200, 0x01, 0x03, 0x01, 0x01, 0x01, 0x00, 0x7f, 0x02, 0x10, 0x10},
/* 96k */
{12288000, 96000, 0x01, 0x01, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{18432000, 96000, 0x03, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{6144000, 96000, 0x01, 0x02, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{3072000, 96000, 0x01, 0x03, 0x01, 0x01, 0x00, 0x00, 0xff, 0x04, 0x10, 0x10},
{1536000, 96000, 0x01, 0x03, 0x01, 0x01, 0x01, 0x00, 0x7f, 0x02, 0x10, 0x10},
};
static const char *TAG = "ES8311";
static inline esp_err_t es8311_write_reg(es8311_handle_t dev, uint8_t reg_addr, uint8_t data)
{
es8311_dev_t *es = (es8311_dev_t *) dev;
const uint8_t write_buf[2] = {reg_addr, data};
return i2cWrite(es->port, es->dev_addr, write_buf, sizeof(write_buf), 1000);
}
static inline esp_err_t es8311_read_reg(es8311_handle_t dev, uint8_t reg_addr, uint8_t *reg_value)
{
es8311_dev_t *es = (es8311_dev_t *) dev;
size_t readCount = 0;
return i2cWriteReadNonStop(es->port, es->dev_addr, &reg_addr, 1, reg_value, 1, 1000, &readCount);
}
/*
* look for the coefficient in coeff_div[] table
*/
static int get_coeff(uint32_t mclk, uint32_t rate)
{
for (int i = 0; i < (sizeof(coeff_div) / sizeof(coeff_div[0])); i++) {
if (coeff_div[i].rate == rate && coeff_div[i].mclk == mclk) {
return i;
}
}
return -1;
}
esp_err_t es8311_sample_frequency_config(es8311_handle_t dev, int mclk_frequency, int sample_frequency)
{
uint8_t regv;
/* Get clock coefficients from coefficient table */
int coeff = get_coeff(mclk_frequency, sample_frequency);
if (coeff < 0) {
ESP_LOGE(TAG, "Unable to configure sample rate %dHz with %dHz MCLK", sample_frequency, mclk_frequency);
return ESP_ERR_INVALID_ARG;
}
const struct _coeff_div *const selected_coeff = &coeff_div[coeff];
/* register 0x02 */
ESP_RETURN_ON_ERROR(es8311_read_reg(dev, ES8311_CLK_MANAGER_REG02, &regv), TAG, "I2C read/write error");
regv &= 0x07;
regv |= (selected_coeff->pre_div - 1) << 5;
regv |= selected_coeff->pre_multi << 3;
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_CLK_MANAGER_REG02, regv), TAG, "I2C read/write error");
/* register 0x03 */
const uint8_t reg03 = (selected_coeff->fs_mode << 6) | selected_coeff->adc_osr;
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_CLK_MANAGER_REG03, reg03), TAG, "I2C read/write error");
/* register 0x04 */
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_CLK_MANAGER_REG04, selected_coeff->dac_osr), TAG, "I2C read/write error");
/* register 0x05 */
const uint8_t reg05 = ((selected_coeff->adc_div - 1) << 4) | (selected_coeff->dac_div - 1);
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_CLK_MANAGER_REG05, reg05), TAG, "I2C read/write error");
/* register 0x06 */
ESP_RETURN_ON_ERROR(es8311_read_reg(dev, ES8311_CLK_MANAGER_REG06, &regv), TAG, "I2C read/write error");
regv &= 0xE0;
if (selected_coeff->bclk_div < 19) {
regv |= (selected_coeff->bclk_div - 1) << 0;
} else {
regv |= (selected_coeff->bclk_div) << 0;
}
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_CLK_MANAGER_REG06, regv), TAG, "I2C read/write error");
/* register 0x07 */
ESP_RETURN_ON_ERROR(es8311_read_reg(dev, ES8311_CLK_MANAGER_REG07, &regv), TAG, "I2C read/write error");
regv &= 0xC0;
regv |= selected_coeff->lrck_h << 0;
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_CLK_MANAGER_REG07, regv), TAG, "I2C read/write error");
/* register 0x08 */
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_CLK_MANAGER_REG08, selected_coeff->lrck_l), TAG, "I2C read/write error");
return ESP_OK;
}
static esp_err_t es8311_clock_config(es8311_handle_t dev, const es8311_clock_config_t *const clk_cfg, es8311_resolution_t res)
{
uint8_t reg06;
uint8_t reg01 = 0x3F; // Enable all clocks
int mclk_hz;
/* Select clock source for internal MCLK and determine its frequency */
if (clk_cfg->mclk_from_mclk_pin) {
mclk_hz = clk_cfg->mclk_frequency;
} else {
mclk_hz = clk_cfg->sample_frequency * (int)res * 2;
reg01 |= BIT(7); // Select BCLK (a.k.a. SCK) pin
}
if (clk_cfg->mclk_inverted) {
reg01 |= BIT(6); // Invert MCLK pin
}
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_CLK_MANAGER_REG01, reg01), TAG, "I2C read/write error");
ESP_RETURN_ON_ERROR(es8311_read_reg(dev, ES8311_CLK_MANAGER_REG06, &reg06), TAG, "I2C read/write error");
if (clk_cfg->sclk_inverted) {
reg06 |= BIT(5);
} else {
reg06 &= ~BIT(5);
}
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_CLK_MANAGER_REG06, reg06), TAG, "I2C read/write error");
/* Configure clock dividers */
return es8311_sample_frequency_config(dev, mclk_hz, clk_cfg->sample_frequency);
}
static esp_err_t es8311_resolution_config(const es8311_resolution_t res, uint8_t *reg)
{
switch (res) {
case ES8311_RESOLUTION_16:
*reg |= (3 << 2);
break;
case ES8311_RESOLUTION_18:
*reg |= (2 << 2);
break;
case ES8311_RESOLUTION_20:
*reg |= (1 << 2);
break;
case ES8311_RESOLUTION_24:
*reg |= (0 << 2);
break;
case ES8311_RESOLUTION_32:
*reg |= (4 << 2);
break;
default:
return ESP_ERR_INVALID_ARG;
}
return ESP_OK;
}
static esp_err_t es8311_fmt_config(es8311_handle_t dev, const es8311_resolution_t res_in, const es8311_resolution_t res_out)
{
uint8_t reg09 = 0; // SDP In
uint8_t reg0a = 0; // SDP Out
ESP_LOGI(TAG, "ES8311 in Slave mode and I2S format");
uint8_t reg00;
ESP_RETURN_ON_ERROR(es8311_read_reg(dev, ES8311_RESET_REG00, &reg00), TAG, "I2C read/write error");
reg00 &= 0xBF;
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_RESET_REG00, reg00), TAG, "I2C read/write error"); // Slave serial port - default
/* Setup SDP In and Out resolution */
es8311_resolution_config(res_in, &reg09);
es8311_resolution_config(res_out, &reg0a);
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_SDPIN_REG09, reg09), TAG, "I2C read/write error");
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_SDPOUT_REG0A, reg0a), TAG, "I2C read/write error");
return ESP_OK;
}
esp_err_t es8311_microphone_config(es8311_handle_t dev, bool digital_mic)
{
uint8_t reg14 = 0x1A; // enable analog MIC and max PGA gain
/* PDM digital microphone enable or disable */
if (digital_mic) {
reg14 |= BIT(6);
}
es8311_write_reg(dev, ES8311_ADC_REG17, 0xC8); // Set ADC gain @todo move this to ADC config section
return es8311_write_reg(dev, ES8311_SYSTEM_REG14, reg14);
}
esp_err_t es8311_init(es8311_handle_t dev, const es8311_clock_config_t *const clk_cfg, const es8311_resolution_t res_in, const es8311_resolution_t res_out)
{
ESP_RETURN_ON_FALSE(
(clk_cfg->sample_frequency >= 8000) && (clk_cfg->sample_frequency <= 96000),
ESP_ERR_INVALID_ARG, TAG, "ES8311 init needs frequency in interval [8000; 96000] Hz"
);
if (!clk_cfg->mclk_from_mclk_pin) {
ESP_RETURN_ON_FALSE(res_out == res_in, ESP_ERR_INVALID_ARG, TAG, "Resolution IN/OUT must be equal if MCLK is taken from SCK pin");
}
/* Reset ES8311 to its default */
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_RESET_REG00, 0x1F), TAG, "I2C read/write error");
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_RESET_REG00, 0x00), TAG, "I2C read/write error");
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_RESET_REG00, 0x80), TAG, "I2C read/write error"); // Power-on command
/* Setup clock: source, polarity and clock dividers */
ESP_RETURN_ON_ERROR(es8311_clock_config(dev, clk_cfg, res_out), TAG, "");
/* Setup audio format (fmt): master/slave, resolution, I2S */
ESP_RETURN_ON_ERROR(es8311_fmt_config(dev, res_in, res_out), TAG, "");
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_SYSTEM_REG0D, 0x01), TAG, "I2C read/write error"); // Power up analog circuitry - NOT default
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_SYSTEM_REG0E, 0x02), TAG, "I2C read/write error"); // Enable analog PGA, enable ADC modulator - NOT default
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_SYSTEM_REG12, 0x00), TAG, "I2C read/write error"); // power-up DAC - NOT default
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_SYSTEM_REG13, 0x10), TAG, "I2C read/write error"); // Enable output to HP drive - NOT default
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_ADC_REG1C, 0x6A), TAG, "I2C read/write error"); // ADC Equalizer bypass, cancel DC offset in digital domain
ESP_RETURN_ON_ERROR(es8311_write_reg(dev, ES8311_DAC_REG37, 0x08), TAG, "I2C read/write error"); // Bypass DAC equalizer - NOT default
return ESP_OK;
}
void es8311_delete(es8311_handle_t dev)
{
free(dev);
}
esp_err_t es8311_voice_volume_set(es8311_handle_t dev, int volume, int *volume_set)
{
if (volume < 0) {
volume = 0;
} else if (volume > 100) {
volume = 100;
}
int reg32;
if (volume == 0) {
reg32 = 0;
} else {
reg32 = ((volume) * 256 / 100) - 1;
}
// provide user with real volume set
if (volume_set != NULL) {
*volume_set = volume;
}
return es8311_write_reg(dev, ES8311_DAC_REG32, reg32);
}
esp_err_t es8311_voice_volume_get(es8311_handle_t dev, int *volume)
{
uint8_t reg32;
ESP_RETURN_ON_ERROR(es8311_read_reg(dev, ES8311_DAC_REG32, &reg32), TAG, "I2C read/write error");
if (reg32 == 0) {
*volume = 0;
} else {
*volume = ((reg32 * 100) / 256) + 1;
}
return ESP_OK;
}
esp_err_t es8311_voice_mute(es8311_handle_t dev, bool mute)
{
uint8_t reg31;
ESP_RETURN_ON_ERROR(es8311_read_reg(dev, ES8311_DAC_REG31, &reg31), TAG, "I2C read/write error");
if (mute) {
reg31 |= BIT(6) | BIT(5);
} else {
reg31 &= ~(BIT(6) | BIT(5));
}
return es8311_write_reg(dev, ES8311_DAC_REG31, reg31);
}
esp_err_t es8311_microphone_gain_set(es8311_handle_t dev, es8311_mic_gain_t gain_db)
{
return es8311_write_reg(dev, ES8311_ADC_REG16, gain_db); // ADC gain scale up
}
esp_err_t es8311_voice_fade(es8311_handle_t dev, const es8311_fade_t fade)
{
uint8_t reg37;
ESP_RETURN_ON_ERROR(es8311_read_reg(dev, ES8311_DAC_REG37, &reg37), TAG, "I2C read/write error");
reg37 &= 0x0F;
reg37 |= (fade << 4);
return es8311_write_reg(dev, ES8311_DAC_REG37, reg37);
}
esp_err_t es8311_microphone_fade(es8311_handle_t dev, const es8311_fade_t fade)
{
uint8_t reg15;
ESP_RETURN_ON_ERROR(es8311_read_reg(dev, ES8311_ADC_REG15, &reg15), TAG, "I2C read/write error");
reg15 &= 0x0F;
reg15 |= (fade << 4);
return es8311_write_reg(dev, ES8311_ADC_REG15, reg15);
}
void es8311_register_dump(es8311_handle_t dev)
{
for (int reg = 0; reg < 0x4A; reg++) {
uint8_t value;
ESP_ERROR_CHECK(es8311_read_reg(dev, reg, &value));
printf("REG:%02x: %02x", reg, value);
}
}
es8311_handle_t es8311_create(const unsigned int port, const uint16_t dev_addr)
{
es8311_dev_t *sensor = (es8311_dev_t *) calloc(1, sizeof(es8311_dev_t));
sensor->port = port;
sensor->dev_addr = dev_addr;
return (es8311_handle_t) sensor;
}
@@ -0,0 +1,227 @@
/*
* SPDX-FileCopyrightText: 2015-2022 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
/**
* @file
* @brief ES8311 driver
*/
#pragma once
#include "esp_types.h"
#include "esp_err.h"
/* ES8311 address: CE pin low - 0x18, CE pin high - 0x19 */
#define ES8311_ADDRRES_0 0x18u // Leaving this here for backward compatibility
#define ES8311_ADDRESS_0 0x18u
#define ES8311_ADDRESS_1 0x19u
#ifdef __cplusplus
extern "C" {
#endif
typedef void *es8311_handle_t;
typedef enum {
ES8311_MIC_GAIN_MIN = -1,
ES8311_MIC_GAIN_0DB,
ES8311_MIC_GAIN_6DB,
ES8311_MIC_GAIN_12DB,
ES8311_MIC_GAIN_18DB,
ES8311_MIC_GAIN_24DB,
ES8311_MIC_GAIN_30DB,
ES8311_MIC_GAIN_36DB,
ES8311_MIC_GAIN_42DB,
ES8311_MIC_GAIN_MAX
} es8311_mic_gain_t;
typedef enum {
ES8311_FADE_OFF = 0,
ES8311_FADE_4LRCK, // 4LRCK means ramp 0.25dB/4LRCK
ES8311_FADE_8LRCK,
ES8311_FADE_16LRCK,
ES8311_FADE_32LRCK,
ES8311_FADE_64LRCK,
ES8311_FADE_128LRCK,
ES8311_FADE_256LRCK,
ES8311_FADE_512LRCK,
ES8311_FADE_1024LRCK,
ES8311_FADE_2048LRCK,
ES8311_FADE_4096LRCK,
ES8311_FADE_8192LRCK,
ES8311_FADE_16384LRCK,
ES8311_FADE_32768LRCK,
ES8311_FADE_65536LRCK
} es8311_fade_t;
typedef enum es8311_resolution_t {
ES8311_RESOLUTION_16 = 16,
ES8311_RESOLUTION_18 = 18,
ES8311_RESOLUTION_20 = 20,
ES8311_RESOLUTION_24 = 24,
ES8311_RESOLUTION_32 = 32
} es8311_resolution_t;
typedef struct es8311_clock_config_t {
bool mclk_inverted;
bool sclk_inverted;
bool mclk_from_mclk_pin; // true: from MCLK pin (pin no. 2), false: from SCLK pin (pin no. 6)
int mclk_frequency; // This parameter is ignored if MCLK is taken from SCLK pin
int sample_frequency; // in Hz
} es8311_clock_config_t;
/**
* @brief Initialize ES8311
*
* There are two ways of providing Master Clock (MCLK) signal to ES8311 in Slave Mode:
* 1. From MCLK pin:
* For flexible scenarios. A clock signal from I2S master is routed to MCLK pin.
* Its frequency must be defined in clk_cfg->mclk_frequency parameter.
* 2. From SCLK pin:
* For simpler scenarios. ES8311 takes its clock from SCK pin. MCLK pin does not have to be connected.
* In this case, res_in must equal res_out; clk_cfg->mclk_frequency parameter is ignored
* and MCLK is calculated as MCLK = clk_cfg->sample_frequency * res_out * 2.
* Not all sampling frequencies are supported in this mode.
*
* @param dev ES8311 handle
* @param[in] clk_cfg Clock configuration
* @param[in] res_in Input serial port resolution
* @param[in] res_out Output serial port resolution
* @return
* - ESP_OK success
* - ESP_ERR_INVALID_ARG Sample frequency or resolution invalid
* - Else fail
*/
esp_err_t es8311_init(es8311_handle_t dev, const es8311_clock_config_t *const clk_cfg, const es8311_resolution_t res_in,
const es8311_resolution_t res_out);
/**
* @brief Set output volume
*
* Volume paramter out of <0, 100> interval will be truncated.
*
* @param dev ES8311 handle
* @param[in] volume Set volume (0 ~ 100)
* @param[out] volume_set Volume that was set. Same as volume, unless volume is outside of <0, 100> interval.
* This parameter can be set to NULL, if user does not need this information.
*
* @return
* - ESP_OK success
* - Else fail
*/
esp_err_t es8311_voice_volume_set(es8311_handle_t dev, int volume, int *volume_set);
/**
* @brief Get output volume
*
* @param dev ES8311 handle
* @param[out] volume get volume (0 ~ 100)
*
* @return
* - ESP_OK success
* - Else fail
*/
esp_err_t es8311_voice_volume_get(es8311_handle_t dev, int *volume);
/**
* @brief Print out ES8311 register content
*
* @param dev ES8311 handle
*/
void es8311_register_dump(es8311_handle_t dev);
/**
* @brief Mute ES8311 output
*
* @param dev ES8311 handle
* @param[in] enable true: mute, false: don't mute
* @return
* - ESP_OK success
* - Else fail
*/
esp_err_t es8311_voice_mute(es8311_handle_t dev, bool enable);
/**
* @brief Set Microphone gain
*
* @param dev ES8311 handle
* @param[in] gain_db Microphone gain
* @return
* - ESP_OK success
* - Else fail
*/
esp_err_t es8311_microphone_gain_set(es8311_handle_t dev, es8311_mic_gain_t gain_db);
/**
* @brief Configure microphone
*
* @param dev ES8311 handle
* @param[in] digital_mic Set to true for digital microphone
* @return
* - ESP_OK success
* - Else fail
*/
esp_err_t es8311_microphone_config(es8311_handle_t dev, bool digital_mic);
/**
* @brief Configure sampling frequency
*
* @note This function is called by es8311_init().
* Call this function explicitly only if you want to change sample frequency during runtime.
* @param dev ES8311 handle
* @param[in] mclk_frequency MCLK frequency in [Hz] (MCLK or SCLK pin, depending on bit register01[7])
* @param[in] sample_frequency Required sample frequency in [Hz], e.g. 44100, 22050...
* @return
* - ESP_OK success
* - ESP_ERR_INVALID_ARG cannot set clock dividers for given MCLK and sampling frequency
* - Else I2C read/write error
*/
esp_err_t es8311_sample_frequency_config(es8311_handle_t dev, int mclk_frequency, int sample_frequency);
/**
* @brief Configure fade in/out for ADC: voice
*
* @param dev ES8311 handle
* @param[in] fade Fade ramp rate
* @return
* - ESP_OK success
* - Else I2C read/write error
*/
esp_err_t es8311_voice_fade(es8311_handle_t dev, const es8311_fade_t fade);
/**
* @brief Configure fade in/out for DAC: microphone
*
* @param dev ES8311 handle
* @param[in] fade Fade ramp rate
* @return
* - ESP_OK success
* - Else I2C read/write error
*/
esp_err_t es8311_microphone_fade(es8311_handle_t dev, const es8311_fade_t fade);
/**
* @brief Create ES8311 object and return its handle
*
* @param[in] port I2C port number
* @param[in] dev_addr I2C device address of ES8311
*
* @return
* - NULL Fail
* - Others Success
*/
es8311_handle_t es8311_create(const unsigned int port, const uint16_t dev_addr);
/**
* @brief Delete ES8311 object
*
* @param dev ES8311 handle
*/
void es8311_delete(es8311_handle_t dev);
#ifdef __cplusplus
}
#endif
@@ -0,0 +1,76 @@
/*
* SPDX-FileCopyrightText: 2015-2021 Espressif Systems (Shanghai) CO LTD
*
* SPDX-License-Identifier: Apache-2.0
*/
#pragma once
/*
* ES8311_REGISTER NAME_REG_REGISTER ADDRESS
*/
#define ES8311_RESET_REG00 0x00 /*reset digital,csm,clock manager etc.*/
/*
* Clock Scheme Register definition
*/
#define ES8311_CLK_MANAGER_REG01 0x01 /* select clk src for mclk, enable clock for codec */
#define ES8311_CLK_MANAGER_REG02 0x02 /* clk divider and clk multiplier */
#define ES8311_CLK_MANAGER_REG03 0x03 /* adc fsmode and osr */
#define ES8311_CLK_MANAGER_REG04 0x04 /* dac osr */
#define ES8311_CLK_MANAGER_REG05 0x05 /* clk divier for adc and dac */
#define ES8311_CLK_MANAGER_REG06 0x06 /* bclk inverter and divider */
#define ES8311_CLK_MANAGER_REG07 0x07 /* tri-state, lrck divider */
#define ES8311_CLK_MANAGER_REG08 0x08 /* lrck divider */
/*
* SDP
*/
#define ES8311_SDPIN_REG09 0x09 /* dac serial digital port */
#define ES8311_SDPOUT_REG0A 0x0A /* adc serial digital port */
/*
* SYSTEM
*/
#define ES8311_SYSTEM_REG0B 0x0B /* system */
#define ES8311_SYSTEM_REG0C 0x0C /* system */
#define ES8311_SYSTEM_REG0D 0x0D /* system, power up/down */
#define ES8311_SYSTEM_REG0E 0x0E /* system, power up/down */
#define ES8311_SYSTEM_REG0F 0x0F /* system, low power */
#define ES8311_SYSTEM_REG10 0x10 /* system */
#define ES8311_SYSTEM_REG11 0x11 /* system */
#define ES8311_SYSTEM_REG12 0x12 /* system, Enable DAC */
#define ES8311_SYSTEM_REG13 0x13 /* system */
#define ES8311_SYSTEM_REG14 0x14 /* system, select DMIC, select analog pga gain */
/*
* ADC
*/
#define ES8311_ADC_REG15 0x15 /* ADC, adc ramp rate, dmic sense */
#define ES8311_ADC_REG16 0x16 /* ADC */
#define ES8311_ADC_REG17 0x17 /* ADC, volume */
#define ES8311_ADC_REG18 0x18 /* ADC, alc enable and winsize */
#define ES8311_ADC_REG19 0x19 /* ADC, alc maxlevel */
#define ES8311_ADC_REG1A 0x1A /* ADC, alc automute */
#define ES8311_ADC_REG1B 0x1B /* ADC, alc automute, adc hpf s1 */
#define ES8311_ADC_REG1C 0x1C /* ADC, equalizer, hpf s2 */
/*
* DAC
*/
#define ES8311_DAC_REG31 0x31 /* DAC, mute */
#define ES8311_DAC_REG32 0x32 /* DAC, volume */
#define ES8311_DAC_REG33 0x33 /* DAC, offset */
#define ES8311_DAC_REG34 0x34 /* DAC, drc enable, drc winsize */
#define ES8311_DAC_REG35 0x35 /* DAC, drc maxlevel, minilevel */
#define ES8311_DAC_REG37 0x37 /* DAC, ramprate */
/*
*GPIO
*/
#define ES8311_GPIO_REG44 0x44 /* GPIO, dac2adc for test */
#define ES8311_GP_REG45 0x45 /* GP CONTROL */
/*
* CHIP
*/
#define ES8311_CHD1_REGFD 0xFD /* CHIP ID1 */
#define ES8311_CHD2_REGFE 0xFE /* CHIP ID2 */
#define ES8311_CHVER_REGFF 0xFF /* VERSION */
#define ES8311_CHD1_REGFD 0xFD /* CHIP ID1 */
#define ES8311_MAX_REGISTER 0xFF
@@ -0,0 +1,866 @@
#include <Arduino.h>
#include <Wire.h>
#include <Preferences.h>
#include <WiFi.h>
#include <time.h>
#include <sys/time.h>
#include <FFat.h>
#include <esp_sntp.h>
#include <Arduino_GFX_Library.h>
#include <TouchDrvCSTXXX.hpp>
#include <lvgl.h>
#define XPOWERS_CHIP_AXP2101
#include <XPowersLib.h>
#include "ESP_I2S.h"
#include "es8311.h"
void setup();
void loop();
// Manual Monitor LVGL V2.1: swapped physical buttons, inverted orientation phases, edge-controlled AMOLED.
#define PIN_LCD_CS 12
#define PIN_LCD_SCLK 38
#define PIN_LCD_D0 4
#define PIN_LCD_D1 5
#define PIN_LCD_D2 6
#define PIN_LCD_D3 7
#define PIN_LCD_RST 2
#define PIN_I2C_SDA 15
#define PIN_I2C_SCL 14
#define PIN_TP_INT 11
#define PIN_INHALE 18
#define PIN_EXHALE 0
#define PIN_PA 46
#define PIN_I2S_BCLK 9
#define PIN_I2S_LRCK 45
#define PIN_I2S_DOUT 8
#define PIN_I2S_DIN 10
#define PIN_I2S_MCLK 42
static constexpr uint16_t DISP_W = 480, DISP_H = 480;
static constexpr uint32_t LVGL_TICK_MS = 2, UI_MS = 120;
static constexpr uint32_t DEBOUNCE_MS = 45, BATT_MS = 5000;
static constexpr uint32_t QUIET_START_MS = 30000, LOUD_START_MS = 60000;
static constexpr uint32_t SLOW_LOUD_MS = 90000, POWER_OFF_MS = 390000;
static constexpr uint16_t LIMITS[] = {5, 7, 10, 15, 20};
static constexpr uint32_t SCREEN_TIMEOUTS[] = {10000, 30000, 60000, 0};
static const char *SCREEN_TIMEOUT_NAMES[] = {"10 sec", "30 sec", "60 sec", "Always on"};
static const int16_t TICK_VOLUME[] = {0, 40, 80, 140, 220, 320, 440, 580, 720, 800, 1600};
static const int16_t ALERT_VOLUME[] = {0, 150, 300, 500, 800, 12000, 12000, 12000, 12000, 12000, 12000};
Arduino_DataBus *gBus = new Arduino_ESP32QSPI(PIN_LCD_CS, PIN_LCD_SCLK, PIN_LCD_D0, PIN_LCD_D1, PIN_LCD_D2, PIN_LCD_D3);
Arduino_CO5300 *gfx = new Arduino_CO5300(gBus, PIN_LCD_RST, 0, DISP_W, DISP_H, 0, 0, 0, 0);
TouchDrvCST92xx gTouch;
XPowersPMU gPower;
I2SClass gI2s;
Preferences gPrefs;
struct Button { int pin; bool raw = false; bool stable = false; uint32_t changed = 0; uint32_t pressed = 0; };
static Button gInhale{PIN_INHALE}, gExhale{PIN_EXHALE};
static bool gRotation=false,gImuOk=false,gRotationArmed=false;
static bool gWifiEnabled=false;
static int8_t gOrientation=-1,gOrientationCandidate=-1;
static uint32_t gOrientationChanged=0,gOrientationSample=0;
// QMI8658 screen-axis mapping: change sign if the TOP edge maps to negative Y.
static constexpr int8_t IMU_TOP_EDGE_Y_SIGN = 1;
// 0: face up/down; 1: edge up; 2: screen top edge up; 3: another edge up.
static int8_t gScreenEdgeOrientation=-1,gScreenEdgeCandidate=-1;
static uint32_t gScreenEdgeChanged=0;
static bool gExhaleLongDone=false;
enum class Screen : uint8_t { Home, Monitor, Settings, Wifi, WifiPassword, Time, ManualTime };
static Screen gScreen = Screen::Home;
static bool gPowerReady = false, gAudioReady = false, gTouchDown = false;
static uint32_t gLastPowerLong = 0;
static uint32_t gKey1WakeUntil = 0;
static bool gScreenOn = true, gPaused = false;
enum class BreathState : uint8_t { Waiting, Inhale, Exhale };
static BreathState gBreath = BreathState::Waiting;
static uint64_t gCompletedMs = 0;
static uint32_t gPhaseStarted = 0, gCycleStarted = 0, gLastActivity = 0, gLastUi = 0, gLastBatt = 0, gLastReminder = 0;
static uint8_t gLimit = 2, gTick = 3, gAlert = 10, gScreenTimeout = 1;
static uint32_t gCycles[5] = {}; static uint8_t gCycleCount = 0, gCycleNext = 0, gShortStreak = 0;
static lv_disp_draw_buf_t gDrawBuf; static lv_color_t *gBuf1 = nullptr, *gBuf2 = nullptr;
static lv_obj_t *gRoot=nullptr, *gState=nullptr, *gPhaseTime=nullptr, *gCycleValue=nullptr;
static lv_obj_t *gAverageValue=nullptr, *gElapsedValue=nullptr, *gLimitValue=nullptr;
static lv_obj_t *gHistory[5]={}, *gPausedBanner=nullptr;
static lv_obj_t *gBatteryText=nullptr, *gBatteryFill=nullptr, *gBolt=nullptr, *gWifiText=nullptr,*gClockText=nullptr,*gRotationMark=nullptr;
static lv_obj_t *gTimeCurrent=nullptr,*gTimeStatus=nullptr,*gAutoCheck=nullptr,*gTzDropdown=nullptr;
static lv_obj_t *gManualPreview=nullptr;
static int gTzDraft=60, gManualField=0;
static int gManualParts[5]={2026,1,1,12,0};
static String gManualDigits="";
static lv_obj_t *gWifiList=nullptr, *gPasswordField=nullptr, *gPasswordKeyboard=nullptr;
static bool gKbSymbols=false,gKbShift=false,gKbPage=false,gKbShowPassword=false;
static String gKbValue="";
static void wifiPasswordScreen();
static String gSavedSsid[8], gSavedPass[8], gScannedSsid[20], gSelectedSsid;
static int32_t gScannedRssi[20];
static uint8_t gScannedCount=0;
static bool gWifiScanActive=false, gWifiConnecting=false, gWifiManual=false;
static void wifiEnable(bool enabled);
static int8_t gAttemptedSaved=-1;
static uint8_t gAttemptMask=0;
static uint32_t gWifiStarted=0, gWifiNextScan=0, gWifiLastStatus=0;
static String gWifiNotice="", gPendingPassword="";
static void wifiScreen(lv_event_t * = nullptr);
static void wifiPasswordScreen();
static void wifiTick();
static void wifiScan(bool manual);
static void wifiConnect(const String &ssid,const String &password,bool manual);
static void wifiLoad();
static void timeScreen(lv_event_t * = nullptr);
static void manualTimeScreen();
static void timeUiTick();
static bool gAutoSync=true,gTimeValid=false,gNtpPending=false,gFileReady=false;
static int16_t gTimezoneMinutes=60;
static uint32_t gNtpStart=0,gLastNtp=0,gEventSeq=0;
static uint64_t gCycleUtcMs=0;
static bool appendEvent(uint8_t type,uint64_t timestamp=UINT64_MAX,uint16_t inh=0,uint16_t exh=0,uint16_t avg=0,uint16_t deficit=0,int16_t val=0);
static uint32_t gInhaleDuration=0;
static bool gInhaleExceeded=false,gExhaleExceeded=false;
// RTC PCF85063A/T (I2C 0x51). Keep RTC and stored event timestamps in UTC.
static uint8_t bcd(uint8_t v){return (v/10)*16+(v%10);}
static uint8_t unbcd(uint8_t v){return (v>>4)*10+(v&15);}
static bool rtcRead(time_t &epoch){
Wire.beginTransmission(0x51);Wire.write(0x04);
if(Wire.endTransmission(false)!=0 || Wire.requestFrom((uint8_t)0x51,(uint8_t)7)!=7)return false;
uint8_t d[7];for(int i=0;i<7;i++)d[i]=Wire.read();
if(d[0]&0x80)return false; // oscillator stopped: unreliable calendar
tm t={};t.tm_sec=unbcd(d[0]&0x7f);t.tm_min=unbcd(d[1]&0x7f);t.tm_hour=unbcd(d[2]&0x3f);
t.tm_mday=unbcd(d[3]&0x3f);t.tm_mon=unbcd(d[5]&0x1f)-1;t.tm_year=unbcd(d[6])+100;
if(t.tm_year<124||t.tm_year>199||t.tm_mon<0||t.tm_mon>11||t.tm_mday<1||t.tm_mday>31||t.tm_hour>23||t.tm_min>59||t.tm_sec>59)return false;
// Convert Gregorian UTC date to Unix seconds without non-portable timegm().
int y=t.tm_year+1900,m=t.tm_mon+1,day=t.tm_mday;
y -= m<=2;
const int era=(y>=0?y:y-399)/400;
const unsigned yoe=(unsigned)(y-era*400);
const unsigned mp=(unsigned)(m+(m>2?-3:9));
const unsigned doy=(153*mp+2)/5+(unsigned)day-1;
const unsigned doe=yoe*365+yoe/4-yoe/100+doy;
int64_t days=(int64_t)era*146097+(int64_t)doe-719468;
epoch=(time_t)(days*86400+t.tm_hour*3600+t.tm_min*60+t.tm_sec);
return epoch>1700000000;
}
static bool rtcWrite(time_t epoch){
tm t={};gmtime_r(&epoch,&t);
if(t.tm_year<100||t.tm_year>199)return false;
Wire.beginTransmission(0x51);Wire.write(0x04);
uint8_t d[7]={bcd(t.tm_sec),bcd(t.tm_min),bcd(t.tm_hour),bcd(t.tm_mday),bcd(t.tm_wday),bcd(t.tm_mon+1),bcd(t.tm_year-100)};
Wire.write(d,7);return Wire.endTransmission()==0;
}
static uint64_t unixMs(){if(!gTimeValid)return 0;timeval tv={};gettimeofday(&tv,nullptr);return (uint64_t)tv.tv_sec*1000ULL+tv.tv_usec/1000;}
static void initClock(){time_t v;if(rtcRead(v)){timeval tv={};tv.tv_sec=v;settimeofday(&tv,nullptr);gTimeValid=true;}}
static void requestNtp(){if(WiFi.status()!=WL_CONNECTED)return;gNtpPending=true;gNtpStart=millis();
// configTime starts SNTP asynchronously; system timezone remains UTC.
configTime(0,0,"pool.ntp.org","time.google.com");
}
static void ntpTick(){
if(!gNtpPending)return;
if(millis()-gNtpStart>18000){gNtpPending=false;return;}
time_t e=time(nullptr);
if(e>1750000000 && sntp_get_sync_status()==SNTP_SYNC_STATUS_COMPLETED){
rtcWrite(e);gTimeValid=true;gNtpPending=false;gLastNtp=millis();appendEvent(9);
}
}
// FFat append-only record. Fixed 32 bytes, versioned + CRC32; zero UTC flags untrusted clock.
// All numerical fields little-endian on ESP32. CRC is over first 28 bytes.
// type:1 cycle,2 boot,3 shutdown,4 pause,5 resume,6 limit,7 inhaleLong,8 exhaleLong,9 sync,10 rotation.
struct __attribute__((packed)) EventRecord {
uint8_t version,type,flags,reserved;
uint32_t seq;
uint64_t utcMs;
uint16_t inhale10,exhale10,avg10,shortfall10;
int16_t value;
uint16_t spare;
uint32_t crc;
};
static_assert(sizeof(EventRecord)==32,"Event size should be 32 bytes");
static uint32_t crc32(const uint8_t *data,size_t size){uint32_t c=~0u;while(size--){c^=*data++;for(int j=0;j<8;j++)c=(c>>1)^((c&1)?0xedb88320u:0u);}return ~c;}
static bool appendEvent(uint8_t type,uint64_t timestamp,uint16_t inh,uint16_t exh,uint16_t avg,uint16_t deficit,int16_t val){
if(!gFileReady)return false;
EventRecord e={};e.version=1;e.type=type;e.flags=gTimeValid?1:0;e.seq=++gEventSeq;
e.utcMs=(timestamp==UINT64_MAX)?unixMs():timestamp;
if(e.utcMs==0)e.flags=0;
e.inhale10=inh;e.exhale10=exh;e.avg10=avg;e.shortfall10=deficit;e.value=val;
e.crc=crc32((const uint8_t*)&e,28);
File f=FFat.open("/events.bin","a");if(!f)return false;
bool ok=f.write((const uint8_t*)&e,sizeof(e))==sizeof(e);f.flush();f.close();return ok;
}
static void initEvents(){
gFileReady=FFat.begin(false);
if(!gFileReady){
Serial.println("FFat mount failed; formatting filesystem");
gFileReady=FFat.begin(true);
}
if(!gFileReady){Serial.println("FFat unavailable; recording disabled");return;}
File f=FFat.open("/events.bin","r");if(f){EventRecord e;while(f.available()>=(int)sizeof(e)){
if(f.read((uint8_t*)&e,sizeof(e))!=sizeof(e))break;
if(e.version==1 && e.crc==crc32((const uint8_t*)&e,28))gEventSeq=max(gEventSeq,e.seq);
}f.close();}
}
// QMI8658: I2C 0x6A/0x6B; accelerometer +/-2g, 125Hz ODR (register defaults tested by WHO_AM_I).
static uint8_t gImuAddr=0;
static bool imuRead(uint8_t reg,uint8_t *data,uint8_t count){
Wire.beginTransmission(gImuAddr);Wire.write(reg);
if(Wire.endTransmission(false)!=0||Wire.requestFrom(gImuAddr,count)!=count)return false;
for(int i=0;i<count;i++)data[i]=Wire.read();return true;
}
static bool imuWrite(uint8_t reg,uint8_t val){Wire.beginTransmission(gImuAddr);Wire.write(reg);Wire.write(val);return Wire.endTransmission()==0;}
static void initImu(){for(uint8_t addr:{(uint8_t)0x6A,(uint8_t)0x6B}){
gImuAddr=addr;uint8_t id;if(imuRead(0x00,&id,1)&&id==0x05){
imuWrite(0x02,0x60); // auto-increment + little endian for burst
imuWrite(0x03,0x05); // accelerometer 2g, 125Hz
imuWrite(0x08,0x01); // enable accelerometer only
gImuOk=true;break;
}
}if(!gImuOk)Serial.println("QMI8658 unavailable; rotation disabled");
}
static void pollOrientation();
static lv_color_t color(uint32_t c) { return lv_color_hex(c); }
static void flush(lv_disp_drv_t *d, const lv_area_t *a, lv_color_t *p) {
uint32_t w = a->x2-a->x1+1, h = a->y2-a->y1+1;
#if LV_COLOR_16_SWAP != 0
gfx->draw16bitBeRGBBitmap(a->x1,a->y1,(uint16_t *)&p->full,w,h);
#else
gfx->draw16bitRGBBitmap(a->x1,a->y1,(uint16_t *)&p->full,w,h);
#endif
lv_disp_flush_ready(d);
}
// CO5300 QSPI: align LVGL partial-refresh rectangles to whole RGB565 pixel pairs.
// This prevents odd-width transfer regions from potentially shifting successive rows.
static void rounder(lv_disp_drv_t *d, lv_area_t *a) {
(void)d;
a->x1 &= ~1;
a->x2 |= 1;
if (a->x1 < 0) a->x1 = 0;
if (a->x2 >= DISP_W) a->x2 = DISP_W - 1;
}
static void tick(void *) { lv_tick_inc(LVGL_TICK_MS); }
static void touchRead(lv_indev_drv_t *, lv_indev_data_t *d) {
int16_t x=0,y=0; bool down = gTouch.getPoint(&x,&y,1)>0;
if (down && !gTouchDown) { gTouchDown=true; gLastActivity=millis(); if (!gScreenOn) { gfx->setBrightness(220); gScreenOn=true; } }
if (!down) gTouchDown=false;
d->state=down ? LV_INDEV_STATE_PR : LV_INDEV_STATE_REL; d->point.x=x; d->point.y=y;
}
static void card(lv_obj_t *o, uint32_t bg=0x142331) { lv_obj_set_style_bg_color(o,color(bg),0); lv_obj_set_style_border_color(o,color(0x365264),0); lv_obj_set_style_border_width(o,1,0); lv_obj_set_style_radius(o,14,0); lv_obj_clear_flag(o,LV_OBJ_FLAG_SCROLLABLE); }
static lv_obj_t *label(lv_obj_t *p,const char *s,const lv_font_t *f,uint32_t c) {
lv_obj_t *o=lv_label_create(p);
lv_label_set_text(o,s);
lv_obj_set_style_text_font(o,f,0);
lv_obj_set_style_text_color(o,color(c),0);
return o;
}
static lv_obj_t *panel(int x,int y,int w,int h,uint32_t bg=0x142331) { lv_obj_t *o=lv_obj_create(gRoot); lv_obj_set_pos(o,x,y); lv_obj_set_size(o,w,h); card(o,bg); return o; }
static void fmt(char *out,size_t n,uint32_t ms) { snprintf(out,n,"%lu.%01lu s",(unsigned long)(ms/1000),(unsigned long)((ms%1000)/100)); }
static uint32_t average() { uint64_t total=0; for(uint8_t i=0;i<gCycleCount;i++) total+=gCycles[i]; return gCycleCount ? (uint32_t)((total+gCycleCount/2)/gCycleCount) : 0; }
static void loadSettings() { gPrefs.begin("manual-lvgl",false); gLimit=min<uint8_t>(4,gPrefs.getUChar("limit",2)); gTick=min<uint8_t>(10,gPrefs.getUChar("tick",3)); gAlert=min<uint8_t>(10,gPrefs.getUChar("alert",10)); gScreenTimeout=min<uint8_t>(3,gPrefs.getUChar("screen",1));gRotation=gPrefs.getBool("rotation",false);gAutoSync=gPrefs.getBool("autosync",true);gTimezoneMinutes=gPrefs.getShort("timezone",60);gWifiEnabled=gPrefs.getBool("wifi_on",false); }
static void saveSettings() { gPrefs.putUChar("limit",gLimit); gPrefs.putUChar("tick",gTick); gPrefs.putUChar("alert",gAlert); gPrefs.putUChar("screen",gScreenTimeout);gPrefs.putBool("rotation",gRotation);gPrefs.putBool("autosync",gAutoSync);gPrefs.putShort("timezone",gTimezoneMinutes);gPrefs.putBool("wifi_on",gWifiEnabled); }
static void initPower() { gPowerReady=gPower.begin(Wire,AXP2101_SLAVE_ADDRESS,PIN_I2C_SDA,PIN_I2C_SCL); if(!gPowerReady)return; gPower.disableIRQ(XPOWERS_AXP2101_ALL_IRQ); gPower.setChargeTargetVoltage(3); gPower.setPowerKeyPressOffTime(XPOWERS_POWEROFF_10S);
// AXP2101 IRQ hold threshold: 0=1s, 1=1.5s, 2=2s, 3=2.5s (reg 0x27, bits 5:4).
Wire.beginTransmission(AXP2101_SLAVE_ADDRESS); Wire.write(0x27);
if(Wire.endTransmission(false)==0 && Wire.requestFrom((uint8_t)AXP2101_SLAVE_ADDRESS,(uint8_t)1)==1){
uint8_t reg=Wire.read(); Wire.beginTransmission(AXP2101_SLAVE_ADDRESS);
Wire.write(0x27);Wire.write((uint8_t)((reg & ~0x30u)|0x10u));Wire.endTransmission();
}
gPower.clearIrqStatus(); gPower.enableIRQ(XPOWERS_AXP2101_PKEY_SHORT_IRQ | XPOWERS_AXP2101_PKEY_LONG_IRQ); gPower.enableBattDetection(); gPower.enableBattVoltageMeasure(); gPower.enableVbusVoltageMeasure(); }
static int battery() { if(!gPowerReady || !gPower.isBatteryConnect())return -1; int percent=constrain(gPower.getBatteryPercent(),0,100); uint16_t mv=gPower.getBattVoltage(); if(percent==0 && mv>=3300) return constrain((int)((mv-3300UL)*100UL/900UL),1,100); return percent; }
static void initAudio() { pinMode(PIN_PA,OUTPUT); digitalWrite(PIN_PA,HIGH); gI2s.setPins(PIN_I2S_BCLK,PIN_I2S_LRCK,PIN_I2S_DOUT,PIN_I2S_DIN,PIN_I2S_MCLK); if(!gI2s.begin(I2S_MODE_STD,16000,I2S_DATA_BIT_WIDTH_16BIT,I2S_SLOT_MODE_STEREO,I2S_STD_SLOT_BOTH))return; es8311_handle_t h=es8311_create(0,ES8311_ADDRRES_0); if(!h)return; es8311_clock_config_t c={false,false,true,4096000,16000}; gAudioReady=es8311_init(h,&c,ES8311_RESOLUTION_16,ES8311_RESOLUTION_16)==ESP_OK; if(gAudioReady){es8311_voice_volume_set(h,100,nullptr);es8311_voice_mute(h,false);} }
static void beep(uint16_t hz,uint16_t count,int16_t amp) { if(!gAudioReady||amp<=0)return; static int16_t buf[1600*2]; count=min<uint16_t>(count,1600); for(uint16_t i=0;i<count;i++){int16_t v=(int16_t)(sinf(6.2831853f*hz*i/16000.0f)*amp);buf[i*2]=v;buf[i*2+1]=v;} gI2s.write((uint8_t *)buf,count*4); }
static void quiet() { beep(880,480,TICK_VOLUME[gTick]); } static void loud(){beep(1200,1600,ALERT_VOLUME[gAlert]);}
static void batteryUi() { if(!gBatteryText)return; int p=battery(); char t[8]; snprintf(t,sizeof(t),p<0?"--":"%d%%",p); lv_label_set_text(gBatteryText,t); if(gBatteryFill)lv_obj_set_width(gBatteryFill,p>0?max(2,min(26,p*26/100)):0); if(gBolt)lv_obj_set_style_opa(gBolt,(gPowerReady&&gPower.isCharging())?LV_OPA_COVER:LV_OPA_TRANSP,0); }
static void topBar(const char *title) {
// On the monitor: Wi-Fi on the left, battery on the right. Other pages: page title.
if(gScreen==Screen::Monitor){
gRotationMark=label(gRoot,"",&lv_font_montserrat_16,0x38B26D);lv_obj_set_pos(gRotationMark,14,51);
gWifiText=label(gRoot,"Wi-Fi: --",&lv_font_montserrat_16,0x9EB4C2);
lv_obj_set_pos(gWifiText,39,51);
lv_obj_set_width(gWifiText,188);
gClockText=label(gRoot,"--:--",&lv_font_montserrat_16,0xFFFFFF);lv_obj_set_pos(gClockText,234,51);
lv_label_set_long_mode(gWifiText,LV_LABEL_LONG_DOT);
}else{
lv_obj_t *heading=label(gRoot,title,&lv_font_montserrat_20,0xFFFFFF);
lv_obj_set_pos(heading,24,48);
}
gBatteryText=label(gRoot,"--",&lv_font_montserrat_16,0xC9D3DE);lv_obj_set_pos(gBatteryText,297,51);
if(gPowerReady){static const lv_point_t bolt[]={{6,0},{1,9},{5,9},{2,18},{10,7},{6,7}};gBolt=lv_line_create(gRoot);lv_line_set_points(gBolt,bolt,6);lv_obj_set_pos(gBolt,337,46);lv_obj_set_style_line_width(gBolt,2,0);lv_obj_set_style_line_color(gBolt,color(0xFFD34D),0);lv_obj_set_style_line_rounded(gBolt,true,0);}
lv_obj_t *b=lv_obj_create(gRoot);lv_obj_set_pos(b,349,53);lv_obj_set_size(b,32,16);lv_obj_set_style_bg_opa(b,LV_OPA_TRANSP,0);lv_obj_set_style_border_color(b,color(0xC9D3DE),0);lv_obj_set_style_border_width(b,2,0);lv_obj_set_style_radius(b,4,0);lv_obj_clear_flag(b,LV_OBJ_FLAG_SCROLLABLE);
lv_obj_t *cap=lv_obj_create(gRoot);lv_obj_set_pos(cap,381,57);lv_obj_set_size(cap,4,8);lv_obj_set_style_bg_color(cap,color(0xC9D3DE),0);lv_obj_set_style_border_width(cap,0,0);lv_obj_set_style_radius(cap,2,0);
gBatteryFill=lv_obj_create(gRoot);lv_obj_set_pos(gBatteryFill,352,56);lv_obj_set_size(gBatteryFill,2,10);lv_obj_set_style_bg_color(gBatteryFill,color(0x38B26D),0);lv_obj_set_style_border_width(gBatteryFill,0,0);lv_obj_set_style_radius(gBatteryFill,2,0);batteryUi();
}
static void clearUi() { lv_obj_clean(lv_scr_act()); gRoot=lv_scr_act(); lv_obj_set_style_bg_color(gRoot,color(0x08111B),0);lv_obj_set_style_bg_opa(gRoot,LV_OPA_COVER,0);lv_obj_set_style_pad_all(gRoot,0,0); gBatteryText=gBatteryFill=gBolt=gWifiText=gWifiList=gPasswordField=gPasswordKeyboard=nullptr;gClockText=gRotationMark=gTimeCurrent=gTimeStatus=gAutoCheck=gTzDropdown=gManualPreview=nullptr; }
static void legend() {
lv_obj_t *l=label(gRoot,"INHALE",&lv_font_montserrat_14,0x38B26D);lv_obj_set_pos(l,90,12);
l=label(gRoot,"SETTINGS",&lv_font_montserrat_14,0xC9D3DE);lv_obj_align(l,LV_ALIGN_TOP_MID,0,12);
l=label(gRoot,"EXHALE",&lv_font_montserrat_14,0x4FB3FF);lv_obj_set_pos(l,338,12);
static const lv_point_t rule[]={{0,0},{432,0}};
lv_obj_t *line=lv_line_create(gRoot);lv_line_set_points(line,rule,2);
lv_obj_set_pos(line,24,37);lv_obj_set_style_line_width(line,1,0);
lv_obj_set_style_line_color(line,color(0x365264),0);
}
static lv_obj_t *metric(int x,int y,const char *caption,uint32_t valueColor) {
lv_obj_t *p=panel(x,y,204,100);lv_obj_t *l=label(p,caption,&lv_font_montserrat_14,0x9EB4C2);
lv_obj_align(l,LV_ALIGN_TOP_MID,0,7);
l=label(p,"--",&lv_font_montserrat_28,valueColor);lv_obj_align(l,LV_ALIGN_CENTER,0,12);
return l;
}
static void enterMonitor(lv_event_t *) {
gScreen=Screen::Monitor;gLastActivity=millis();clearUi();legend();topBar("");
lv_obj_t *hero=panel(24,92,432,73,0x102A36);
gState=label(hero,"WAITING",&lv_font_montserrat_28,0x4FB3FF);
gPhaseTime=label(hero,"",&lv_font_montserrat_28,0xFFFFFF);
gCycleValue=metric(24,182,"CYCLE",0xFFFFFF);
gAverageValue=metric(252,182,"AVG 5",0xFFFFFF);
gElapsedValue=metric(24,298,"ELAPSED",0xFFFFFF);
gLimitValue=metric(252,298,"LIMIT",0xFFD34D);
lv_obj_t *history=panel(24,413,432,53);
lv_obj_t *title=label(history,"HISTORY",&lv_font_montserrat_14,0xC9D3DE);lv_obj_set_pos(title,7,3);
for(int i=0;i<5;i++){gHistory[i]=label(history,"--",&lv_font_montserrat_16,0xFFFFFF);
lv_obj_set_pos(gHistory[i],78+i*68,3);}
}
static void home(lv_event_t *); static void settings(lv_event_t *);
static lv_obj_t *button(lv_obj_t *p,const char *text,int x,int y,int w,int h,uint32_t bg,lv_event_cb_t cb,void *userData=nullptr) { lv_obj_t *b=lv_btn_create(p);lv_obj_set_pos(b,x,y);lv_obj_set_size(b,w,h);card(b,bg);lv_obj_add_event_cb(b,cb,LV_EVENT_CLICKED,userData);lv_obj_t *l=label(b,text,&lv_font_montserrat_20,0xFFFFFF);lv_obj_center(l);return b; }
static void home(lv_event_t *) {enterMonitor(nullptr);}
static void settingChanged(lv_event_t *e){
uint8_t *v=(uint8_t *)lv_event_get_user_data(e);
uint8_t old=*v;*v=lv_slider_get_value(lv_event_get_target(e));
if(old!=*v)saveSettings();
}
static void settingReleased(lv_event_t *e){
if(lv_event_get_user_data(e)==&gLimit)appendEvent(6,UINT64_MAX,0,0,0,0,LIMITS[gLimit]*10);
}
static void refresh();
static void settings(lv_event_t *) {
gScreen=Screen::Settings;clearUi();legend();topBar("SETTINGS");
if(gPaused){gPausedBanner=label(gRoot,"PAUSED",&lv_font_montserrat_20,0xFFD34D);
lv_obj_align(gPausedBanner,LV_ALIGN_TOP_MID,0,32);}
lv_obj_t *list=lv_obj_create(gRoot);lv_obj_set_pos(list,20,91);lv_obj_set_size(list,440,280);
card(list,0x10202D);lv_obj_set_style_pad_all(list,10,0);lv_obj_set_flex_flow(list,LV_FLEX_FLOW_COLUMN);
lv_obj_set_style_pad_row(list,9,0);
struct Item{const char *name;uint8_t *v;uint8_t max;};
Item items[]={{"Breath limit",&gLimit,4},{"Cycle tick",&gTick,10},{"Alert volume",&gAlert,10},{"Screen timeout",&gScreenTimeout,3}};
for(auto &it:items){lv_obj_t *row=lv_obj_create(list);lv_obj_set_size(row,400,67);card(row,0x172C3C);
lv_obj_t *n=label(row,it.name,&lv_font_montserrat_16,0xFFFFFF);lv_obj_set_pos(n,12,6);
lv_obj_t *sl=lv_slider_create(row);lv_obj_set_pos(sl,12,36);lv_obj_set_size(sl,376,16);
lv_slider_set_range(sl,0,it.max);lv_slider_set_value(sl,*it.v,LV_ANIM_OFF);
lv_obj_add_event_cb(sl,settingChanged,LV_EVENT_VALUE_CHANGED,it.v);
if(it.v==&gLimit)lv_obj_add_event_cb(sl,settingReleased,LV_EVENT_RELEASED,it.v);
}
button(gRoot,"Wi-Fi",24,383,132,42,0x214D69,[](lv_event_t *){wifiScreen(nullptr);});
button(gRoot,"TIME",173,383,132,42,0x214D69,[](lv_event_t *){timeScreen(nullptr);});
lv_obj_t *rot=lv_checkbox_create(gRoot);lv_checkbox_set_text(rot,"ROTATION CONTROL");lv_obj_set_pos(rot,32,437);
if(gRotation)lv_obj_add_state(rot,LV_STATE_CHECKED);
lv_obj_add_event_cb(rot,[](lv_event_t *e){gRotation=lv_obj_has_state(lv_event_get_target(e),LV_STATE_CHECKED);gRotationArmed=false;gOrientation=-1;gScreenEdgeOrientation=-1;gScreenEdgeCandidate=-1;saveSettings();appendEvent(10,UINT64_MAX,0,0,0,0,gRotation);},LV_EVENT_VALUE_CHANGED,nullptr);
button(gRoot,"BACK",322,383,132,42,0x214D69,[](lv_event_t *){
if(gPaused){gPaused=false;gBreath=BreathState::Waiting;gRotationArmed=false;gOrientation=-1;gScreenEdgeOrientation=-1;gScreenEdgeCandidate=-1;appendEvent(5);}enterMonitor(nullptr);
});
}
// PMU power key can blank the AMOLED independently of our timeout flag.
// Explicitly wake the panel for any accepted KEY1 action.
static void wakeDisplayFromKey1() {
gLastActivity=millis();
gKey1WakeUntil=gLastActivity+1500;
gScreenOn=true;
gfx->setBrightness(220);
}
static void keyShort(){
wakeDisplayFromKey1();
if(gScreen==Screen::WifiPassword||gScreen==Screen::Wifi||gScreen==Screen::Time||gScreen==Screen::ManualTime){settings(nullptr);}
else if(gScreen==Screen::Settings){if(gPaused){gPaused=false;gBreath=BreathState::Waiting;gRotationArmed=false;gOrientation=-1;gScreenEdgeOrientation=-1;gScreenEdgeCandidate=-1;appendEvent(5);}enterMonitor(nullptr);}
else settings(nullptr);
}
static void keyLong(){
wakeDisplayFromKey1();
if(!gPaused){gPaused=true;gBreath=BreathState::Waiting;gCycleStarted=0;gPhaseStarted=0;gRotationArmed=false;gOrientation=-1;gScreenEdgeOrientation=-1;gScreenEdgeCandidate=-1;appendEvent(4);}
settings(nullptr);
}
// Key1 is PMU PWRON (AXP2101), not a GPIO. Handle short/long PMU IRQs.
static void pollPowerKey(){
if(!gPowerReady)return;
gPower.getIrqStatus();
bool longPress=gPower.isPekeyLongPressIrq();
bool shortPress=gPower.isPekeyShortPressIrq();
if(longPress||shortPress){gPower.clearIrqStatus();wakeDisplayFromKey1();
if(longPress){gLastPowerLong=millis();keyLong();}
else if(millis()-gLastPowerLong>750)keyShort();}
}
static void addCycle(uint32_t ms,uint32_t inhaleMs){
if(!ms)return;
gCompletedMs+=ms;gCycles[gCycleNext]=ms;gCycleNext=(gCycleNext+1)%5;
if(gCycleCount<5)gCycleCount++;
uint32_t a=average();
uint16_t inh10=min<uint32_t>(65535,(inhaleMs+50)/100),exh10=min<uint32_t>(65535,(ms-inhaleMs+50)/100);
uint16_t avg10=min<uint32_t>(65535,(a+50)/100);
uint16_t missing=min<uint32_t>(65535,ms<LIMITS[gLimit]*1000UL?(LIMITS[gLimit]*1000UL-ms+50)/100:0);
appendEvent(1,gCycleUtcMs,inh10,exh10,avg10,missing);
if(a && a<LIMITS[gLimit]*1000UL){
gShortStreak=min<uint8_t>(5,gShortStreak+1);
for(uint8_t i=0;i<gShortStreak;i++){loud();delay(80);}
}else gShortStreak=0;
}
static void phase(bool inhale){
if(gPaused)return;
uint32_t now=millis();
if(inhale){
if(gBreath==BreathState::Inhale)return;
if(gBreath==BreathState::Exhale)addCycle(now-gCycleStarted,gInhaleDuration);
gBreath=BreathState::Inhale;gCycleStarted=now;gPhaseStarted=now;gCycleUtcMs=unixMs();gInhaleExceeded=false;gExhaleExceeded=false;quiet();
}else{
if(gBreath!=BreathState::Inhale)return;
gInhaleDuration=now-gPhaseStarted;gBreath=BreathState::Exhale;gPhaseStarted=now;quiet();
}
gLastReminder=now;
}
static void poll(Button &b,bool inhale){
uint32_t now=millis();bool raw=digitalRead(b.pin)==LOW;
if(raw!=b.raw){b.raw=raw;b.changed=now;}
if(b.stable==b.raw||now-b.changed<DEBOUNCE_MS){
if(!inhale&&b.stable&&!gExhaleLongDone&&now-b.pressed>=2000){
gExhaleLongDone=true;gRotation=true;gRotationArmed=false;gOrientation=-1;gScreenEdgeOrientation=-1;gScreenEdgeCandidate=-1;saveSettings();appendEvent(10,UINT64_MAX,0,0,0,0,gRotation);
}return;}
b.stable=b.raw;if(b.stable){b.pressed=now;if(!inhale)gExhaleLongDone=false;gLastActivity=now;
if(gRotation){gRotation=false;gRotationArmed=false;gOrientation=-1;gScreenEdgeOrientation=-1;gScreenEdgeCandidate=-1;gOrientationCandidate=-1;saveSettings();appendEvent(10,UINT64_MAX,0,0,0,0,0);}
if(!gScreenOn){gScreenOn=true;gfx->setBrightness(220);}
phase(inhale);
}
}
static void refresh(){
if(gScreen!=Screen::Monitor)return;
uint32_t now=millis();char t[24];
if(gRotationMark)lv_label_set_text(gRotationMark,gRotation?"✓":"");
if(gClockText){time_t e=time(nullptr);char clockbuf[12]="--:--";if(gTimeValid&&e>1700000000){e+=(int32_t)gTimezoneMinutes*60;tm tmv={};gmtime_r(&e,&tmv);snprintf(clockbuf,sizeof(clockbuf),"%02d:%02d",tmv.tm_hour,tmv.tm_min);}lv_label_set_text(gClockText,clockbuf);}
if(gWifiText){
String wi = !gWifiEnabled?String("Wi-Fi: off"):(WiFi.status()==WL_CONNECTED ? String("Wi-Fi: ")+WiFi.SSID() : (gWifiConnecting?"Wi-Fi: connecting":"Wi-Fi: none"));
lv_label_set_text(gWifiText,wi.c_str());
lv_obj_set_style_text_color(gWifiText,color(WiFi.status()==WL_CONNECTED?0x38B26D:0x9EB4C2),0);
}
const char *state=gBreath==BreathState::Waiting?"WAITING":gBreath==BreathState::Inhale?"INHALE":"EXHALE";
lv_label_set_text(gState,state);
lv_obj_set_style_text_color(gState,color(gBreath==BreathState::Inhale?0x38B26D:0x4FB3FF),0);
if(gBreath==BreathState::Waiting)lv_label_set_text(gPhaseTime,"");
else{fmt(t,sizeof(t),now-gPhaseStarted);lv_label_set_text(gPhaseTime,t);}
// Center phase and white phase timer as one horizontal group.
lv_obj_update_layout(gState);lv_obj_update_layout(gPhaseTime);
int w=lv_obj_get_width(gState)+(gBreath==BreathState::Waiting?0:14+lv_obj_get_width(gPhaseTime));
lv_obj_set_pos(gState,(432-w)/2,14);
lv_obj_set_pos(gPhaseTime,(432-w)/2+lv_obj_get_width(gState)+14,14);
lv_obj_align(gCycleValue,LV_ALIGN_CENTER,0,12);
lv_obj_align(gAverageValue,LV_ALIGN_CENTER,0,12);
lv_obj_align(gElapsedValue,LV_ALIGN_CENTER,0,12);
lv_obj_align(gLimitValue,LV_ALIGN_CENTER,0,12);
uint32_t cycle=gBreath==BreathState::Waiting?0:now-gCycleStarted;
fmt(t,sizeof(t),cycle);lv_label_set_text(gCycleValue,t);
if(gCycleCount){fmt(t,sizeof(t),average());lv_label_set_text(gAverageValue,t);}
else lv_label_set_text(gAverageValue,"--");
uint64_t seconds=gCompletedMs/1000;
if(seconds>=3600)snprintf(t,sizeof(t),"%llu:%02llu:%02llu",
(unsigned long long)(seconds/3600),(unsigned long long)((seconds/60)%60),(unsigned long long)(seconds%60));
else snprintf(t,sizeof(t),"%02llu:%02llu",(unsigned long long)(seconds/60),(unsigned long long)(seconds%60));
lv_label_set_text(gElapsedValue,t);
snprintf(t,sizeof(t),"%u.0 s",LIMITS[gLimit]);lv_label_set_text(gLimitValue,t);
for(uint8_t i=0;i<5;i++){
if(i<gCycleCount){uint8_t index=(gCycleNext+5-gCycleCount+i)%5;
snprintf(t,sizeof(t),"%lu.%01lu",(unsigned long)(gCycles[index]/1000),
(unsigned long)((gCycles[index]%1000)/100));}
else snprintf(t,sizeof(t),"--");
lv_label_set_text(gHistory[i],t);
}
lv_obj_align(gCycleValue,LV_ALIGN_CENTER,0,12);
lv_obj_align(gAverageValue,LV_ALIGN_CENTER,0,12);
lv_obj_align(gElapsedValue,LV_ALIGN_CENTER,0,12);
lv_obj_align(gLimitValue,LV_ALIGN_CENTER,0,12);
// LVGL owns all drawing; do not overwrite its tiles through direct GFX writes.
}
static void reminders(){
if(gPaused||gBreath==BreathState::Waiting||gScreen!=Screen::Monitor)return;
uint32_t now=millis(),age=now-gPhaseStarted;
if(age>=LOUD_START_MS){
if(gBreath==BreathState::Inhale&&!gInhaleExceeded){gInhaleExceeded=true;appendEvent(7);}
if(gBreath==BreathState::Exhale&&!gExhaleExceeded){gExhaleExceeded=true;appendEvent(8);}
}
if(age<QUIET_START_MS||now-gLastReminder<((age<SLOW_LOUD_MS)?5000:15000))return;
gLastReminder=now;
if(age<LOUD_START_MS)quiet();else if(age<POWER_OFF_MS)loud();
else{appendEvent(3);gfx->setBrightness(0);if(gPowerReady)gPower.shutdown();esp_deep_sleep_start();}
}
// Wi-Fi credentials use the same key layout as shine_homeserver_main.ino,
// but an isolated Preferences namespace to avoid modifying the other application.
static Preferences gWifiPrefs;
static void wifiLoad(){
gWifiPrefs.begin("manual-wifi",false);
for(int i=0;i<8;i++){
String k=String("wifi_ssid_")+i, p=String("wifi_pass_")+i;
gSavedSsid[i]=gWifiPrefs.getString(k.c_str(),"");
gSavedPass[i]=gWifiPrefs.getString(p.c_str(),"");
}
gWifiEnabled = gWifiPrefs.getBool("enabled",false);
WiFi.mode(gWifiEnabled?WIFI_STA:WIFI_OFF);
WiFi.setAutoReconnect(false); // All known networks are selected by our own state machine.
WiFi.persistent(false);
}
static void wifiEnable(bool enabled){
gWifiEnabled=enabled;gWifiPrefs.putBool("enabled",enabled);gPrefs.putBool("wifi_on",enabled);
gWifiScanActive=false;gWifiConnecting=false;gWifiManual=false;
if(!enabled){WiFi.scanDelete();WiFi.disconnect(true,false);WiFi.mode(WIFI_OFF);gWifiNotice="Wi-Fi disabled";}
else{WiFi.mode(WIFI_STA);WiFi.setAutoReconnect(false);gAttemptMask=0;gWifiNextScan=millis()+250;gWifiNotice="Wi-Fi enabled";}
}
static int wifiKnown(const String &ssid){for(int i=0;i<8;i++)if(gSavedSsid[i]==ssid)return i;return -1;}
static void wifiRemember(const String &ssid,const String &pass){
int i=wifiKnown(ssid);
if(i<0){for(i=0;i<8 && gSavedSsid[i].length();i++);if(i>=8){
for(int j=0;j<7;j++){gSavedSsid[j]=gSavedSsid[j+1];gSavedPass[j]=gSavedPass[j+1];}i=7;
}}
gSavedSsid[i]=ssid;gSavedPass[i]=pass;
String k=String("wifi_ssid_")+i,p=String("wifi_pass_")+i;
gWifiPrefs.putString(k.c_str(),ssid);gWifiPrefs.putString(p.c_str(),pass);
}
static void wifiConnect(const String &ssid,const String &password,bool manual){
if(!gWifiEnabled)return;
if(ssid.isEmpty())return;
gWifiManual=manual;gWifiConnecting=true;gWifiStarted=millis();
gWifiNotice=String("Connecting: ")+ssid;
WiFi.mode(WIFI_STA);
WiFi.begin(ssid.c_str(),password.c_str()); // asynchronous: WiFi.status() polled in loop()
}
static void wifiScan(bool manual){
if(!gWifiEnabled)return;
if(gWifiScanActive||gWifiConnecting)return;
gWifiManual=manual;gWifiNotice="Scanning...";
gScannedCount=0;
int result=WiFi.scanNetworks(true,false); // asynchronous scanning
gWifiScanActive=(result==WIFI_SCAN_RUNNING || result==-1);
if(!gWifiScanActive)gWifiNextScan=millis()+15000;
}
static void wifiTryAvailable(){
int best=-1, bestRssi=-9999;
for(int j=0;j<gScannedCount;j++){
int index=wifiKnown(gScannedSsid[j]);
if(index<0 || (gAttemptMask&(1u<<index)))continue;
if(gScannedRssi[j]>bestRssi){bestRssi=gScannedRssi[j];best=index;}
}
if(best>=0){gAttemptedSaved=best;gAttemptMask|=(1u<<best);
wifiConnect(gSavedSsid[best],gSavedPass[best],false);
}else{gAttemptMask=0;gWifiNextScan=millis()+20000;gWifiNotice="No saved network available";}
}
static void wifiTick(){
if(!gWifiEnabled)return;
const uint32_t now=millis();
if(gWifiConnecting){
if(WiFi.status()==WL_CONNECTED){
gWifiConnecting=false;gAttemptMask=0;gWifiNotice=String("Connected: ")+WiFi.SSID();
if(gWifiManual)wifiRemember(WiFi.SSID(),gPendingPassword);
if(gAutoSync)requestNtp(); // NTP on every new connection
if(gScreen==Screen::Wifi||gScreen==Screen::WifiPassword)wifiScreen(nullptr);
}else if(now-gWifiStarted>12000){
gWifiConnecting=false;WiFi.disconnect(false,false);gWifiNotice="Connection failed";
if(!gWifiManual)wifiTryAvailable();
if(gScreen==Screen::Wifi||gScreen==Screen::WifiPassword)wifiScreen(nullptr);
}
return;
}
if(gWifiScanActive){
int result=WiFi.scanComplete();
if(result==WIFI_SCAN_RUNNING || result==-1)return;
gWifiScanActive=false;
if(result>0){
for(int i=0;i<result && gScannedCount<20;i++){
String ssid=WiFi.SSID(i);if(ssid.isEmpty())continue;
bool repeated=false;for(int j=0;j<gScannedCount;j++)if(gScannedSsid[j]==ssid){repeated=true;break;}
if(repeated)continue;
gScannedSsid[gScannedCount]=ssid;gScannedRssi[gScannedCount]=WiFi.RSSI(i);gScannedCount++;
}
}
WiFi.scanDelete();gWifiNotice=String("Found networks: ")+gScannedCount;
if(gWifiManual){if(gScreen==Screen::Wifi)wifiScreen(nullptr);}
else wifiTryAvailable();
return;
}
if(WiFi.status()==WL_CONNECTED)return;
if((int32_t)(now-gWifiNextScan)>=0){gAttemptMask=0;wifiScan(false);}
}
static void wifiSelect(lv_event_t *e){
uint32_t i=(uintptr_t)lv_event_get_user_data(e);if(i>=gScannedCount)return;
gSelectedSsid=gScannedSsid[i];int old=wifiKnown(gSelectedSsid);
if(old>=0){gPendingPassword=gSavedPass[old];wifiConnect(gSelectedSsid,gSavedPass[old],true);wifiScreen(nullptr);}
else {gKbValue="";gKbPage=false;gKbSymbols=false;gKbShift=false;gKbShowPassword=false;wifiPasswordScreen();}
}
static void wifiStartScan(lv_event_t *){
if(gWifiConnecting||gWifiScanActive)return;
wifiScan(true);wifiScreen(nullptr);
}
static void wifiForget(lv_event_t *){
for(int i=0;i<8;i++){
gSavedSsid[i]="";gSavedPass[i]="";
String a=String("wifi_ssid_")+i,b=String("wifi_pass_")+i;
gWifiPrefs.remove(a.c_str());gWifiPrefs.remove(b.c_str());
}
WiFi.disconnect(false,false);gWifiConnecting=false;gWifiNextScan=millis()+1500;
gWifiNotice="Saved networks cleared";wifiScreen(nullptr);
}
static void wifiScreen(lv_event_t *){
gScreen=Screen::Wifi;clearUi();legend();topBar("Wi-Fi");
String connected=WiFi.status()==WL_CONNECTED?String("Connected: ")+WiFi.SSID():
(gWifiConnecting?gWifiNotice:String("Not connected"));
lv_obj_t *status=label(gRoot,connected.c_str(),&lv_font_montserrat_16,0xC9D3DE);
lv_obj_set_pos(status,24,88);lv_obj_set_width(status,432);lv_label_set_long_mode(status,LV_LABEL_LONG_DOT);
lv_obj_t *check=lv_checkbox_create(gRoot);lv_checkbox_set_text(check,"Wi-Fi enabled");lv_obj_set_pos(check,24,120);
if(gWifiEnabled)lv_obj_add_state(check,LV_STATE_CHECKED);
lv_obj_add_event_cb(check,[](lv_event_t *e){wifiEnable(lv_obj_has_state(lv_event_get_target(e),LV_STATE_CHECKED));wifiScreen(nullptr);},LV_EVENT_VALUE_CHANGED,nullptr);
button(gRoot,"SCAN",24,167,200,43,0x214D69,wifiStartScan);
button(gRoot,"FORGET ALL",238,167,218,43,0x553442,wifiForget);
gWifiList=lv_obj_create(gRoot);lv_obj_set_pos(gWifiList,24,222);lv_obj_set_size(gWifiList,432,191);card(gWifiList);
lv_obj_set_style_pad_all(gWifiList,8,0);
lv_obj_set_flex_flow(gWifiList,LV_FLEX_FLOW_COLUMN);
lv_obj_set_style_pad_row(gWifiList,7,0);
lv_obj_add_flag(gWifiList,LV_OBJ_FLAG_SCROLLABLE);
if(!gScannedCount){label(gWifiList,!gWifiEnabled?"Enable Wi-Fi first":(gWifiScanActive?"Scanning networks...":"Tap SCAN to find networks"),&lv_font_montserrat_16,0xC9D3DE);}
for(int i=0;i<gScannedCount;i++){
String n=gScannedSsid[i];if(wifiKnown(n)>=0)n+=" [saved]";
lv_obj_t *item=lv_btn_create(gWifiList);lv_obj_set_size(item,390,43);card(item,0x203E50);
lv_obj_add_event_cb(item,wifiSelect,LV_EVENT_CLICKED,(void *)(uintptr_t)i);
lv_obj_t *name=label(item,n.c_str(),&lv_font_montserrat_16,0xFFFFFF);
lv_obj_set_width(name,365);lv_label_set_long_mode(name,LV_LABEL_LONG_DOT);lv_obj_center(name);
}
button(gRoot,"BACK",140,431,200,39,0x214D69,[](lv_event_t *){settings(nullptr);});
batteryUi();
}
static void wifiPasswordEvent(lv_event_t *e){
lv_event_code_t code=lv_event_get_code(e);
if(code==LV_EVENT_CANCEL){wifiScreen(nullptr);return;}
if(code!=LV_EVENT_READY)return;
String password=lv_textarea_get_text(gPasswordField);
// Copy before cleaning the screen (LVGL destroys the textarea).
String ssid=gSelectedSsid;
wifiConnect(ssid,password,true);
// Password only becomes persistent after a successful connection.
// Retain temporarily in RAM during connection.
gPendingPassword=password;
gWifiNotice="Connecting...";
wifiScreen(nullptr);
}
// Compact SHiNE keyboard: alpha/symbol pages, shift, delete, show password, save/cancel.
// Password stays in RAM until Wi-Fi confirms a successful connection.
static void kbRefreshField(){
if(!gPasswordField)return;
lv_textarea_set_text(gPasswordField,gKbValue.c_str());
lv_textarea_set_cursor_pos(gPasswordField,LV_TEXTAREA_CURSOR_LAST);
}
static void kbClicked(lv_event_t *e){
const char *key=(const char*)lv_event_get_user_data(e);
if(!key)return;
if(!strcmp(key,"<SAVE>")){
String ssid=gSelectedSsid, pass=gKbValue;
wifiConnect(ssid,pass,true);
gPendingPassword=pass;
gWifiNotice="Connecting...";
wifiScreen(nullptr);return;
}
if(!strcmp(key,"<CANCEL>")){wifiScreen(nullptr);return;}
if(!strcmp(key,"<MODE>")){gKbSymbols=!gKbSymbols;gKbPage=false;wifiPasswordScreen();return;}
if(!strcmp(key,"<PAGE>")){gKbPage=!gKbPage;wifiPasswordScreen();return;}
if(!strcmp(key,"<SHIFT>")){gKbShift=!gKbShift;wifiPasswordScreen();return;}
if(!strcmp(key,"<SHOW>")){gKbShowPassword=!gKbShowPassword;lv_textarea_set_password_mode(gPasswordField,!gKbShowPassword);return;}
if(!strcmp(key,"<DEL>")){if(gKbValue.length())gKbValue.remove(gKbValue.length()-1);kbRefreshField();return;}
if(!strcmp(key,"<CLEAR>")){gKbValue="";kbRefreshField();return;}
if(gKbValue.length()>=63)return;
String ch=(!strcmp(key,"<SPACE>"))?" ":String(key);
if(!gKbSymbols&&gKbShift)ch.toUpperCase();
gKbValue+=ch;kbRefreshField();
}
static void kbButton(const char *title,const char *token,int x,int y,int w,int h,uint32_t bg,uint8_t fontsize=16){
lv_obj_t *b=lv_btn_create(gRoot);lv_obj_set_pos(b,x,y);lv_obj_set_size(b,w,h);
lv_obj_set_style_radius(b,7,0);lv_obj_set_style_bg_color(b,color(bg),0);
lv_obj_set_style_pad_all(b,0,0);
lv_obj_add_event_cb(b,kbClicked,LV_EVENT_CLICKED,(void*)token);
const lv_font_t *font=fontsize==14?&lv_font_montserrat_14:&lv_font_montserrat_16;
lv_obj_t *txt=label(b,title,font,0xFFFFFF);lv_obj_center(txt);
}
static void wifiPasswordScreen(){
gScreen=Screen::WifiPassword;clearUi();legend();topBar("Wi-Fi password");
lv_obj_t *name=label(gRoot,gSelectedSsid.c_str(),&lv_font_montserrat_20,0xFFFFFF);
lv_obj_set_pos(name,18,73);lv_obj_set_width(name,444);lv_label_set_long_mode(name,LV_LABEL_LONG_DOT);
gPasswordField=lv_textarea_create(gRoot);
lv_obj_set_pos(gPasswordField,18,109);lv_obj_set_size(gPasswordField,444,51);
lv_textarea_set_one_line(gPasswordField,true);
lv_textarea_set_password_mode(gPasswordField,!gKbShowPassword);
lv_textarea_set_max_length(gPasswordField,63);
lv_obj_set_style_text_font(gPasswordField,&lv_font_montserrat_20,0);
kbRefreshField();
// Same split-page layout as shine_homeserver_main.ino, rescaled for 480x480.
static const char *alphaA[3][5]={{"q","w","e","r","t"},{"a","s","d","f","g"},{"z","x","c","v","b"}};
static const char *alphaB[3][5]={{"y","u","i","o","p"},{"h","j","k","l","."},{"n","m","-","_","@"}};
static const char *symA[3][5]={{"1","2","3","4","5"},{"/",":","_","@","."},{"!","?","#","+","="}};
static const char *symB[3][5]={{"6","7","8","9","0"},{"$","%","&","*","-"},{"(",")","[","]","~"}};
const char *(*rows)[5]=gKbSymbols?(gKbPage?symB:symA):(gKbPage?alphaB:alphaA);
for(int row=0;row<3;row++)for(int col=0;col<5;col++){
const char *token=rows[row][col];String cap=token;
if(!gKbSymbols&&gKbShift)cap.toUpperCase();
kbButton(cap.c_str(),token,18+col*91,169+row*58,84,51,0x2A6F97);
}
kbButton(gKbSymbols?"ABC":"123","<MODE>",18,347,79,47,0x5C6F82);
kbButton(gKbShift?"SHIFT*":"SHIFT","<SHIFT>",109,347,79,47,0x7A5C9B,14);
kbButton(gKbPage?"< 1/2":"2/2 >","<PAGE>",200,347,80,47,0x365873);
kbButton("SPACE","<SPACE>",292,347,79,47,0x365873,14);
kbButton("DEL","<DEL>",383,347,79,47,0x7D3A3A);
kbButton(gKbShowPassword?"HIDE":"SHOW","<SHOW>",18,406,79,54,0x53606B,14);
kbButton("CLEAR","<CLEAR>",109,406,79,54,0x7D3A3A,14);
kbButton("CANCEL","<CANCEL>",200,406,118,54,0x5A6570,14);
kbButton("CONNECT","<SAVE>",330,406,132,54,0x2A9D8F,14);
}
static void timeScreen(lv_event_t *){
gScreen=Screen::Time;clearUi();legend();topBar("TIME SETTINGS");
gTimeCurrent=label(gRoot,"--.--.---- --:--:--",&lv_font_montserrat_24,0xFFFFFF);
lv_obj_align(gTimeCurrent,LV_ALIGN_TOP_MID,0,80);
gTimeStatus=label(gRoot,"Clock not synchronized",&lv_font_montserrat_14,0x9EB4C2);
lv_obj_align(gTimeStatus,LV_ALIGN_TOP_MID,0,123);
gAutoCheck=lv_checkbox_create(gRoot);lv_checkbox_set_text(gAutoCheck,"Auto sync on Wi-Fi connect");
lv_obj_set_pos(gAutoCheck,26,160);if(gAutoSync)lv_obj_add_state(gAutoCheck,LV_STATE_CHECKED);
lv_obj_add_event_cb(gAutoCheck,[](lv_event_t *e){gAutoSync=lv_obj_has_state(lv_event_get_target(e),LV_STATE_CHECKED);saveSettings();},LV_EVENT_VALUE_CHANGED,nullptr);
lv_obj_t *tzTitle=label(gRoot,"Time zone (fixed UTC offset)",&lv_font_montserrat_16,0xC9D3DE);lv_obj_set_pos(tzTitle,26,205);
// Fixed selection avoids LVGL dropdown invalidation on screen changes.
gTzDraft=gTimezoneMinutes;
lv_obj_t *tz=label(gRoot,"",&lv_font_montserrat_20,0xFFFFFF);lv_obj_set_pos(tz,175,246);gTzDropdown=tz;
auto tzUpdate=[](){char txt[20];int m=abs(gTzDraft);snprintf(txt,sizeof(txt),"UTC%c%02d:%02d",gTzDraft<0?'-':'+',m/60,m%60);if(gTzDropdown)lv_label_set_text(gTzDropdown,txt);};
tzUpdate();
button(gRoot,"-",25,235,60,49,0x214D69,[](lv_event_t *){gTzDraft=max(-720,gTzDraft-15);char b[20];int m=abs(gTzDraft);snprintf(b,sizeof(b),"UTC%c%02d:%02d",gTzDraft<0?'-':'+',m/60,m%60);lv_label_set_text(gTzDropdown,b);});
button(gRoot,"+",95,235,60,49,0x214D69,[](lv_event_t *){gTzDraft=min(840,gTzDraft+15);char b[20];int m=abs(gTzDraft);snprintf(b,sizeof(b),"UTC%c%02d:%02d",gTzDraft<0?'-':'+',m/60,m%60);lv_label_set_text(gTzDropdown,b);});
button(gRoot,"SET",330,235,122,49,0x214D69,[](lv_event_t *){gTimezoneMinutes=gTzDraft;saveSettings();timeUiTick();});
button(gRoot,"SYNC NOW",23,316,210,54,0x214D69,[](lv_event_t *){requestNtp();});
button(gRoot,"SET MANUALLY",245,316,209,54,0x214D69,[](lv_event_t *){
time_t e=time(nullptr);if(!gTimeValid||e<1700000000)e=1760000000;
e+=(int32_t)gTimezoneMinutes*60;tm t={};gmtime_r(&e,&t);
gManualParts[0]=t.tm_year+1900;gManualParts[1]=t.tm_mon+1;gManualParts[2]=t.tm_mday;gManualParts[3]=t.tm_hour;gManualParts[4]=t.tm_min;
gManualField=0;gManualDigits="";manualTimeScreen();
});
button(gRoot,"BACK",140,399,200,52,0x214D69,[](lv_event_t *){settings(nullptr);});
}
static bool manualValid(){
int y=gManualParts[0],m=gManualParts[1],d=gManualParts[2],h=gManualParts[3],n=gManualParts[4];
if(y<2024||y>2099||m<1||m>12||h<0||h>23||n<0||n>59)return false;
int nd[]={31,28,31,30,31,30,31,31,30,31,30,31};
if((y%4==0&&y%100!=0)||y%400==0)nd[1]=29;
return d>=1&&d<=nd[m-1];
}
static int64_t utcFromParts(int y,int m,int d,int h,int minute){
y-=m<=2;int era=(y>=0?y:y-399)/400;unsigned yoe=y-era*400;
unsigned mp=m+(m>2?-3:9);unsigned doy=(153*mp+2)/5+d-1;
unsigned doe=yoe*365+yoe/4-yoe/100+doy;
return ((int64_t)era*146097+doe-719468)*86400+h*3600+minute*60;
}
static void manualRefresh(){
if(!gManualPreview)return;char b[96];
static const char *fieldNames[]={"YEAR","MONTH","DAY","HOUR","MINUTE"};
snprintf(b,sizeof(b),"%04d.%02d.%02d %02d:%02d:00\nEditing: %s %s",gManualParts[0],gManualParts[1],gManualParts[2],gManualParts[3],gManualParts[4],
fieldNames[gManualField],gManualDigits.c_str());
lv_label_set_text(gManualPreview,b);
}
static void manualKey(lv_event_t *e){
const char *key=(const char*)lv_event_get_user_data(e);if(!key)return;
if(strcmp(key,"CANCEL")==0){timeScreen(nullptr);return;}
if(strcmp(key,"BACK")==0){if(!gManualDigits.isEmpty())gManualDigits.remove(gManualDigits.length()-1);manualRefresh();return;}
if(strcmp(key,"OK")==0){
if(!gManualDigits.isEmpty())gManualParts[gManualField]=gManualDigits.toInt();
gManualDigits="";
if(gManualField<4){gManualField++;manualRefresh();return;}
if(!manualValid()){lv_label_set_text(gManualPreview,"Invalid date or time!\nEdit fields again.");gManualField=0;return;}
time_t utc=(time_t)(utcFromParts(gManualParts[0],gManualParts[1],gManualParts[2],gManualParts[3],gManualParts[4])-(int64_t)gTimezoneMinutes*60);
timeval tv={};tv.tv_sec=utc;tv.tv_usec=0;settimeofday(&tv,nullptr);rtcWrite(utc);gTimeValid=true;gNtpPending=false;
appendEvent(9);timeScreen(nullptr);return;
}
if(gManualDigits.length()<4){gManualDigits+=key;manualRefresh();}
}
static void manualTimeScreen(){
gScreen=Screen::ManualTime;clearUi();legend();topBar("SET DATE AND TIME");
gManualPreview=label(gRoot,"",&lv_font_montserrat_20,0xFFFFFF);lv_obj_set_pos(gManualPreview,44,86);manualRefresh();
const char *keys[]={"1","2","3","4","5","6","7","8","9","BACK","0","OK"};
for(int i=0;i<12;i++){
int col=i%3,row=i/3;
button(gRoot,keys[i],30+col*147,173+row*61,126,53,0x214D69,manualKey,(void*)keys[i]);
}
button(gRoot,"CANCEL",133,424,214,45,0x553442,manualKey,(void*)"CANCEL");
}
static void timeUiTick(){
if(gScreen!=Screen::Time||!gTimeCurrent)return;
time_t now=time(nullptr);char buf[48];
if(gTimeValid&&now>1700000000){now+=(int32_t)gTimezoneMinutes*60;tm t={};gmtime_r(&now,&t);snprintf(buf,sizeof(buf),"%02d.%02d.%04d %02d:%02d:%02d",t.tm_mday,t.tm_mon+1,t.tm_year+1900,t.tm_hour,t.tm_min,t.tm_sec);}
else snprintf(buf,sizeof(buf),"--.--.---- --:--:--");
lv_label_set_text(gTimeCurrent,buf);
lv_label_set_text(gTimeStatus,gNtpPending?"Synchronizing...":(gTimeValid?"Clock available (RTC / NTP)":"Clock not synchronized"));
}
static void applyRotationScreenPolicy(){
if(!gRotation || !gImuOk || gPaused || gScreen!=Screen::Monitor)return;
// Keep on for the top edge; keep off for the other three edges.
// For flat orientations retain the ordinary configured screen timeout.
if(gScreenEdgeOrientation==2){
if(!gScreenOn){gfx->setBrightness(220);gScreenOn=true;}
}else if(gScreenEdgeOrientation==3){
if(gScreenOn){gfx->setBrightness(0);gScreenOn=false;}
}
}
static void pollOrientation(){
if(!gRotation||!gImuOk||gPaused||gScreen!=Screen::Monitor)return;
uint32_t now=millis();if(now-gOrientationSample<70)return;gOrientationSample=now;
uint8_t data[6];if(!imuRead(0x35,data,6))return;
int16_t x=(int16_t)(data[0]|data[1]<<8),y=(int16_t)(data[2]|data[3]<<8),z=(int16_t)(data[4]|data[5]<<8);
float horiz=sqrtf((float)x*x+(float)y*y),az=fabsf((float)z);
if(horiz<100&&az<100)return;
// 0 = face up/down (EXHALE); 1 = any edge up (INHALE).
int8_t detected=(az>horiz*1.428f)?0:((az<horiz*0.700f)?1:-1);
// Edge selection is only relevant in rotation mode while the monitor is visible.
// A stable upward-pointing TOP edge holds the screen on. Other edges turn it off.
int8_t edge=-1;
if(detected==1){
float ax=fabsf((float)x),ay=fabsf((float)y);
if(ay>ax*1.35f)edge=((int32_t)y*IMU_TOP_EDGE_Y_SIGN>0)?2:3;
else if(ax>ay*1.35f)edge=3;
}
if(edge!=gScreenEdgeCandidate){gScreenEdgeCandidate=edge;gScreenEdgeChanged=now;}
else if(now-gScreenEdgeChanged>=250 && edge!=gScreenEdgeOrientation){
gScreenEdgeOrientation=edge;
applyRotationScreenPolicy();
}
if(detected<0)return;
if(detected!=gOrientationCandidate){gOrientationCandidate=detected;gOrientationChanged=now;return;}
if(now-gOrientationChanged<250 || detected==gOrientation)return;
gOrientation=detected;
if(!gRotationArmed){
gRotationArmed=true;
// Start a new measurement only when the device first reaches an inhale edge.
if(detected==1&&gBreath==BreathState::Waiting)phase(true);
return;
}
if(detected==0)phase(false);else phase(true);
}
// USB CDC serial protocol: LOG INFO / LOG DOWNLOAD; records stay on device.
static String gUsbCommand="";
static void usbCommands(){
while(Serial.available()){
char ch=(char)Serial.read();
if(ch=='\r')continue;
if(ch!='\n'){
if(gUsbCommand.length()<64)gUsbCommand+=ch;
continue;
}
gUsbCommand.trim();
if(gUsbCommand=="LOG INFO"){
if(!gFileReady){Serial.println("LOG ERROR FS");}
else{File f=FFat.open("/events.bin","r");size_t sz=f?f.size():0;if(f)f.close();
Serial.printf("LOG INFO %u %u\n",(unsigned)sz,(unsigned)gEventSeq);}
}else if(gUsbCommand=="LOG DOWNLOAD"){
if(!gFileReady){Serial.println("LOG ERROR FS");}
else{File f=FFat.open("/events.bin","r");size_t sz=f?f.size():0;
Serial.printf("LOG BEGIN %u\n",(unsigned)sz);
if(f){const char hex[]="0123456789ABCDEF";char line[129];size_t n=0;
while(f.available()){int x=f.read();if(x<0)break;line[2*n]=hex[((uint8_t)x)>>4];line[2*n+1]=hex[((uint8_t)x)&15];n++;
if(n==64){line[128]=0;Serial.println(line);n=0;delay(1);}}
if(n){line[2*n]=0;Serial.println(line);}f.close();}
Serial.println("LOG END");}
}else if(gUsbCommand.length()){Serial.println("LOG ERROR COMMAND");}
gUsbCommand="";
}
}
void setup(){Serial.begin(115200);Wire.begin(PIN_I2C_SDA,PIN_I2C_SCL);initPower();pinMode(PIN_INHALE,INPUT_PULLUP);pinMode(PIN_EXHALE,INPUT_PULLUP);initAudio();gfx->begin();gBus->writeC8D8(0x36,0xA0);gfx->setBrightness(220);gTouch.setPins(PIN_TP_INT,-1);gTouch.begin(Wire,0x5A,PIN_I2C_SDA,PIN_I2C_SCL);gTouch.setMaxCoordinates(DISP_W,DISP_H);gTouch.setSwapXY(true);gTouch.setMirrorXY(true,false);loadSettings();initClock();initImu();initEvents();appendEvent(2);wifiLoad();lv_init();gBuf1=(lv_color_t *)heap_caps_malloc(DISP_W*40*sizeof(lv_color_t),MALLOC_CAP_DMA);gBuf2=(lv_color_t *)heap_caps_malloc(DISP_W*40*sizeof(lv_color_t),MALLOC_CAP_DMA);lv_disp_draw_buf_init(&gDrawBuf,gBuf1,gBuf2,DISP_W*40);static lv_disp_drv_t dd;lv_disp_drv_init(&dd);dd.hor_res=DISP_W;dd.ver_res=DISP_H;dd.flush_cb=flush;dd.rounder_cb=rounder;dd.draw_buf=&gDrawBuf;lv_disp_drv_register(&dd);static lv_indev_drv_t id;lv_indev_drv_init(&id);id.type=LV_INDEV_TYPE_POINTER;id.read_cb=touchRead;lv_indev_drv_register(&id);const esp_timer_create_args_t ta={.callback=&tick,.name="lvgl_tick"};esp_timer_handle_t timer;esp_timer_create(&ta,&timer);esp_timer_start_periodic(timer,LVGL_TICK_MS*1000);gLastActivity=millis();enterMonitor(nullptr);gWifiNextScan=millis()+1500;}
void loop(){uint32_t now=millis();poll(gInhale,true);poll(gExhale,false);pollPowerKey();pollOrientation();usbCommands();wifiTick();ntpTick();reminders();if(now-gLastUi>=UI_MS){gLastUi=now;refresh();timeUiTick();}if(now-gLastBatt>=BATT_MS){gLastBatt=now;batteryUi();}uint32_t timeout=SCREEN_TIMEOUTS[gScreenTimeout];if(gScreenOn&&!(gRotation && gImuOk && gScreenEdgeOrientation==2)&&gScreen!=Screen::Settings&&gScreen!=Screen::Wifi&&gScreen!=Screen::WifiPassword&&gScreen!=Screen::Time&&gScreen!=Screen::ManualTime&&(int32_t)(now-gKey1WakeUntil)>=0&&timeout&&now-gLastActivity>=timeout){gScreenOn=false;gfx->setBrightness(0);}lv_timer_handler();applyRotationScreenPolicy();if((int32_t)(millis()-gKey1WakeUntil)<0){gScreenOn=true;gfx->setBrightness(220);}delay(5);}