From 951c56168cb8bd1cd900c513543ed6e29acfe416 Mon Sep 17 00:00:00 2001 From: Dejvino Date: Wed, 11 Nov 2026 22:03:40 +0100 Subject: [PATCH] CRT Terminal app --- .gitignore | 2 + README.MD | 16 +- emulator/Makefile | 46 +- emulator/src/main.cpp | 71 +- emulator/src/shim/Preferences.h | 4 +- examples/CrtTerminal/CrtTerminal.ino | 971 ++++++++++++++++++++++++++ examples/CrtTerminal/sound_engine.cpp | 222 ++++++ examples/CrtTerminal/sound_engine.h | 55 ++ examples/CrtTerminal/utilities.h | 85 +++ platformio.ini | 3 +- 10 files changed, 1447 insertions(+), 28 deletions(-) create mode 100644 examples/CrtTerminal/CrtTerminal.ino create mode 100644 examples/CrtTerminal/sound_engine.cpp create mode 100644 examples/CrtTerminal/sound_engine.h create mode 100644 examples/CrtTerminal/utilities.h diff --git a/.gitignore b/.gitignore index 49783fb..613a1e9 100644 --- a/.gitignore +++ b/.gitignore @@ -9,3 +9,5 @@ emulator/missilecommand-emu emulator/seq*.bmp emulator/mc-prefs.cfg +emulator/*-emu +emulator/*-prefs.cfg diff --git a/README.MD b/README.MD index 9cf029e..ccd6a22 100644 --- a/README.MD +++ b/README.MD @@ -23,6 +23,8 @@ examples ├─Touchpad # Read touch coordinates ├─GPSShield # GPS Shield example ├─lvgl_example # lvgl example +├─MissileCommand # arcade game +├─CrtTerminal # CRT monitor terminal emulator └─UnitTest # Factory hardware unit testing ```` @@ -95,4 +97,16 @@ See [utilities.h](./examples//UnitTest//utilities.h) - See [shell](./shell/) -![](./shell/T_Deck_2.png) \ No newline at end of file +![](./shell/T_Deck_2.png) + +## SDL emulator (run sketches on your PC) + +`emulator/` hosts a small SDL2 harness that runs selected example sketches +without hardware (framebuffer, keyboard, trackball and touch are emulated): + +```` +cd emulator +make run # MissileCommand (default) +make run APP=CrtTerminal # CRT terminal +make smoke APP=CrtTerminal # headless: N frames + BMP dump, --type "keys\n" +```` \ No newline at end of file diff --git a/emulator/Makefile b/emulator/Makefile index 2c890c8..bfc3cd5 100644 --- a/emulator/Makefile +++ b/emulator/Makefile @@ -1,34 +1,54 @@ -# Local SDL2 emulator for MissileCommand (run the game on your PC) +# SDL2 emulator for T-Deck example sketches (run the app on your PC) # -# make build ./missilecommand-emu -# make run build + launch the window -# make smoke headless test: 240 frames, dump the last frame to a BMP +# make build the MissileCommand emulator (default) +# make APP=CrtTerminal build the CRT terminal emulator +# make run [APP=...] build + launch the window +# make smoke [APP=...] headless test: N frames, dump the last frame +# make clean [APP=...] remove the binary + smoke frame # +# The sketch is included by src/main.cpp as a single translation unit: +# -DAPP_INO='".ino"'. Apps with a sound_engine.cpp get it linked +# automatically (wildcard). + +APP ?= MissileCommand +APP_DIR := ../examples/$(APP) + +ifeq ($(APP),MissileCommand) +APP_TITLE := Missile Command +DEFS += -DEMU_APP_MISSILECOMMAND +endif +ifeq ($(APP),CrtTerminal) +APP_TITLE := CRT Terminal +endif +APP_TITLE ?= $(APP) + CXX ?= g++ CXXFLAGS ?= -std=gnu++17 -O2 -Wall -Wextra SDLFLAGS := -I/usr/include/SDL2 -INC := -Isrc/shim -I../examples/MissileCommand +INC := -Isrc/shim -I$(APP_DIR) LIBS := -lSDL2 -lSDL2_ttf -GAME_DIR := ../examples/MissileCommand -SHIMS := $(wildcard src/shim/*.h) $(wildcard src/shim/driver/*.h) -EMU := missilecommand-emu +DEFS += -DAPP_INO='"$(APP).ino"' -DAPP_NAME='"$(APP_TITLE)"' + +SHIMS := $(wildcard src/shim/*.h) $(wildcard src/shim/driver/*.h) +SOUND_SRC := $(wildcard $(APP_DIR)/sound_engine.cpp) +EMU := $(APP)-emu .PHONY: all run smoke clean all: $(EMU) -$(EMU): src/main.cpp $(GAME_DIR)/sound_engine.cpp $(GAME_DIR)/MissileCommand.ino $(SHIMS) - $(CXX) $(CXXFLAGS) $(SDLFLAGS) $(INC) \ - src/main.cpp $(GAME_DIR)/sound_engine.cpp -o $@ $(LIBS) +$(EMU): src/main.cpp $(SOUND_SRC) $(APP_DIR)/$(APP).ino $(SHIMS) + $(CXX) $(CXXFLAGS) $(SDLFLAGS) $(INC) $(DEFS) \ + src/main.cpp $(SOUND_SRC) -o $@ $(LIBS) run: $(EMU) ./$(EMU) # Headless smoke test: dummy video/audio, run N frames, save the last frame. -# Feed some keys: 'a' starts the game, arrows steer, etc. via --script. +# Feed keys via --type "text" (queued a few chars per frame). smoke: $(EMU) ./$(EMU) --frames 240 --dump smoke_frame.bmp clean: - rm -f $(EMU) smoke_frame.bmp + rm -f $(EMU) smoke_frame.bmp \ No newline at end of file diff --git a/emulator/src/main.cpp b/emulator/src/main.cpp index 0cd8d9b..cf06c61 100644 --- a/emulator/src/main.cpp +++ b/emulator/src/main.cpp @@ -1,15 +1,15 @@ /** - * SDL2 host for the MissileCommand sketch — run the game on your PC. + * SDL2 host for T-Deck example sketches — run the app on your PC. + * The sketch is selected with -DAPP_INO (see the Makefile, APP=...). * * Input mapping: * Arrow keys trackball roll (hold to keep rolling) * Mouse wheel trackball roll (each notch = a ball pulse burst) - * Enter / right-click trackball press (fire) - * Left-click screen tap (aim + fire) - * A S D fire from left / center / right battery - * Space fire from nearest battery - * U / V volume up / down - * M mute toggle + * Enter / right-click trackball press + * Left-click screen tap + * Letters/digits keyboard device @ I2C 0x55 + * Backspace/Delete keyboard device (0x08 / 0x7F) + * --type "text" queue keys programmatically (for smoke tests) */ #include #include @@ -19,8 +19,15 @@ #include "emu_gfx.h" #include "emu_input.h" -// pull in the whole game as a single translation unit -#include "MissileCommand.ino" +#ifndef APP_INO +#define APP_INO "MissileCommand.ino" +#endif +#ifndef APP_NAME +#define APP_NAME "T-Deck app" +#endif + +// pull in the whole sketch as a single translation unit +#include APP_INO // --------------------------------------------------------------------------- // Global instances declared extern in the shims @@ -63,14 +70,22 @@ int main(int argc, char **argv) { long maxFrames = -1; const char *dumpPath = nullptr; - bool autoplay = false; + const char *typeStr = nullptr; + int typeFromFrame = 30; int dumpEvery = 0; +#ifdef EMU_APP_MISSILECOMMAND + bool autoplay = false; +#endif for (int i = 1; i < argc; i++) { if (!strcmp(argv[i], "--frames") && i + 1 < argc) maxFrames = atol(argv[++i]); else if (!strcmp(argv[i], "--dump") && i + 1 < argc) dumpPath = argv[++i]; else if (!strcmp(argv[i], "--dump-interval") && i + 1 < argc) dumpEvery = atoi(argv[++i]); + else if (!strcmp(argv[i], "--type") && i + 1 < argc) typeStr = argv[++i]; + else if (!strcmp(argv[i], "--type-at") && i + 1 < argc) typeFromFrame = atoi(argv[++i]); +#ifdef EMU_APP_MISSILECOMMAND else if (!strcmp(argv[i], "--wave") && i + 1 < argc) emuStartWaveRequest = atoi(argv[++i]); else if (!strcmp(argv[i], "--autoplay")) autoplay = true; +#endif } if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_AUDIO) != 0) { @@ -79,7 +94,7 @@ int main(int argc, char **argv) } TTF_Init(); - SDL_Window *win = SDL_CreateWindow("Missile Command — T-Deck emulator", + SDL_Window *win = SDL_CreateWindow("T-Deck emulator — " APP_NAME, SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, 640, 480, SDL_WINDOW_RESIZABLE); SDL_Renderer *ren = SDL_CreateRenderer(win, -1, SDL_RENDERER_ACCELERATED); @@ -122,6 +137,12 @@ int main(int argc, char **argv) case SDLK_SPACE: emu::keyboard.push_back(' '); break; + case SDLK_BACKSPACE: + emu::keyboard.push_back(0x08); + break; + case SDLK_DELETE: + emu::keyboard.push_back(0x7F); + break; case SDLK_ESCAPE: running = false; break; @@ -203,7 +224,34 @@ int main(int argc, char **argv) } } + // --type: queue the string on the keyboard device like a human typing + // (one char per --type-at start, ~40 ms apart in millis time, so the + // sketch processes each key before the next arrives). + // '\n' emulates Enter: press the trackball pin for one iteration. + static const char *typeNext = nullptr; + static int typePressPin = -1; + static unsigned long lastTypeMs = 0; + if (typeStr && frame >= (uint32_t)typeFromFrame) { + if (typePressPin >= 0) { + emu::pinLevels[typePressPin] = 1; // release the Enter press + typePressPin = -1; + } + if (!typeNext) typeNext = typeStr; + const char *typeEnd = typeStr + strlen(typeStr); + if (typeNext < typeEnd && millis() - lastTypeMs >= 40) { + lastTypeMs = millis(); + if (*typeNext == '\n' || *typeNext == '\r') { + typeNext++; // consume the Enter char + emu::pinLevels[BOARD_BOOT_PIN] = 0; + typePressPin = BOARD_BOOT_PIN; + } else { + emu::keyboard.push_back((uint8_t)*typeNext++); + } + } + } + // Headless test mode: start the game, wander the crosshair, keep firing. +#ifdef EMU_APP_MISSILECOMMAND if (autoplay) { static bool started = false; if (!started && frame >= 5) { @@ -215,6 +263,7 @@ int main(int argc, char **argv) if (frame % 4 == 0) emu::pinLevels[dirPin[dir]] ^= 1; if (frame % 75 == 0) emu::keyboard.push_back('s'); } +#endif // fire any emulated interrupts triggered by the pin changes above emu::dispatchIsrs(); diff --git a/emulator/src/shim/Preferences.h b/emulator/src/shim/Preferences.h index 995d05e..69cc196 100644 --- a/emulator/src/shim/Preferences.h +++ b/emulator/src/shim/Preferences.h @@ -13,8 +13,8 @@ class Preferences { public: bool begin(const char *ns, bool readOnly = false) { - (void)ns; (void)readOnly; + snprintf(path_, sizeof(path_), "%s-prefs.cfg", ns); map_.clear(); if (FILE *f = fopen(path_, "r")) { char key[64]; @@ -53,5 +53,5 @@ private: } std::unordered_map map_; - const char *path_ = "mc-prefs.cfg"; + char path_[64] = "mc-prefs.cfg"; }; diff --git a/examples/CrtTerminal/CrtTerminal.ino b/examples/CrtTerminal/CrtTerminal.ino new file mode 100644 index 0000000..c4cf1f5 --- /dev/null +++ b/examples/CrtTerminal/CrtTerminal.ino @@ -0,0 +1,971 @@ +/** + * @file CrtTerminal.ino + * @brief CRT monitor terminal emulator for the LilyGo T-Deck (ESP32-S3). + * + * A green-phosphor (P1-style) terminal drawn with TFT_eSPI pixels: a 53x26 + * character grid rendered from a built-in 5x7 bitmap font, with CRT dressing: + * - scanlines (every 3rd row drawn dim) + * - a rolling interference band with a bright phosphor halo + * - occasional single-row horizontal jitter + * - selectable phosphor: green / amber / white (B&W TV) + * + * Input: + * Keyboard : type commands, Backspace erases, Enter submits + * Trackball press : submits the line (like Enter) + * Screen tap : submits the line + * + * Commands (try 'help'): + * help clear echo ver uptime mem fortune dir + * banner beep phos crt vol + * + * Rendering: everything is a character grid, so the effects can repaint any + * row at any time (they only need the grid, no frame buffer). Glyph pixels + * are drawn as fillRect runs, which is SPI-friendly on the device. + */ + +#include +#include +#include +#include +#include +#include "utilities.h" +#include "TouchDrvGT911.hpp" +#include "sound_engine.h" + +// --------------------------------------------------------------------------- +// Hardware +// --------------------------------------------------------------------------- +TFT_eSPI tft; +TouchDrvGT911 touch; +SoundEngine sound; +Preferences prefs; + +static bool touchAvail = false; + +// --------------------------------------------------------------------------- +// Screen / grid geometry (rotation 1 -> 320x240) +// --------------------------------------------------------------------------- +static const int CELL_W = 6; // 5 px glyph + 1 px gap +static const int CELL_H = 9; // 7 px glyph + 2 px gap +static const int COLS = 53; // 53 * 6 = 318 px +static const int ROWS = 26; // 26 * 9 = 234 px +static const int X0 = 1; +static const int Y0 = 3; +static const int SCR_W = 320; +static const int SCR_H = 240; +static const int LINE_BUF = COLS - 3; // room for "> " + cursor cell + +// --------------------------------------------------------------------------- +// CRT look: phosphor palettes {R,G,B} + brightness levels (0..255) +// --------------------------------------------------------------------------- +enum Phos : uint8_t { PH_GREEN = 0, PH_AMBER = 1, PH_WHITE = 2, PH_COUNT }; +static const uint8_t PHOS_RGB[PH_COUNT][3] = { + { 90, 255, 140 }, // P1 green phosphor + { 255, 170, 60 }, // P3 amber + { 215, 228, 255 }, // B&W TV white +}; +static const char *PHOS_NAME[PH_COUNT] = { "P1 GREEN", "P3 AMBER", "B&W TV" }; + +static uint8_t phosMode = PH_GREEN; + +// Brightness levels, packed as RGB565 on demand +static const int LV_BRIGHT = 255; // glyph core +static const int LV_MID = 170; // cursor block +static const int LV_GLOW = 60; // band halo / interference line +static const int LV_SCAN = 160; // glyph pixels on scanline rows + +static uint16_t C_BG, C_BRIGHT, C_MID, C_GLOW, C_SCAN; + +static uint16_t shadeRGB(const uint8_t *rgb, int lv) +{ + int r = (rgb[0] * lv) / 255; + int g = (rgb[1] * lv) / 255; + int b = (rgb[2] * lv) / 255; + return (uint16_t)(((r >> 3) << 11) | ((g >> 2) << 5) | (b >> 3)); +} + +static void buildPalette() +{ + const uint8_t *rgb = PHOS_RGB[phosMode]; + C_BG = 0x0000; // true black behind the glass + C_BRIGHT = shadeRGB(rgb, LV_BRIGHT); + C_MID = shadeRGB(rgb, LV_MID); + C_GLOW = shadeRGB(rgb, LV_GLOW); + C_SCAN = shadeRGB(rgb, LV_SCAN); +} + +// --------------------------------------------------------------------------- +// 5x7 bitmap font, ASCII 32..126 (classic terminal font). +// Each byte is one glyph column, bit i (LSB) = row i (top to bottom). +// --------------------------------------------------------------------------- +static const uint8_t FONT5X7[95][5] = { + {0x00,0x00,0x00,0x00,0x00}, // ' ' + {0x00,0x00,0x5F,0x00,0x00}, // '!' + {0x00,0x07,0x00,0x07,0x00}, // '"' + {0x14,0x7F,0x14,0x7F,0x14}, // '#' + {0x24,0x2A,0x7F,0x2A,0x12}, // '$' + {0x23,0x13,0x08,0x64,0x62}, // '%' + {0x36,0x49,0x55,0x22,0x50}, // '&' + {0x00,0x05,0x03,0x00,0x00}, // '\'' + {0x00,0x1C,0x22,0x41,0x00}, // '(' + {0x00,0x41,0x22,0x1C,0x00}, // ')' + {0x14,0x08,0x3E,0x08,0x14}, // '*' + {0x08,0x08,0x3E,0x08,0x08}, // '+' + {0x00,0x50,0x30,0x00,0x00}, // ',' + {0x08,0x08,0x08,0x08,0x08}, // '-' + {0x00,0x60,0x60,0x00,0x00}, // '.' + {0x20,0x10,0x08,0x04,0x02}, // '/' + {0x3E,0x51,0x49,0x45,0x3E}, // '0' + {0x00,0x42,0x7F,0x40,0x00}, // '1' + {0x42,0x61,0x51,0x49,0x46}, // '2' + {0x21,0x41,0x45,0x4B,0x31}, // '3' + {0x18,0x14,0x12,0x7F,0x10}, // '4' + {0x27,0x45,0x45,0x45,0x39}, // '5' + {0x3C,0x4A,0x49,0x49,0x30}, // '6' + {0x01,0x71,0x09,0x05,0x03}, // '7' + {0x36,0x49,0x49,0x49,0x36}, // '8' + {0x06,0x49,0x49,0x29,0x1E}, // '9' + {0x00,0x36,0x36,0x00,0x00}, // ':' + {0x00,0x56,0x36,0x00,0x00}, // ';' + {0x00,0x08,0x14,0x22,0x41}, // '<' + {0x14,0x14,0x14,0x14,0x14}, // '=' + {0x41,0x22,0x14,0x08,0x00}, // '>' + {0x02,0x01,0x51,0x09,0x06}, // '?' + {0x32,0x49,0x79,0x41,0x3E}, // '@' + {0x7E,0x11,0x11,0x11,0x7E}, // 'A' + {0x7F,0x49,0x49,0x49,0x36}, // 'B' + {0x3E,0x41,0x41,0x41,0x22}, // 'C' + {0x7F,0x41,0x41,0x22,0x1C}, // 'D' + {0x7F,0x49,0x49,0x49,0x41}, // 'E' + {0x7F,0x09,0x09,0x01,0x01}, // 'F' + {0x3E,0x41,0x49,0x49,0x7A}, // 'G' + {0x7F,0x08,0x08,0x08,0x7F}, // 'H' + {0x00,0x41,0x7F,0x41,0x00}, // 'I' + {0x20,0x40,0x41,0x3F,0x01}, // 'J' + {0x7F,0x08,0x14,0x22,0x41}, // 'K' + {0x7F,0x40,0x40,0x40,0x40}, // 'L' + {0x7F,0x02,0x0C,0x02,0x7F}, // 'M' + {0x7F,0x04,0x08,0x10,0x7F}, // 'N' + {0x3E,0x41,0x41,0x41,0x3E}, // 'O' + {0x7F,0x09,0x09,0x09,0x06}, // 'P' + {0x3E,0x41,0x51,0x21,0x5E}, // 'Q' + {0x7F,0x09,0x09,0x09,0x79}, // 'R' + {0x46,0x49,0x49,0x49,0x31}, // 'S' + {0x01,0x01,0x7F,0x01,0x01}, // 'T' + {0x3F,0x40,0x40,0x40,0x3F}, // 'U' + {0x1F,0x20,0x40,0x20,0x1F}, // 'V' + {0x3F,0x40,0x38,0x40,0x3F}, // 'W' + {0x63,0x14,0x08,0x14,0x63}, // 'X' + {0x07,0x08,0x70,0x08,0x07}, // 'Y' + {0x61,0x51,0x49,0x45,0x43}, // 'Z' + {0x00,0x7F,0x41,0x41,0x00}, // '[' + {0x02,0x04,0x08,0x10,0x20}, // '\' + {0x00,0x41,0x41,0x7F,0x00}, // ']' + {0x04,0x02,0x01,0x02,0x04}, // '^' + {0x40,0x40,0x40,0x40,0x40}, // '_' + {0x01,0x02,0x04,0x00,0x00}, // '`' + {0x20,0x54,0x54,0x54,0x78}, // 'a' + {0x7F,0x48,0x44,0x44,0x38}, // 'b' + {0x38,0x44,0x44,0x44,0x20}, // 'c' + {0x38,0x44,0x44,0x48,0x7F}, // 'd' + {0x38,0x54,0x54,0x54,0x18}, // 'e' + {0x08,0x7E,0x09,0x01,0x02}, // 'f' + {0x0C,0x52,0x52,0x52,0x3E}, // 'g' + {0x7F,0x08,0x04,0x04,0x78}, // 'h' + {0x00,0x44,0x7D,0x40,0x00}, // 'i' + {0x20,0x40,0x44,0x3D,0x00}, // 'j' + {0x7F,0x10,0x28,0x44,0x00}, // 'k' + {0x00,0x41,0x7F,0x40,0x00}, // 'l' + {0x7C,0x04,0x18,0x04,0x78}, // 'm' + {0x7C,0x08,0x04,0x04,0x78}, // 'n' + {0x38,0x44,0x44,0x44,0x38}, // 'o' + {0x7C,0x14,0x14,0x14,0x08}, // 'p' + {0x08,0x14,0x14,0x18,0x7C}, // 'q' + {0x7C,0x08,0x04,0x04,0x08}, // 'r' + {0x48,0x54,0x54,0x54,0x20}, // 's' + {0x04,0x3E,0x44,0x40,0x20}, // 't' + {0x3C,0x40,0x40,0x20,0x7C}, // 'u' + {0x1C,0x20,0x40,0x20,0x1C}, // 'v' + {0x3C,0x40,0x30,0x40,0x3C}, // 'w' + {0x44,0x28,0x10,0x28,0x44}, // 'x' + {0x0C,0x50,0x50,0x50,0x3C}, // 'y' + {0x44,0x64,0x54,0x4C,0x44}, // 'z' + {0x00,0x08,0x36,0x41,0x00}, // '{' + {0x00,0x00,0x7F,0x00,0x00}, // '|' + {0x00,0x41,0x36,0x08,0x00}, // '}' + {0x08,0x08,0x2A,0x1C,0x08}, // '~' +}; + +// --------------------------------------------------------------------------- +// Terminal state +// --------------------------------------------------------------------------- +static char grid[ROWS][COLS]; +static int curCol = 0, curRow = 0; // next cell to write +static char lineBuf[LINE_BUF + 1]; +static int lineLen = 0; + +static const uint32_t FRAME_MS = 33; // ~30 fps +static const uint32_t INPUT_GRACE_MS = 1200; +static const uint32_t CURSOR_ON_MS = 420; +static const uint32_t CURSOR_PERIOD = 700; + +// CRT effects +static bool fxOn = true; +static float bandY = -24.0f; // top of the rolling band (px) +static const float BAND_SPEED = 0.55f; // px / frame +static const int BAND_H = 18; // band height (px) +static bool bandRows[ROWS]; // which cell rows the band covers +static int lineLastY = -1; // interference line y last frame +static int jitterRow = -1, jitterOff = 0; // active row jitter +static uint32_t jitterUntil = 0; +static uint32_t nextJitterMs = 0; + +// Cursor blink +static bool cursorShowing = false; +static bool cursorDirty = true; +static uint32_t blinkT0 = 0; + +// --------------------------------------------------------------------------- +// Low-level rendering +// --------------------------------------------------------------------------- +static void renderGlyphRuns(int x, int y, char ch, uint16_t color, bool scanDim) +{ + if (ch < 32 || ch > 126) ch = '?'; + const uint8_t *g = FONT5X7[ch - 32]; + for (int ry = 0; ry < 7; ry++) { + int rx = 0; + while (rx < 5) { + if (g[rx] & (1 << ry)) { + int len = 1; + while (rx + len < 5 && (g[rx + len] & (1 << ry))) len++; + uint16_t col = color; + if (scanDim && ((y + ry) % 3) == 2) col = C_SCAN; + tft.fillRect(x + rx, y + ry, len, 1, col); + rx += len; + } else { + rx++; + } + } + } +} + +// Repaint one grid cell: black background, then the glyph. +static void renderCell(int col, int row, int xoff, bool inBand) +{ + if (col < 0 || col >= COLS || row < 0 || row >= ROWS) return; + int x = X0 + col * CELL_W + xoff; + int y = Y0 + row * CELL_H; + tft.fillRect(x, y, CELL_W, CELL_H, C_BG); + char ch = grid[row][col]; + if (ch == ' ') return; + if (inBand) { + // phosphor halo: slightly enlarged dim copy behind the glyph + renderGlyphRuns(x - 1, y - 1, ch, C_GLOW, false); + renderGlyphRuns(x - 1, y + 1, ch, C_GLOW, false); + } + renderGlyphRuns(x, y, ch, C_BRIGHT, true); +} + +static void renderRow(int row, int xoff) +{ + bool inBand = fxOn && bandRows[row]; + for (int c = 0; c < COLS; c++) renderCell(c, row, xoff, inBand); + if (row == curRow) cursorDirty = true; +} + +static void renderAll() +{ + for (int r = 0; r < ROWS; r++) renderRow(r, 0); +} + +// Block cursor: filled cell with the glyph knocked out in background color. +static void renderCursor(bool on) +{ + if (curCol < 0 || curCol >= COLS || curRow < 0 || curRow >= ROWS) return; + int x = X0 + curCol * CELL_W; + int y = Y0 + curRow * CELL_H; + tft.fillRect(x, y, CELL_W, CELL_H, C_BG); + if (on) { + tft.fillRect(x, y, 5, 7, C_MID); + char ch = grid[curRow][curCol]; + if (ch != ' ') renderGlyphRuns(x, y, ch, C_BG, false); + } else { + char ch = grid[curRow][curCol]; + if (ch != ' ') { + bool inBand = fxOn && bandRows[curRow]; + if (inBand) { + renderGlyphRuns(x - 1, y - 1, ch, C_GLOW, false); + renderGlyphRuns(x - 1, y + 1, ch, C_GLOW, false); + } + renderGlyphRuns(x, y, ch, C_BRIGHT, true); + } + } +} + +// Big text (2x scale) drawn straight to the glass (used by boot + 'banner') +static int bigTextWidth(const char *s) +{ + return (int)strlen(s) * (5 * 2 + 2) - 2; +} + +static void bigPrintAt(const char *s, int x, int y) +{ + for (int i = 0; s[i]; i++) { + if (s[i] == ' ') { x += 5 * 2 + 2; continue; } + if (s[i] < 32 || s[i] > 126) continue; + const uint8_t *g = FONT5X7[s[i] - 32]; + for (int cx = 0; cx < 5; cx++) { + for (int ry = 0; ry < 7; ry++) { + if (g[cx] & (1 << ry)) { + tft.fillRect(x + cx * 2, y + ry * 2, 2, 2, C_BRIGHT); + } + } + } + x += 5 * 2 + 2; + } +} + +static void bigPrintCentered(const char *s, int y) +{ + bigPrintAt(s, (SCR_W - bigTextWidth(s)) / 2, y); +} + +// --------------------------------------------------------------------------- +// Grid / text output +// --------------------------------------------------------------------------- +static void scrollUp() +{ + memmove(&grid[0], &grid[1], sizeof(grid) - COLS); + memset(&grid[ROWS - 1][0], ' ', COLS); + renderAll(); +} + +static void newline() +{ + curCol = 0; + curRow++; + if (curRow >= ROWS) { + curRow = ROWS - 1; + scrollUp(); + } + cursorDirty = true; + sndBlip(); +} + +static void putChar(char ch) +{ + if (ch == '\n') { newline(); return; } + if (ch < 32 || ch > 126) ch = '?'; + grid[curRow][curCol] = ch; + renderCell(curCol, curRow, 0, fxOn && bandRows[curRow]); + sndBlip(); + curCol++; + if (curCol >= COLS) newline(); +} + +static void writeStr(const char *s) +{ + for (int i = 0; s[i]; i++) putChar(s[i]); +} + +static void clearScreen() +{ + tft.fillScreen(C_BG); + tft.drawRect(0, 0, SCR_W, SCR_H, C_GLOW); + memset(grid, ' ', sizeof(grid)); + curCol = curRow = 0; + memset(bandRows, 0, sizeof(bandRows)); + lineLastY = -1; + cursorDirty = true; +} + +static void printPrompt() +{ + writeStr("> "); +} + +// --------------------------------------------------------------------------- +// Sound helpers +// --------------------------------------------------------------------------- +static void sndBlip() +{ + SndEvent e = { SND_TONE, 540, 0, 10, 8000 }; + sound.play(e); + SndEvent f = { SND_TONE, 540, 0, 10, 100 }; + sound.play(f); + delay(15); +} + +static void sndClick() +{ + SndEvent e = { SND_TONE, 660, 0, 22, 5000 }; + sound.play(e); +} + +static void sndBell() +{ + SndEvent e = { SND_TONE, 1250, 0, 70, 9000 }; + sound.play(e); +} + +static void sndError() +{ + SndEvent a = { SND_TONE, 240, 0, 90, 12000 }; + SndEvent b = { SND_TONE, 170, 0, 130, 12000 }; + sound.play(a); + sound.play(b); +} + +// --------------------------------------------------------------------------- +// Input handling +// --------------------------------------------------------------------------- +static void execute(char *line); // shell (defined below) + +static volatile uint32_t tbClicks; +static void IRAM_ATTR tbIsrClick() { tbClicks++; } + +static void attachTrackball() +{ + pinMode(BOARD_BOOT_PIN, INPUT_PULLUP); + attachInterrupt(digitalPinToInterrupt(BOARD_BOOT_PIN), tbIsrClick, FALLING); +} + +static uint32_t lastSubmitMs = 0; + +static void submitLine() +{ + uint32_t now = millis(); + if (now - lastSubmitMs < 150) return; // soft repeat guard + lastSubmitMs = now; + + lineBuf[lineLen] = 0; + if (cursorShowing) renderCursor(false); + newline(); + if (lineLen > 0) execute(lineBuf); + else sndClick(); + lineLen = 0; + printPrompt(); + cursorDirty = true; +} + +static void addChar(char c) +{ + if (lineLen >= LINE_BUF) { sndBell(); return; } + if (cursorShowing) renderCursor(false); + grid[curRow][curCol] = c; + renderCell(curCol, curRow, 0, fxOn && bandRows[curRow]); + lineBuf[lineLen++] = c; + curCol++; + if (curCol >= COLS) newline(); + blinkT0 = millis(); // restart blink phase + cursorShowing = true; + renderCursor(true); +} + +static void backspace() +{ + if (lineLen == 0) { sndBell(); return; } + curCol--; + lineLen--; + lineBuf[lineLen] = 0; + grid[curRow][curCol] = ' '; + renderCell(curCol, curRow, 0, fxOn && bandRows[curRow]); + blinkT0 = millis(); + cursorShowing = true; + renderCursor(true); +} + +static void handleKey(char k) +{ + if (k == '\n' || k == '\r') { submitLine(); return; } + if (k == 0x08 || k == 0x7F) { backspace(); return; } + if (k >= 32 && k <= 126) addChar(k); +} + +static void pollKeyboard() +{ + // drain everything the keyboard controller has buffered (a fast typist + // must never lose keys to the frame pacing) + Wire.requestFrom((uint8_t)0x55, (uint8_t)1); + while (Wire.available() > 0) { + char k = (char)Wire.read(); + if (k != 0) handleKey(k); + } +} + +static void pollClick() +{ + if (tbClicks == 0) return; + // submit only after the ball is released again: contact bounce fires + // several FALLING edges while the pin is low, and this way they can't + // double-submit — nor can a quick second press be swallowed by a timer + if (digitalRead(BOARD_BOOT_PIN) != HIGH) return; + tbClicks = 0; + submitLine(); +} + +static void pollTouch() +{ + if (!touchAvail) return; + static bool wasDown = false; + if (!touch.isPressed()) { wasDown = false; return; } + if (wasDown) return; + int16_t x[1], y[1]; + if (touch.getPoint(x, y, 1) > 0) { + wasDown = true; + submitLine(); + } +} + +// --------------------------------------------------------------------------- +// CRT effects +// --------------------------------------------------------------------------- +static bool rowInBand(int row) +{ + int yTop = Y0 + row * CELL_H; + int yBot = yTop + CELL_H; + return bandY < yBot && (bandY + BAND_H) > yTop; +} + +static void fxUpdate() +{ + if (!fxOn) return; + + // rolling band: repaint rows it enters / leaves (halo boost) + bandY += BAND_SPEED; + if (bandY > SCR_H) { + bandY = -BAND_H; + memset(bandRows, 0, sizeof(bandRows)); + } + for (int r = 0; r < ROWS; r++) { + bool in = rowInBand(r); + if (in != bandRows[r]) { + bandRows[r] = in; + renderRow(r, 0); + } + } + + // interference line: a 1 px bright trace riding the band + int ly = (int)(bandY + BAND_H / 2); + if (ly < 0 || ly >= SCR_H) return; + if (ly != lineLastY) { + int orow = (lineLastY - Y0) / CELL_H; + if (orow >= 0 && orow < ROWS) renderRow(orow, 0); + lineLastY = ly; + } + tft.drawRect(0, 0, SCR_W, SCR_H, C_GLOW); + tft.fillRect(0, ly, SCR_W, 1, C_GLOW); + if (cursorShowing && curRow == (ly - Y0) / CELL_H) renderCursor(true); + + // occasional single-row jitter (sync wobble) + uint32_t now = millis(); + if (jitterRow >= 0) { + if ((int32_t)(now - jitterUntil) >= 0) { + renderRow(jitterRow, 0); + jitterRow = -1; + } + } else if (now >= nextJitterMs) { + nextJitterMs = now + 1800 + random(0, 2600); + int r = random(0, ROWS); + if (r != curRow) { + jitterRow = r; + jitterOff = (random(0, 2) == 0) ? 1 : -1; + jitterUntil = now + 90; + renderRow(r, jitterOff); + } + } +} + +static void setFx(bool on) +{ + if (fxOn == on) return; + fxOn = on; + if (on) { + bandY = -BAND_H; + memset(bandRows, 0, sizeof(bandRows)); + lineLastY = -1; + nextJitterMs = millis() + 2000; + } else { + jitterRow = -1; + } + renderAll(); +} + +// --------------------------------------------------------------------------- +// Commands +// --------------------------------------------------------------------------- +static void cmdHelp() +{ + writeStr("COMMANDS:\n"); + writeStr("help clear echo ver uptime\n"); + writeStr("mem fortune dir banner beep\n"); + writeStr("phos \n"); + writeStr("crt vol \n"); +} + +static void cmdVer() +{ + writeStr("CRTTERM v1.0 - T-Deck CRT\n"); + writeStr("PHOSPHOR: "); + writeStr(PHOS_NAME[phosMode]); + writeStr("\n"); +} + +static void cmdUptime() +{ + uint32_t s = millis() / 1000; + uint32_t d = s / 86400; s %= 86400; + uint32_t h = s / 3600; s %= 3600; + uint32_t m = s / 60; s %= 60; + char buf[48]; + snprintf(buf, sizeof(buf), "UP %luD %02lu:%02lu:%02lu\n", + (unsigned long)d, (unsigned long)h, (unsigned long)m, (unsigned long)s); + writeStr(buf); +} + +static void cmdMem() +{ +#ifdef EMULATOR + writeStr("HEAP 247K/8192K (EMU)\n"); +#else + char buf[64]; + snprintf(buf, sizeof(buf), "HEAP %uK/%uK\n", + (unsigned)(ESP.getFreeHeap() / 1024), + (unsigned)(ESP.getHeapSize() / 1024)); + writeStr(buf); +#endif +} + +static const char *FORTUNES[] = { + "IT IS NOW SAFE TO TURN OFF", + "YOUR COMPUTER.", + "", + "REAL TERMINALS FLICKER.", + "IT BUILDS CHARACTER.", + "", + "THERE IS NO PLACE LIKE", + "0x0000:0000.", + "", + "PC LOAD LETTER", + "", + "THE CAKE IS A LIE.", + "", + "LOADING REALITY... 42%", + "", + "GREEN PHOSPHOR NEVER DIES,", + "IT JUST FADES TO DIM.", + "", + "IT'S NOT A BUG, IT'S AN", + "UNDOCUMENTED FEATURE.", + "", + "INSERT COIN TO CONTINUE.", +}; + +static void cmdFortune() +{ + int n = sizeof(FORTUNES) / sizeof(FORTUNES[0]); + // fortunes come in 3-line blocks (text, text, blank) + int block = random(0, n / 3); + for (int i = 0; i < 3; i++) { + writeStr(FORTUNES[block * 3 + i]); + writeStr("\n"); + } +} + +static void cmdDir() +{ + writeStr("TAPE DIRECTORY:\n"); + writeStr("BASIC.BIN 12K\n"); + writeStr("ADVENTURE.BIN 34K\n"); + writeStr("STARFIELD.BIN 8K\n"); + writeStr("MONITOR.ROM 64K\n"); + writeStr("4 FILE(S), 8192K FREE\n"); +} + +static void cmdBanner() +{ + bigPrintCentered("T-DECK", Y0 + 7 * CELL_H); + bigPrintCentered("CRT", Y0 + 12 * CELL_H); + SndEvent e = { SND_SWEEP, 220, 880, 260, 12000 }; + sound.play(e); + delay(1500); + clearScreen(); + writeStr("*** T-DECK CRT TERMINAL ***\n"); +} + +static void cmdBeep(const char *args) +{ + int n = atoi(args); + if (n < 1) n = 1; + if (n > 5) n = 5; + for (int i = 0; i < n; i++) { + SndEvent e = { SND_TONE, 880, 0, 110, 14000 }; + sound.play(e); + delay(140); + } +} + +// case-insensitive compare (avoids strcasecmp portability differences) +static bool eqIgnoreCase(const char *a, const char *b) +{ + while (*a && *b) { + if (tolower((unsigned char)*a) != tolower((unsigned char)*b)) return false; + a++; b++; + } + return *a == 0 && *b == 0; +} + +static void cmdPhos(const char *args) +{ + if (eqIgnoreCase(args, "green") || eqIgnoreCase(args, "p1")) phosMode = PH_GREEN; + else if (eqIgnoreCase(args, "amber") || eqIgnoreCase(args, "p3")) phosMode = PH_AMBER; + else if (eqIgnoreCase(args, "white") || eqIgnoreCase(args, "bw")) phosMode = PH_WHITE; + else { + writeStr("USAGE: PHOS \n"); + return; + } + buildPalette(); + tft.fillScreen(C_BG); + memset(bandRows, 0, sizeof(bandRows)); + lineLastY = -1; + renderAll(); + writeStr("PHOSPHOR: "); + writeStr(PHOS_NAME[phosMode]); + writeStr("\n"); + prefs.begin("crt", false); + prefs.putUInt("phos", phosMode); +} + +static void cmdCrt(const char *args) +{ + if (eqIgnoreCase(args, "off")) { + setFx(false); + writeStr("CRT FX: OFF\n"); + } else if (eqIgnoreCase(args, "on")) { + setFx(true); + writeStr("CRT FX: ON\n"); + } else { + writeStr("USAGE: CRT \n"); + } + prefs.begin("crt", false); + prefs.putUInt("fx", fxOn ? 1 : 0); +} + +static void cmdVol(const char *args) +{ + if (*args == 0) { + writeStr("USAGE: VOL <0-8|+|->\n"); + return; + } + if (strcmp(args, "+") == 0) { + sound.volumeUp(); + } else if (strcmp(args, "-") == 0) { + sound.volumeDown(); + } else { + int v = atoi(args); + if (v < 0) v = 0; + if (v > SoundEngine::VOL_MAX) v = SoundEngine::VOL_MAX; + sound.setVolume((uint8_t)v); + } + char buf[24]; + snprintf(buf, sizeof(buf), "VOL %u/%u\n", sound.volume(), SoundEngine::VOL_MAX); + writeStr(buf); + prefs.begin("crt", false); + prefs.putUInt("vol", sound.volume()); +} + +static void execute(char *line) +{ + // trim leading spaces + while (*line == ' ') line++; + if (*line == 0) return; + + // split command / args + char *args = line; + while (*args && *args != ' ') args++; + if (*args) { + *args = 0; + args++; + while (*args == ' ') args++; + } + + // lowercase the command + for (char *p = line; *p; p++) *p = (char)tolower((unsigned char)*p); + + if (strcmp(line, "help") == 0) cmdHelp(); + else if (strcmp(line, "clear") == 0 || strcmp(line, "cls") == 0) clearScreen(); + else if (strcmp(line, "echo") == 0) { writeStr(args); writeStr("\n"); } + else if (strcmp(line, "ver") == 0) cmdVer(); + else if (strcmp(line, "uptime") == 0) cmdUptime(); + else if (strcmp(line, "mem") == 0) cmdMem(); + else if (strcmp(line, "fortune") == 0) cmdFortune(); + else if (strcmp(line, "dir") == 0 || strcmp(line, "ls") == 0) cmdDir(); + else if (strcmp(line, "banner") == 0) cmdBanner(); + else if (strcmp(line, "beep") == 0) cmdBeep(args); + else if (strcmp(line, "phos") == 0) cmdPhos(args); + else if (strcmp(line, "crt") == 0) cmdCrt(args); + else if (strcmp(line, "vol") == 0) cmdVol(args); + else { + writeStr("?SYNTAX ERROR\n"); + writeStr("TRY 'HELP'\n"); + sndError(); + } +} + +// --------------------------------------------------------------------------- +// Boot +// --------------------------------------------------------------------------- +static void setBrightness(uint8_t level) +{ + // ESP32-S3 LEDC-attached backlight: same bit-banged stepping as UnitTest + static uint8_t blLevel = 255; + static const uint8_t steps = 16; + if (level == 0) { + digitalWrite(BOARD_BL_PIN, 1); + blLevel = steps; + delayMicroseconds(30); + } + int from = steps - blLevel; + int to = steps - level; + int num = (steps + to - from) % steps; + for (int i = 0; i < num; i++) { + digitalWrite(BOARD_BL_PIN, 0); + digitalWrite(BOARD_BL_PIN, 1); + } + blLevel = level; +} + +static void hardwareInit() +{ + Serial.begin(115200); + Serial.println("T-Deck CRT Terminal"); + + pinMode(BOARD_POWERON, OUTPUT); + digitalWrite(BOARD_POWERON, HIGH); + + // CS lines high during init + pinMode(BOARD_SDCARD_CS, OUTPUT); + pinMode(RADIO_CS_PIN, OUTPUT); + pinMode(BOARD_TFT_CS, OUTPUT); + digitalWrite(BOARD_SDCARD_CS, HIGH); + digitalWrite(RADIO_CS_PIN, HIGH); + digitalWrite(BOARD_TFT_CS, HIGH); + + pinMode(BOARD_SPI_MISO, INPUT_PULLUP); + SPI.begin(BOARD_SPI_SCK, BOARD_SPI_MISO, BOARD_SPI_MOSI); + + tft.begin(); + tft.setRotation(1); + tft.fillScreen(TFT_BLACK); + + pinMode(BOARD_BL_PIN, OUTPUT); + for (int i = 0; i <= 16; ++i) { + setBrightness(i); + delay(20); + } + + // I2C: touch + keyboard share the bus + Wire.begin(BOARD_I2C_SDA, BOARD_I2C_SCL); + + touch.setPins(-1, BOARD_TOUCH_INT); + touchAvail = touch.begin(Wire); + if (touchAvail) { + touch.setMaxCoordinates(tft.width(), tft.height()); + touch.setSwapXY(true); + touch.setMirrorXY(false, true); + Serial.println("GT911 touch ready"); + } else { + Serial.println("No GT911 touch found"); + } + + attachTrackball(); +} + +static void bootSequence() +{ + clearScreen(); + SndEvent e = { SND_SWEEP, 300, 900, 320, 10000 }; + sound.play(e); + bigPrintCentered("T-DECK", Y0 + 6 * CELL_H); + bigPrintCentered("CRT TERMINAL", Y0 + 11 * CELL_H); + delay(1600); + clearScreen(); + + static const char *lines[] = { + "*** T-DECK CRT TERMINAL ***", + "ROM BIOS 1.0 - 320X240", + "RAM TEST ......... 8192K OK", + "PHOSPHOR ......... WARMING UP", + "KEYBOARD @55 ..... ONLINE", + touchAvail ? "TOUCH GT911 ...... ONLINE" : "TOUCH GT911 ...... ABSENT", + "SOUND ............ READY", + "", + "TYPE 'HELP' FOR COMMANDS.", + "", + }; + for (const char *l : lines) { + SndEvent t = { SND_TONE, 1500, 0, 10, 2500 }; + sound.play(t); + writeStr(l); + writeStr("\n"); + delay(110); + } + printPrompt(); +} + +// --------------------------------------------------------------------------- +// setup / loop +// --------------------------------------------------------------------------- +void setup() +{ + hardwareInit(); + + buildPalette(); + + if (!sound.begin()) { + Serial.println("Sound engine init failed (no I2S?)"); + } + + // restore persisted settings + prefs.begin("crt", false); + phosMode = prefs.getUInt("phos", PH_GREEN); + if (phosMode >= PH_COUNT) phosMode = PH_GREEN; + buildPalette(); + fxOn = prefs.getUInt("fx", 1) != 0; + sound.setVolume((uint8_t)prefs.getUInt("vol", 5)); + + bootSequence(); +} + +void loop() +{ + // swallow all input right after power-up/reset + uint32_t now = millis(); + if (now < INPUT_GRACE_MS) { + tbClicks = 0; + delay(1); + return; + } + + static uint32_t nextFrame = 0; + if ((int32_t)(now - nextFrame) < 0) { + delay(1); + return; + } + nextFrame = now + FRAME_MS; + + // clicks / taps first: they submit the line as it stood when the user + // pressed Enter — chars typed afterwards belong on the next line + pollClick(); + pollTouch(); + pollKeyboard(); + fxUpdate(); + + // cursor blink + bool on = (now - blinkT0) % CURSOR_PERIOD < CURSOR_ON_MS; + if (on != cursorShowing || cursorDirty) { + cursorShowing = on; + cursorDirty = false; + renderCursor(on); + } +} diff --git a/examples/CrtTerminal/sound_engine.cpp b/examples/CrtTerminal/sound_engine.cpp new file mode 100644 index 0000000..6faa02a --- /dev/null +++ b/examples/CrtTerminal/sound_engine.cpp @@ -0,0 +1,222 @@ +/** + * @file sound_engine.cpp + * @brief I2S speaker rendering task (8 kHz, 16-bit, mono). + * + * Based on the wiring used by examples/SimpleTone: + * BCK = GPIO7, WS = GPIO5, DOUT = GPIO6. + * + * Sounds are rendered strictly in queue order; layering is achieved by + * queueing several events back to back (e.g. a rumble sweep followed by a + * noise tail reads as one big explosion). + */ +#include "sound_engine.h" +#include "utilities.h" +#include + +#define SND_SAMPLE_RATE 8000 +#define SND_I2S_PORT I2S_NUM_0 +#define SND_CHUNK 128 // samples per i2s_write call +#define SND_FADE_MS 2 // fade in/out to avoid clicks + +bool SoundEngine::begin() +{ + i2s_config_t cfg = {}; + cfg.mode = (i2s_mode_t)(I2S_MODE_MASTER | I2S_MODE_TX); + cfg.sample_rate = SND_SAMPLE_RATE; + cfg.bits_per_sample = I2S_BITS_PER_SAMPLE_16BIT; + cfg.channel_format = I2S_CHANNEL_FMT_ONLY_LEFT; + cfg.communication_format = I2S_COMM_FORMAT_STAND_I2S; + cfg.intr_alloc_flags = ESP_INTR_FLAG_LEVEL1; + cfg.dma_buf_count = 8; + cfg.dma_buf_len = 64; + + if (i2s_driver_install(SND_I2S_PORT, &cfg, 0, NULL) != ESP_OK) { + return false; + } + + i2s_pin_config_t pins = {}; + pins.bck_io_num = BOARD_I2S_BCK; + pins.ws_io_num = BOARD_I2S_WS; + pins.data_out_num = BOARD_I2S_DOUT; + pins.data_in_num = I2S_PIN_NO_CHANGE; + i2s_set_pin(SND_I2S_PORT, &pins); + + q_ = xQueueCreate(12, sizeof(SndEvent)); + if (q_ == nullptr) { + return false; + } + + // Render on core 0; the game loop runs on core 1. + return xTaskCreatePinnedToCore(trampoline, "sound", 4096, this, 5, nullptr, 0) == pdTRUE; +} + +void SoundEngine::play(const SndEvent &e) +{ + if (q_) { + xQueueSend(q_, &e, 0); // drop instead of blocking the game + } +} + +void SoundEngine::trampoline(void *arg) +{ + static_cast(arg)->task(); +} + +void SoundEngine::task() +{ + for (;;) { + SndEvent e; + xQueueReceive(q_, &e, portMAX_DELAY); + switch (e.type) { + case SND_TONE: renderTone(e.freq, e.dur, e.amp); break; + case SND_SWEEP: renderSweep(e.freq, e.freq2, e.dur, e.amp); break; + case SND_NOISE: renderNoise(e.dur, e.amp); break; + } + // After the LAST queued event the I2S TX DMA ring would keep + // replaying its remaining ~64 ms of buffer forever — heard as the + // sound's tail (rocket sweep, melody tone) repeating endlessly. + // Zero the ring once the queue is empty (not between queued events, + // which would punch silence-gaps into back-to-back melodies). + if (uxQueueMessagesWaiting(q_) == 0) { + i2s_zero_dma_buffer(SND_I2S_PORT); + } + } +} + +void SoundEngine::volumeUp() +{ + if (vol_ < VOL_MAX) vol_++; +} + +void SoundEngine::volumeDown() +{ + if (vol_ > 0) vol_--; +} + +void SoundEngine::toggleMute() +{ + if (vol_ > 0) { + lastVol_ = vol_; + vol_ = 0; + } else { + vol_ = lastVol_ > 0 ? lastVol_ : VOL_MAX / 2; + } +} + +// Restore a saved volume level (from NVS at boot); 0 keeps the device muted +// while lastVol_ stays at its default so unmute still works. +void SoundEngine::setVolume(uint8_t v) +{ + if (v > VOL_MAX) v = VOL_MAX; + vol_ = v; + if (vol_ > 0) lastVol_ = vol_; +} + +// scaled peak amplitude for the current volume level +static inline uint32_t scaledAmp(uint16_t amp, uint8_t vol) +{ + return ((uint32_t)amp * vol) / SoundEngine::VOL_MAX; +} + +// fade envelope over the first/last SND_FADE_MS of the whole event +static inline uint32_t envelope(uint32_t pos, uint32_t total, uint32_t fade, uint32_t amp) +{ + if (fade * 2 > total) fade = total / 2; + uint32_t s = amp; + if (pos < fade) s = s * pos / fade; + uint32_t tail = total - pos; + if (tail < fade) s = s * tail / fade; + return s; +} + +void SoundEngine::renderTone(uint16_t freq, uint16_t durMs, uint16_t amp) +{ + static int16_t buf[SND_CHUNK]; + + uint32_t a = scaledAmp(amp, vol_); + if (a == 0) return; + + uint32_t total = (uint32_t)SND_SAMPLE_RATE * durMs / 1000; + if (total == 0) return; + uint32_t half = (freq > 0) ? (SND_SAMPLE_RATE / 2) / freq : 1; + if (half == 0) half = 1; + uint32_t fade = (uint32_t)SND_SAMPLE_RATE * SND_FADE_MS / 1000; + if (fade < 2) fade = 2; + + uint32_t phase = 0; + for (uint32_t i = 0; i < total; ) { + uint32_t n = (total - i < SND_CHUNK) ? (total - i) : SND_CHUNK; + for (uint32_t k = 0; k < n; k++) { + int32_t s = ((phase / half) & 1) ? (int32_t)a : -(int32_t)a; + buf[k] = (int16_t)(s * (int32_t)envelope(i + k, total, fade, 256) / 256); + phase++; + } + size_t bw; + i2s_write(SND_I2S_PORT, buf, n * sizeof(int16_t), &bw, portMAX_DELAY); + i += n; + } +} + +// Square wave gliding from freq0 to freq1 (Hz) over the duration. +// Phase is carried in a float cycle counter (0..1) so frequency changes +// never click. +void SoundEngine::renderSweep(uint16_t freq0, uint16_t freq1, uint16_t durMs, uint16_t amp) +{ + static int16_t buf[SND_CHUNK]; + + uint32_t a = scaledAmp(amp, vol_); + if (a == 0) return; + + uint32_t total = (uint32_t)SND_SAMPLE_RATE * durMs / 1000; + if (total == 0) return; + uint32_t fade = (uint32_t)SND_SAMPLE_RATE * SND_FADE_MS / 1000; + if (fade < 2) fade = 2; + + float phase = 0.0f; + for (uint32_t i = 0; i < total; ) { + uint32_t n = (total - i < SND_CHUNK) ? (total - i) : SND_CHUNK; + for (uint32_t k = 0; k < n; k++) { + uint32_t pos = i + k; + float f = (float)freq0 + + ((float)(int16_t)(freq1 - freq0) * (float)pos) / (float)total; + if (f < 20.0f) f = 20.0f; + phase += f / (float)SND_SAMPLE_RATE; + if (phase >= 1.0f) phase -= 1.0f; + int32_t s = (phase < 0.5f) ? (int32_t)a : -(int32_t)a; + buf[k] = (int16_t)(s * (int32_t)envelope(pos, total, fade, 256) / 256); + } + size_t bw; + i2s_write(SND_I2S_PORT, buf, n * sizeof(int16_t), &bw, portMAX_DELAY); + i += n; + } +} + +void SoundEngine::renderNoise(uint16_t durMs, uint16_t amp) +{ + static int16_t buf[SND_CHUNK]; + + uint32_t a = scaledAmp(amp, vol_); + if (a == 0) return; + + uint32_t total = (uint32_t)SND_SAMPLE_RATE * durMs / 1000; + if (total == 0) return; + + uint32_t seed = esp_random() | 1; + for (uint32_t i = 0; i < total; ) { + uint32_t n = (total - i < SND_CHUNK) ? (total - i) : SND_CHUNK; + for (uint32_t k = 0; k < n; k++) { + // xorshift32 for cheap white noise + seed ^= seed << 13; + seed ^= seed >> 17; + seed ^= seed << 5; + int32_t signedS = (int32_t)(seed & 0xFFFF) - 32768; + // linear decay over the burst + int32_t s = (int32_t)(((int64_t)signedS * a * (int64_t)(total - i - k)) / + ((int64_t)32768 * (int64_t)total)); + buf[k] = (int16_t)s; + } + size_t bw; + i2s_write(SND_I2S_PORT, buf, n * sizeof(int16_t), &bw, portMAX_DELAY); + i += n; + } +} diff --git a/examples/CrtTerminal/sound_engine.h b/examples/CrtTerminal/sound_engine.h new file mode 100644 index 0000000..96854d4 --- /dev/null +++ b/examples/CrtTerminal/sound_engine.h @@ -0,0 +1,55 @@ +/** + * @file sound_engine.h + * @brief Tiny non-blocking I2S sound engine for the T-Deck speaker. + * + * A FreeRTOS task owns the I2S peripheral (speaker, I2S_NUM_0) and renders + * queued sound events one after another. The game only ever pushes events, + * so it never blocks. Event types: + * + * SND_TONE fixed square-wave beep + * SND_SWEEP square wave gliding from freq down/up to freq2 (sirens, booms) + * SND_NOISE white-noise burst with linear decay (explosions) + */ +#pragma once + +#include + +enum SndType : uint8_t { + SND_TONE = 0, // fixed square wave + SND_SWEEP, // square wave gliding freq -> freq2 + SND_NOISE, // white noise burst +}; + +struct SndEvent { + SndType type; + uint16_t freq; // Hz (tone, or sweep start) + uint16_t freq2; // Hz (sweep end; ignored for tone/noise) + uint16_t dur; // duration in ms + uint16_t amp; // peak amplitude 0..32767 +}; + +class SoundEngine { +public: + static const uint8_t VOL_MAX = 8; + + bool begin(); + void play(const SndEvent &e); + + // Master volume, applied to every rendered sound + void volumeUp(); + void volumeDown(); + void toggleMute(); + void setVolume(uint8_t v); // restore a saved level (0 = muted) + uint8_t volume() const { return vol_; } + +private: + static void trampoline(void *arg); + void task(); + void renderTone(uint16_t freq, uint16_t durMs, uint16_t amp); + void renderSweep(uint16_t freq0, uint16_t freq1, uint16_t durMs, uint16_t amp); + void renderNoise(uint16_t durMs, uint16_t amp); + + QueueHandle_t q_ = nullptr; + uint8_t vol_ = 5; // default: moderate + uint8_t lastVol_ = 5; // remembered for mute toggle +}; diff --git a/examples/CrtTerminal/utilities.h b/examples/CrtTerminal/utilities.h new file mode 100644 index 0000000..3ca5aa7 --- /dev/null +++ b/examples/CrtTerminal/utilities.h @@ -0,0 +1,85 @@ +/** + * @file utilities.h + * @author Lewis He (lewishe@outlook.com) + * @license MIT + * @copyright Copyright (c) 2023 Shenzhen Xin Yuan Electronic Technology Co., Ltd + * @date 2023-04-11 + * + */ +#pragma once + + + +//! The board peripheral power control pin needs to be set to HIGH when using the peripheral +#define BOARD_POWERON 10 + +#define BOARD_I2S_WS 5 +#define BOARD_I2S_BCK 7 +#define BOARD_I2S_DOUT 6 + +#define BOARD_I2C_SDA 18 +#define BOARD_I2C_SCL 8 + +#define BOARD_BAT_ADC 4 + +#define BOARD_TOUCH_INT 16 +#define BOARD_KEYBOARD_INT 46 + +#define BOARD_SDCARD_CS 39 +#define BOARD_TFT_CS 12 +#define RADIO_CS_PIN 9 + +#define BOARD_TFT_DC 11 +#define BOARD_TFT_BACKLIGHT 42 + +#define BOARD_SPI_MOSI 41 +#define BOARD_SPI_MISO 38 +#define BOARD_SPI_SCK 40 + +#define BOARD_TBOX_G02 2 +#define BOARD_TBOX_G01 3 +#define BOARD_TBOX_G04 1 +#define BOARD_TBOX_G03 15 + +#define BOARD_ES7210_MCLK 48 +#define BOARD_ES7210_LRCK 21 +#define BOARD_ES7210_SCK 47 +#define BOARD_ES7210_DIN 14 + +#define RADIO_BUSY_PIN 13 +#define RADIO_RST_PIN 17 +#define RADIO_DIO1_PIN 45 + +#define BOARD_BOOT_PIN 0 + +#define BOARD_BL_PIN 42 + + +#define BOARD_GPS_TX_PIN 43 +#define BOARD_GPS_RX_PIN 44 + + +#ifndef RADIO_FREQ +#define RADIO_FREQ 868.0 +#endif + +#ifndef RADIO_BANDWIDTH +#define RADIO_BANDWIDTH 125.0 +#endif + +#ifndef RADIO_SF +#define RADIO_SF 10 +#endif + +#ifndef RADIO_CR +#define RADIO_CR 6 +#endif + +#ifndef RADIO_TX_POWER +#define RADIO_TX_POWER 22 +#endif + +#define DEFAULT_OPA 100 + + + diff --git a/platformio.ini b/platformio.ini index 37ed0b4..2fc742c 100644 --- a/platformio.ini +++ b/platformio.ini @@ -32,7 +32,8 @@ default_envs = T-Deck ; src_dir = examples/I2SPlay ; src_dir = examples/LvglArduinoVNC_VGA ; src_dir = examples/SimpleTone -src_dir = examples/MissileCommand +src_dir = examples/CrtTerminal +; src_dir = examples/MissileCommand ;! Don't make changes