NerdMiner – Display Black Screen Wrong TFT Pinout

Identify your NerdMiner board silkscreen exactly. Unplug the device. With a flashlight and a phone camera at `2x` zoom, read the full part number printed on the back of the PCB: `TTGO T-Display`, `ESP32-2432S028R`, `ESP32-2432S024C`, `ESP32-2432S022`, `T-Display-S3`, or the IdeaSpark sticker branding with screen size (`1.14"` or `1.9"`). Photograph it. Match against the decoder table in the Root Cause section. This is the single input that decides everything downstream — guess wrong and you reflash a mismatched `.bin` and stay dark.

Verify the ESP32 is hashing before you reflash. Connect the NerdMiner to Wi-Fi (if it's joined your network previously) or to its setup AP `NerdMiner_XXXX` on your phone. Browse to `http://nerdminer.local/` or `http://192.168.4.1/`. If the web dashboard shows climbing hashes-per-second and your configured worker name, the device is fully functional — this confirms you are chasing a cosmetic display problem, not a dead miner. Cross-verify on `public-pool.io` or `solo.ckpool.org` that your worker is submitting shares from the pool side.

Open the NerdMiner v2 web installer in Chrome or Edge. The official web installer (bitmaker-hub.github.io/NerdMiner_v2) is WebSerial-based and supports every upstream board variant via a dropdown. WebSerial only works in Chromium browsers (Chrome, Edge, Brave) — Firefox and Safari silently fail. Connect USB from NerdMiner to PC. Click Install, pick your exact silkscreen match from the dropdown, confirm the serial port, let the installer do its thing (`30 - 60 s`). Installer handles `erase_flash` + `write_flash` + verify in one click. Unplug and replug USB — TFT should splash within `~3 s`.

If your board isn't in the upstream installer dropdown, check for a community fork. IdeaSpark `1.9"` ST7789 → Pixelssquad fork. IdeaSpark `1.14"` → Rob-The-Gob fork. `ESP32-2432S024C` → jbman2025 fork. Each fork publishes either its own web installer, a `.bin` release, or source with a board-specific `platformio.ini` env. Read the fork README to confirm it targets your exact silkscreen string — `supports CYD` is not specific enough; you need the exact part number match.

Post-flash, reconnect Wi-Fi and pool. A fresh flash typically wipes NVS, so the NerdMiner will come up in AP mode (`NerdMiner_XXXX`). Connect to the AP on your phone, complete setup wizard — Wi-Fi SSID/password, pool URL (`public-pool.io:21496` or `solo.ckpool.org:3333`), worker name, and your Bitcoin address for payouts (SegWit `bc1q...` or Taproot `bc1p...`). Watch the on-device TFT for the stats dashboard cycling through hashes, pool status, and Bitcoin price. Write down your pool URL and worker name before flashing the next time.

Leave the miner hashing for `30 minutes` before declaring recovery. The ESP32 stabilizes into normal rhythm — `~55 - 70 kH/s` per board on stock firmware depending on ESP32 variant. Accepted shares should start appearing on the TFT dashboard and on the pool-side worker list. If the display lights up for a few minutes and then goes dark again, that's a different failure (thermal, power, or firmware regression) — see nerdminer-display-not-working. If display stays on and miner holds Wi-Fi + pool, recovery complete.

Connect a USB serial terminal at `115200 baud` for live diagnosis. Use PuTTY (Windows), `screen /dev/ttyUSB0 115200` (Linux), or Arduino IDE Serial Monitor. Reset the NerdMiner and capture the first `10 - 15 s` of cold-boot output. Working firmware prints `NerdMiner v2.x.x`, `WiFi: connecting...`, `Display init OK`, `TFT_eSPI v2.5.x driver: ST7789` (or `ILI9341`), and `Mining started — hashes/sec: NNNNN`. If you see these but TFT is dark, firmware is fine and pinout is wrong. If you see `Guru Meditation` / `abort()` / reboot loops, different root cause — see bitaxe-esp32-crash-loop for ESP32 crash triage.

Use `esptool.py` directly when the web installer doesn't cover your board or fork. Install: `pip install --upgrade esptool`. For ESP32 non-S3: `esptool.py --chip esp32 --port COMx --baud 921600 erase_flash`, then `esptool.py --chip esp32 --port COMx --baud 921600 write_flash 0x0 <nerdminer.bin>`. For ESP32-S3 (T-Display-S3): swap `--chip esp32` for `--chip esp32s3`. CLI output tells you exactly what happened — timeout, checksum mismatch, verify fail, success. Espressif's toolchain is the reference; any browser WebSerial tool wraps it.

Verify your `.bin` source before flashing anything from outside BitMaker-hub/NerdMiner_v2 or a vetted community fork. Random `.bin` files from Discord link drops, Telegram channels, Google Drive mirrors are not verified sources. Stick with upstream repo, named forks in the decoder table, or the official web installer. If you must flash an unknown `.bin`, checksum-verify against a known-good copy first. A bricked NerdMiner from a confirmed-bad `.bin` is recoverable (ESP32 mask-ROM always responds to `BOOT` + `RESET`), but it's wasted time.

Check `TFT_BL` / backlight GPIO as a quick-confirm diagnostic. When you're not sure whether your wrong-board `.bin` matches any part of your hardware, backlight is the cheapest signal. In a dark room, tilt the screen — if the panel glows faintly grey/white, `TFT_BL` matches and is driving backlight correctly. That means SPI pinout is the only remaining problem. If fully dead-dark, both `TFT_BL` and SPI pinout are wrong — deeper mismatch. Some CYD variants need `TFT_BL` active HIGH, others active LOW — check the matching `User_Setup_*.h` to confirm.

Label every NerdMiner in your fleet with its exact board silkscreen. If you run more than one NerdMiner — and most solo-mining enthusiasts do — label each on the case with masking tape and Sharpie: `T-DISPLAY-ST7789`, `CYD-ILI9341`, `IDEASPARK-1.9"`. Keep `.bin` files in board-named folders: `~/firmware/nerdminer-t-display/`, `~/firmware/nerdminer-cyd/`, `~/firmware/nerdminer-ideaspark-1.9/`. Never batch-flash a mixed-board fleet without per-device verification. Workshop discipline eliminates the `which board is this?` mistake at 2 AM.

Clone the NerdMiner v2 source and build for your exact board. `git clone https://github.com/BitMaker-hub/NerdMiner_v2`. Install PlatformIO (VS Code extension easiest). Open the project — `platformio.ini` lists all supported envs. Find the env matching your silkscreen, or if none exists, copy the closest match as a new `[env:your-board-name]` section. Edit `build_flags` to point at correct `User_Setup_*.h` (e.g. `-DUSER_SETUP_LOADED=1 -include lib/TFT_eSPI/User_Setups/Setup_YourBoard.h`). Write a matching `Setup_YourBoard.h` with your GPIO assignments, driver macro (`ST7789_DRIVER`/`ILI9341_DRIVER`), `TFT_WIDTH`/`TFT_HEIGHT`, `TFT_BL`. Build and Upload via PlatformIO.

Reference a working `User_Setup_*.h` from a known-good fork when writing your own. If your board is close to an existing fork, clone the fork's `User_Setup_*.h` and edit just the pin assignments. Example: jbman2025's `ESP32-2432S024C` User_Setup.h is a good starting point for other ESP32-2432 variants. Critical pins: `TFT_MOSI`, `TFT_SCLK`, `TFT_CS`, `TFT_DC`, `TFT_RST`, `TFT_BL`. Critical macro: one of `ST7789_DRIVER`, `ILI9341_DRIVER`, `ST7735_DRIVER`. Critical sizes: `TFT_WIDTH`, `TFT_HEIGHT`, matching panel resolution (some rotations swap these). For hand-wired, pins are whatever you soldered.

Verify `User_Setup_Select.h` picks up your new `User_Setup.h`. The TFT_eSPI library has a default `User_Setup_Select.h` that `#include`s one of dozens of `Setup_*.h` files. If your `platformio.ini` `build_flags` don't override this, library falls back to default (usually `Setup1_ILI9341.h`) and your custom `Setup_YourBoard.h` is ignored. Check by dumping compiled binary for driver string literals: `esptool.py --chip esp32 --port COMx read_flash 0x10000 0x1000 partition-dump.bin`, then `strings partition-dump.bin | grep -E 'ST7789|ILI9341|ST7735'`. Right driver should appear; if not, build flags aren't reaching the preprocessor. `git clean -fdx && pio run -t clean && pio run` to force full rebuild.

For hand-wired NerdMiner v2 builds, confirm SPI frequency isn't too high for your wiring. Dupont jumpers and breadboard builds often can't sustain the default `SPI_FREQUENCY` (`27 MHz`+) reliably — panel initializes at `27 MHz` but garbles image data mid-frame, producing blank or flickering screen. Drop `SPI_FREQUENCY` to `10 MHz` in `User_Setup.h` and retest. If screen comes alive at `10 MHz` but not `27 MHz`, issue is signal integrity on wiring, not pinout — shorten jumpers, solder a proper PCB, or accept lower redraw rates.

Debug a stubborn custom-build with TFT_eSPI's built-in diagnostic sketch. Bodmer ships a diagnostic example in `TFT_eSPI/examples/Test and diagnostics/Read_User_Setup/`. Flash this sketch (not NerdMiner firmware) to your board via Arduino IDE or PlatformIO. Open serial at `115200 baud`. The sketch prints the compiled pinout, driver, and panel size — confirming what's actually in the binary versus what you intended. If sketch prints wrong driver or wrong pins, your `build_flags` / `User_Setup_Select.h` wiring is wrong, not your pin assignments. Fix the build-flag chain first, then rebuild NerdMiner firmware.

Stop DIY if repeated confirmed-correct-board flashes still leave the TFT dark AND backlight dead. You've matched the silkscreen, flashed three times cleanly, confirmed the web UI shows hashes, and the TFT is still fully dark with no backlight glow. At this point `TFT_BL` GPIO matches hardware but the panel itself is dead — cracked ribbon, failed LDO on the `3.3V` panel rail, physically damaged backlight LED driver. Crossed from firmware-pinout to hardware failure. Ship to D-Central — same-silicon bench as Bitaxe / NerdAxe / NerdQAxe.

Stop DIY if the ESP32 refuses mask-ROM bootloader even with `BOOT` + `EN/RESET` hold sequence. A physically-alive ESP32 / ESP32-S3 always responds to forced-bootloader — hold `BOOT`, tap `EN` (or `RESET`), release `BOOT`, USB re-enumerates in DFU. If USB enumeration fails on that sequence, the MCU is damaged: surge, ESD, solder-joint fracture, or die failure. No amount of firmware flashing fixes this.

Ship to D-Central with the silkscreen photo and a flash history. Pack the NerdMiner in anti-static, include USB cable and any custom case, and include a note: silkscreen part number, every `.bin` filename flashed (in order, from what source), observed failure mode, serial-console output if captured, whether web UI shows hashes. D-Central's open-source bench runs TFT panel replacement, SPI rework, ESP32 chip replacement, custom `User_Setup_*.h` authoring for exotic boards — same silicon family as Bitaxe, Nerd, NerdQAxe, same flash forensics. Canada-wide shipping; US / international welcomed. Turnaround `5 - 10` business days. D-Central pioneered the Bitaxe ecosystem — original Mesh Stand, first-manufactured Bitaxe / Hex heatsinks.

Consider the economics. Wrong-board-flash DIY recovery via web installer is `$0` — you own the PC and cable. D-Central bench firmware-only recovery (silkscreen confirmation, correct `.bin`, `30-minute` burn-in) is `CAD $25 - $65`. If recovery exposes hardware damage (TFT panel replacement, backlight LED driver, ESP32 reflow), quote rises to `CAD $45 - $145`. Full replacement NerdMiner v2 is `CAD $45 - $120`. DIY Tier 1 with the right web installer is always cheaper than shipping — bench only makes sense when DIY has exhausted pinout-mismatch paths and the board is worth more than labour.