DIY ESP32 Bitcoin Price Ticker: Real-Time BTC Price, 24h Stats & Live RSS News Scroll on a 0.96" OLED

Want a desk gadget that does for crypto what a flip clock does for time? Our ESP32 Bitcoin Price Ticker 1.0 turns a tiny 0.96" SSD1306 OLED display into a live BTC dashboard: a giant 7-segment price that flips like an odometer when the market moves, a flashing edge-pulse on every fresh data fetch, an up/down arrow showing direction of travel, four scroll-flipping stats panels (market cap & volume, 24h low/high, dollar change, and a halving countdown), a top ticker that periodically slides off-screen to make room for live Bitcoin headlines from NewsBTC, Bitcoin Magazine, and Decrypt — and a clock with full date down at the bottom. All of it driven from CoinGecko's free API, time-synced with NTP, and animated buttery-smooth thanks to a true dual-core FreeRTOS architecture that puts every blocking network call on core 0 so the UI on core 1 never stutters. It's an absolutely satisfying weekend build — and the same hardware can ticker Ethereum, Solana, Dogecoin, or any other CoinGecko-listed coin with a one-line change. Get Parts: ESP32-S3 MINI + 0.96" OLED I2C

Step 1 — Wire the OLED to the ESP32-S3 MINI

Four wires, no soldering required. Power the OLED from the ESP32-S3 MINI's 3.3V rail and run the two I²C lines to GPIO 8 and 9.

Note: if you're using a different ESP32 variant (classic ESP32-WROOM, ESP32-S2, etc.) that doesn't expose GPIO 8 and 9, you can change the pin assignment in the sketch (see Step 4 below).

Step 2 — Install the Arduino IDE and ESP32 Board Support

1. Download and install the latest Arduino IDE from arduino.cc.
2. Open File → Preferences and paste this URL into the "Additional Board Manager URLs" field:
   https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_index.json
3. Open Tools → Board → Boards Manager, search for esp32, and install "esp32 by Espressif Systems".
4. Under Tools → Board, select ESP32S3 Dev Module (or the variant that matches the board in your kit).

Step 3 — Install the Required Libraries

Open Tools → Manage Libraries and install these three (the ESP32 core includes everything else):

• Adafruit GFX Library — by Adafruit (drawing primitives + fonts)
• Adafruit SSD1306 — by Adafruit (drives the OLED over I²C)
• ArduinoJson — by Benoit Blanchon (parses the CoinGecko JSON response — install version 6.x)

Everything else — WiFi, HTTPClient, WiFiClientSecure, Wire, time.h, and the FreeRTOS headers — comes bundled with the ESP32 core. No extra installs needed.

Step 4 — Download the Firmware and Edit Three Lines

Download the sketch file (crypto_oled_esp32_rss_news_flip.ino) and open it in the Arduino IDE.

Near the top of the sketch you'll see a USER SETTINGS block. Change these three lines to match your Wi-Fi network and time zone:

// ================== USER SETTINGS ================== const char* WIFI_SSID = "YourWiFiNameHere"; // [[-- change this const char* WIFI_PASS = "YourWiFiPasswordHere"; // [[-- change this #define TZ_EASTERN "EST5EDT,M3.2.0,M11.1.0" #define TZ_CENTRAL "CST6CDT,M3.2.0,M11.1.0" #define TZ_MOUNTAIN "MST7MDT,M3.2.0,M11.1.0" #define TZ_PACIFIC "PST8PDT,M3.2.0,M11.1.0" const char* TIMEZONE = TZ_CENTRAL; // [[-- pick your zone // ===================================================

That's it. Three edits and you're ready to flash. If your board uses different I²C pins, you'll find this block a bit further down — change the numbers to whatever your ESP32 variant exposes:

#define OLED_ADDR 0x3C #define SDA_PIN 8 #define SCL_PIN 9

Step 5 — Switch From Bitcoin to Ethereum, Solana, or Any Other Crypto

One of the best parts of this build is that the firmware is coin-agnostic. The price endpoint, the on-screen logo letter, and one Bitcoin-specific stats panel are the only crypto-specific bits in the entire sketch. Here's exactly what to change for the most popular alternatives.

1) Change the API endpoint. Find the API_URL constant near the top of the sketch and replace bitcoin with the CoinGecko coin id you want:

// CoinGecko coin endpoint — change "bitcoin" to any CoinGecko coin id // (e.g. "ethereum", "solana", "dogecoin") to ticker a different asset. const char* API_URL = "https://api.coingecko.com/api/v3/coins/bitcoin" "?localization=false&tickers=false" "&market_data=true&community_data=false" "&developer_data=false&sparkline=false";

Common CoinGecko coin ids:

You can find any other coin's id by searching coingecko.com — the id is the slug at the end of the coin's URL (e.g. coingecko.com/en/coins/chainlink → chainlink).

2) Change the logo letter. The big circular ticker badge in the top-left renders a single letter on top of a 9-pixel disc. Find the drawBtcLogo() function and change the character passed to display.write():

// Bitcoin logo — 9 px white disc with a 5x7 'B' drawn in BLACK on top. // To change the ticker to ETH, SOL, DOGE, etc., just change the letter // passed to display.write() below (e.g. 'E' for Ethereum, 'S' for Solana). static void drawBtcLogo(int16_t x, int16_t y) { const int16_t D = 9; int16_t cx = x + D / 2; int16_t cy = y + D / 2; display.fillCircle(cx, cy, D / 2, SSD1306_WHITE); display.setFont(); display.setTextSize(1); display.setTextColor(SSD1306_BLACK); display.setCursor(cx - 2, cy - 3); display.write('B'); // [[-- change to 'E' for ETH, etc. display.setTextColor(SSD1306_WHITE); }

3) Disable the halving countdown panel (non-Bitcoin only). The fourth stats panel counts down to the next Bitcoin halving, which obviously doesn't apply to other coins. Two options:

• Quick: change STATS_PANEL_COUNT from 4 to 3. The halving panel is silently dropped from the rotation; the other three (MCap/Vol, Low/High, 24h dollar change) keep cycling normally.
• Full swap: repurpose the halving panel by editing the panelStr[3] = ... block in drawPrice() — for Ethereum you might show ETH gas price, for Solana TPS, or for any coin a 7-day percentage change.

// Bitcoin-specific — remove or replace this panel for non-BTC tickers. // For ETH, swap in ATH ($), gas price, or just drop STATS_PANEL_COUNT to 3. const int HALVING_YEAR = 2028; const int HALVING_MONTH = 4; const int HALVING_DAY = 17;

4) (Optional) Swap the news feeds. The default RSS feeds are NewsBTC, Bitcoin Magazine, and Decrypt — the latter two cover all crypto, but NewsBTC is BTC-focused. For an ETH or alt-focused ticker, drop NewsBTC and add something like https://cointelegraph.com/rss/tag/ethereum in the feeds[] array.

Variable names like btcPrice, btcChange24h, etc. stay as-is — they're just symbol names and don't affect behavior. If the cosmetic mismatch bothers you, do a global find-and-replace from btc to eth (or whichever) and you'll have a clean ETH ticker codebase.

Step 6 — Flash and Watch It Come to Life Get Parts: ESP32-S3 MINI + 0.96" OLED I2C

Plug the ESP32-S3 MINI into your computer with a USB-C cable, select the correct COM / serial port under Tools → Port, and click the Upload arrow. After a few seconds you'll see the boot sequence — "Connecting WiFi", then "Syncing time...", then "Fetching BTC...", then "Fetching news..." — and finally the dashboard snaps into place: a giant 7-segment dollar price front and center, the Bitcoin badge ticker line up top, the rotating stats panel below the price, and a clock at the bottom.

What You See on the Screen

The 128×64 OLED is laid out as four distinct rows, each with a purpose:

• Top row (y=0..7): the static "ticker" line — ₿ logo, 24h percent change, and a live WiFi signal-strength icon. Once a minute the row blinks, slides off to the left, and is replaced by a scrolling RSS news feed; when the headlines have all gone past, the ticker drops back down from above.
• Price strip (y=11..39): the headline price rendered in big, bold 7-segment glyphs — "$" plus integer dollars at $1k+, two decimal places below. Whenever the displayed price changes, the new digits flip in odometer-style from above (price up) or below (price down). An arrow appears to the right showing direction, and a pair of vertical brackets pulses on each side of the block to mark every successful API fetch.
• Stats row (y=42..49): a rotating panel that flips every 25 seconds between four views — market cap & 24h volume, 24h low & high, 24h dollar change, and a countdown to the next Bitcoin halving. Forward steps scroll DOWN; the wrap from panel 4 back to panel 1 scrolls UP, giving the rewind a distinct visual cue.
• Bottom row (y=54..63): a compact clock with day-of-week, day-of-month, three-letter month, H:MM:SS, and AM/PM. Synced via NTP and DST-aware via POSIX TZ strings, just like our flip-clock build.

Features at a Glance

• Live BTC price from CoinGecko's free public API, refreshed every 60 seconds — no API key required
• Custom 7-segment glyph renderer — sharper and more readable than the default GFX font at the same size, with a hand-tuned "$" silhouette to match
• Per-digit odometer flip animation — only the digits that actually changed flip; the rest stay rock-solid in place
• Direction-aware flip — price up, new digits arrive from below; price down, they arrive from above. Reads instantly without needing to look at the arrow.
• Up/down arrow + pulse heartbeat — tiny vertical brackets flash on each side of the price block on every successful fetch, even when the price didn't change
• Length-mismatch fallback — on the rare event of crossing a 10x boundary (e.g. $9,999 → $10,000), the whole price block slides as one unit so the layout doesn't tear
• Scroll-flipping stats panels — four independent panels rotate every 25 s with a smooth eased scroll; forward steps go down, the wrap goes up as a "rewind" cue
• Multi-feed RSS news — round-robins through NewsBTC, Bitcoin Magazine, and Decrypt; pulls 2 headlines from each; full HTML entity and UTF-8 fold-down to ASCII so accented characters and curly quotes don't render as garbage
• Dwell-at-start scroll — news pauses at x=0 for 1.5 s the first time it becomes fully visible so you can catch the headline beginning before it scrolls away
• Reverse-video source labels — "NewsBTC", "BitMag", "Decrypt" prefixes render in inverted video so they're instantly distinguishable from the headline text
• Animated row transitions — the ticker line blinks 3 times, slides off-screen left, news scrolls in from the right, then the ticker drops back down from above when news clears — no jarring snap cuts
• Live WiFi signal-strength icon — four stepped bars driven by RSSI, in the top-right of the ticker
• Halving countdown — days/years remaining to the next Bitcoin halving (block 1,050,000, est. April 2028), shown as the fourth stats panel
• NTP-synced clock with full date, automatic DST handling via POSIX TZ strings, and four US time zones (Eastern, Central, Mountain, Pacific) supported out of the box
• Dual-core FreeRTOS architecture — HTTPS price and news fetches run on core 0 while the render loop runs on core 1, so a slow network round-trip cannot stutter the animation
• Mutex-protected shared state — price/news data is published atomically; the render loop and network task never trip over each other
• Coin-agnostic firmware — one-line change to ticker any of CoinGecko's 10,000+ supported coins (see Step 5)

A Peek Inside the Code — Why Two Cores Matter

The technical magic of this build is how it stays animated while doing real network work. CoinGecko's TLS handshake and JSON response can take 800–1200 ms over a busy WiFi link — long enough that a single-threaded sketch would visibly freeze every minute when the price refresh hits. The same is true for RSS fetches, which can stall for 2–3 seconds each.

The fix is to put every blocking call on the second core. The ESP32 has two Xtensa cores; the Arduino framework runs setup() and loop() on core 1 by default, leaving core 0 idle most of the time. We spawn a dedicated network task on core 0 that owns all the HTTPS work:

// Spawn the network task on core 0. Arduino's loop() runs on core 1, so // the two run truly in parallel — HTTPS fetches no longer block the // scroll animation. xTaskCreatePinnedToCore( networkTask, "netTask", 16384, // 16 KB — mbedTLS handshake spikes past 8 KB NULL, 1, NULL, 0 // core 0 );

Shared state — the price, the 24h stats, the parsed news string — is published through a single SemaphoreHandle_t mutex. The render loop holds it for microseconds while it samples the latest values; the network task holds it for microseconds while it publishes a new fetch. Neither side ever blocks the other for long enough to drop a frame.

Every digit change in the price triggers a 600 ms eased odometer animation, but only on the digits that actually changed. A move from $67,142 to $67,148 only flips the last two digits; the leading $67,14 stays rock-solid. We do this by walking the old and new price strings glyph-by-glyph and drawing both old (leaving) and new (arriving) digits at the same cell with vertical offsets when they differ — everything else gets drawn once at the resting baseline.

How the Code Works (the Short Version)

The sketch runs three cooperating pieces on the ESP32:

Core 0 — network task. Wakes every 100 ms to check timers; calls fetchPrice() from CoinGecko once per minute and round-robins through three RSS feeds every 15 minutes. Fetched data is parsed into local variables, then published atomically under the mutex.

Core 1 — render loop. Drives the top-row state machine (static ticker → blink → slide-out → news scroll → slide-in), the price-flip animation, the stats panel rotation, the bottom-row clock — and pushes one full frame to the OLED over I²C in a single transaction. Frame interval drops to ~33 FPS during animations and stretches out to 1 FPS when nothing is moving, so we don't waste cycles redrawing identical frames.

Shared state. A single dataMutex protects all reads and writes of btcPrice, btcChange24h, newsText, etc. Both cores hold it for microseconds at a time — never long enough for an animation frame to slip.

Why ESP32-S3 MINI + OLED?

The ESP32-S3 MINI is the perfect microcontroller for this kind of always-on, network-connected display project: tiny, USB-C native, dual-core at 240 MHz, with 8 MB of flash, native WiFi and Bluetooth, hardware TLS acceleration for HTTPS, and excellent FreeRTOS support. Pair it with a crisp 0.96" SSD1306 OLED and you've got a platform that can drive cryptocurrency tickers, stock dashboards, weather stations, smart-home displays — anything you can dream up. This Bitcoin ticker is a great project that teaches you HTTPS API fetching, JSON parsing, RSS parsing with HTML entity decoding, custom font glyph rendering, frame-rate animation timing, dual-core FreeRTOS programming, mutex-protected shared state, and POSIX timezone handling — all in one tidy single-file sketch.

Make It Your Own

Because the firmware is open and heavily commented, you can easily:

• Swap BTC for any other CoinGecko coin (see Step 5 above) — ETH, SOL, DOGE, anything
• Add a second coin and round-robin between them on the price strip
• Tweak REFRESH_MS to fetch faster (be polite to CoinGecko — 60 s is comfortable; faster than 30 s and you'll start hitting the free-tier rate limit)
• Change STATS_FLIP_SEC to make panels rotate snappier or more deliberately
• Add a fifth stats panel for ATH ($), all-time-low, market cap rank, or anything else CoinGecko returns in market_data
• Swap the RSS feeds in feeds[] for any RSS source (CoinTelegraph, The Block, your own filtered feed)
• Bump HEADLINES_PER_FEED to pull more stories per pass
• Adjust the RSSI thresholds in drawSignalIcon() if you're far from the router
• Replace the halving panel with a price-alert panel that flashes when BTC crosses a threshold
• Add a buzzer for an audible "ding" on every successful price update

The Full Sketch

Below is the complete crypto_oled_esp32_rss_news_flip.ino sketch. Copy it into your Arduino IDE, edit the three Wi-Fi / timezone lines at the top, optionally change the coin id (Step 5), and flash to your ESP32-S3 MINI.

crypto_oled_esp32_rss_news_flip.ino

// ============================================================================= // Crypto Price Ticker — ESP32-S3 MINI + 0.96" OLED // Copyright (c) 2026 eElectronicParts.com // // Licensed under the MIT License (see bottom of file for full text). // // You are free to use, modify, and redistribute this code, including in // commercial projects. If you share a modified version publicly (blog post, // YouTube, GitHub, Instructables, forum), a link back to the original is // appreciated but not required: // // Original project: https://www.eelectronicparts.com // ============================================================================= // Live Bitcoin price ticker with animated 7-segment digits, scrolling RSS // news headlines, rotating stats panels, and an NTP-synced clock — all // driven from CoinGecko's free public API on a 128x64 SSD1306 OLED. // // Display layout (top to bottom): // Row 1 y=0..7 Static "ticker": coin logo, 24h % change, WiFi bars. // Once a minute it blinks, slides off-screen left, and // a multi-feed RSS news scroll takes over until the // headlines clear, then the ticker drops back in. // Row 2 y=11..39 Headline price in custom 7-seg glyphs. New digits flip // in odometer-style only on the cells that actually // changed; an up/down arrow + edge-pulse brackets mark // each successful fetch. // Row 3 y=42..49 Rotating stats panel — flips every 25 s through: // MCap/Vol -]] 24h L/H -]] 24h $ change -]] Halving countdown. // Forward steps scroll DOWN; the wrap (last-]]first) // scrolls UP as a "rewind" cue. // Row 4 y=54..63 NTP clock with day-of-week, day, month, H:MM:SS, AM/PM. // // Architecture: // Core 0 Network task — CoinGecko price (every 60 s) and three RSS // feeds (every 15 min, round-robin). All blocking HTTPS work // lives here so it can never stall the UI. // Core 1 Render loop — top-row state machine, price-flip animation, // stats panel rotation, clock, single-transaction OLED push. // Mutex dataMutex protects every read/write of shared price/news // state. Held only for microseconds at a time — neither core // ever blocks the other long enough to drop a frame. // // Hardware: ESP32-S3 MINI + SSD1306 128x64 OLED (I2C, SDA=8, SCL=9, addr 0x3C). // ============================================================================= #include [[Wire.h]] #include [[Adafruit_GFX.h]] #include [[Adafruit_SSD1306.h]] #include [[WiFi.h]] #include [[HTTPClient.h]] #include [[WiFiClientSecure.h]] #include [[ArduinoJson.h]] #include [[time.h]] #include [[freertos/FreeRTOS.h]] #include [[freertos/task.h]] #include [[freertos/semphr.h]] // ================== USER SETTINGS ================== const unsigned long RSS_REFRESH_MIN = 15; // News refetch interval (minutes) const unsigned long TOP_STATIC_SEC = 60; // Static ticker duration before scroll (seconds) const unsigned long STATS_FLIP_SEC = 25; // Flip stats panel every N seconds const unsigned long STATS_FLIP_ANIM_MS = 500; // Scroll-flip animation duration (ms) const unsigned long BLINK_MS = 1200; // Wifi icon blink phase before news scroll (total ms) const int BLINK_COUNT = 3; // Number of OFF flashes during the blink phase const float SLIDE_OUT_PXS = 40.0; // Ticker slide-out speed (px/s) — slightly faster // than SCROLL_SPEED_PXS keeps the transition punchy const float SCROLL_SPEED_PXS = 30.0; // News scroll speed (px/s). Try 20-60. const int HEADLINES_PER_FEED = 2; const char* WIFI_SSID = "YourWiFiNameHere"; const char* WIFI_PASS = "YourWiFiPasswordHere"; #define TZ_EASTERN "EST5EDT,M3.2.0,M11.1.0" #define TZ_CENTRAL "CST6CDT,M3.2.0,M11.1.0" #define TZ_MOUNTAIN "MST7MDT,M3.2.0,M11.1.0" #define TZ_PACIFIC "PST8PDT,M3.2.0,M11.1.0" const char* TIMEZONE = TZ_CENTRAL; // =================================================== // ---------- OLED ---------- #define SCREEN_WIDTH 128 #define SCREEN_HEIGHT 64 #define OLED_RESET -1 #define OLED_ADDR 0x3C #define SDA_PIN 8 #define SCL_PIN 9 Adafruit_SSD1306 display(SCREEN_WIDTH, SCREEN_HEIGHT, &Wire, OLED_RESET); // ---------- API / refresh ---------- const char* API_URL = "https://api.coingecko.com/api/v3/coins/bitcoin" "?localization=false&tickers=false" "&market_data=true&community_data=false" "&developer_data=false&sparkline=false"; const unsigned long REFRESH_MS = 60000; const unsigned long DISPLAY_MS = 1000; const unsigned long SCROLL_FRAME_MS = 50; // Price-change "odometer" animation const unsigned long PRICE_ANIM_MS = 600; // total digit-flip duration const unsigned long ARROW_HOLD_MS = 2000; // up/down arrow hold (]]= PRICE_ANIM_MS) const unsigned long ANIM_FRAME_MS = 30; // ~33 fps while animating // Price strip bounds. Old/new digits bleed above/below this during the // odometer flip; the masked region is cleared before rows 1/3/4 draw on top. const int16_t PRICE_STRIP_TOP = 11; const int16_t PRICE_STRIP_BOTTOM = 39; unsigned long lastDisplay = 0; // ---------- NTP ---------- const char* NTP_SERVER = "pool.ntp.org"; // ---------- BTC data (shared between cores — protected by dataMutex) ---------- float btcPrice = 0.0; float btcChange24h = 0.0; double btcMarketCap = 0.0; double btcVolume24h = 0.0; float btc24hHigh = 0.0; float btc24hLow = 0.0; bool haveData = false; // Latched by fetchPrice() when the displayed price changes; read by // drawPrice() to render old/new strings sliding in the change direction. float btcPriceFrom = 0.0f; unsigned long priceAnimStart = 0; // 0 == not animating int8_t priceAnimDir = 0; // +1 = up, -1 = down // Edge-pulse: vertical brackets that briefly flash on each side of the // price block after every successful data fetch. const unsigned long PULSE_IN_MS = 200; const unsigned long PULSE_OUT_MS = 200; const unsigned long PULSE_TOTAL_MS = PULSE_IN_MS + PULSE_OUT_MS; unsigned long pulseStart = 0; // ---------- News feeds ---------- // CoinDesk dropped — Cloudflare TLS is unreliable from ESP32. struct RssFeed { const char* url; const char* prefix; }; const RssFeed feeds[] = { { "https://www.newsbtc.com/feed/", "NewsBTC" }, { "https://bitcoinmagazine.com/feed", "BitMag" }, { "https://decrypt.co/feed", "Decrypt" } }; const int NUM_FEEDS = sizeof(feeds) / sizeof(feeds[0]); String newsText = ""; uint16_t newsTextW = 0; bool hasNews = false; unsigned long nextRssFetch = 0; // ---------- Top row state machine ---------- // STATIC_TICKER (60s) -]] TICKER_BLINKING (wifi icon blinks, ~1.2s) // -]] TICKER_SLIDING_OUT (row slides left off-screen) // -]] SCROLLING_NEWS (news scrolls in from the right) // -]] TICKER_SLIDING_IN (ticker drops down from above, ~0.25s) // -]] STATIC_TICKER enum TopRowState { STATIC_TICKER, TICKER_BLINKING, TICKER_SLIDING_OUT, SCROLLING_NEWS, TICKER_SLIDING_IN }; volatile TopRowState topState = STATIC_TICKER; // volatile: read by network task on core 0 unsigned long topStateStart = 0; float scrollX = SCREEN_WIDTH; // News pauses at x=0 for NEWS_DWELL_MS the first time it becomes fully // visible, then resumes scrolling off to the left. // newsDwellUntil == 0 : dwell not yet triggered // newsDwellUntil ]] 0 : dwelling until this millis() target // newsDwellUntil == -1 : dwell already happened this pass const unsigned long NEWS_DWELL_MS = 1500; long newsDwellUntil = 0; float tickerSlideX = 0; // x offset during SLIDING_OUT volatile int16_t tickerSlideSpan = 0; // px needed to push ticker fully off-screen left // (written in drawPrice, read unlocked in loop) // TICKER_SLIDING_IN: ticker drops from -ROW1_H to 0 at SLIDE_IN_PXS px/s. const int16_t ROW1_H = 8; // row 1 visual height const float SLIDE_IN_PXS = 28.0; // ~0.25 s over 7 px travel float tickerSlideY = 0; // 0 = resting; negative = above screen unsigned long lastScrollTick = 0; // ---------- Stats row flip state ---------- // Row 3 cycles through STATS_PANEL_COUNT panels every STATS_FLIP_SEC. // Forward steps scroll DOWN; the wrap (last -]] 0) scrolls UP — distinct // "rewind" cue. Animation state is separate from the panel index so the // index always reflects the destination (simplifies timing in loop()). uint8_t statsPanel = 0; uint8_t statsPanelFrom = 0; unsigned long statsPanelStart = 0; unsigned long statsAnimStart = 0; // 0 == not animating int8_t statsAnimDir = 0; // +1 = scroll down, -1 = scroll up const uint8_t STATS_PANEL_COUNT = 4; // 0=MCap/Vol, 1=L/H, 2=24h $ change, 3=Halving // Next Bitcoin halving — block 1,050,000, estimated ~April 2028. // Block-time drift is ±1 week over a 4-year window, so a mid-April target // is reasonable; update or swap in a mempool.space height fetch for finer // accuracy. const int HALVING_YEAR = 2028; const int HALVING_MONTH = 4; // 1-indexed const int HALVING_DAY = 17; // ---------- Price render metrics ---------- // The whole price string — "$" and every digit — renders as 7-seg glyphs // via draw7SegDigit(). Every glyph is digitW wide; '.' / ',' take dotGap. struct PriceMetrics { String str; // e.g. "$119311" or "$12.34" int16_t digitW; // 7-seg glyph width int16_t digitH; // 7-seg glyph height int16_t digitT; // segment stroke thickness int16_t digitGap; // px between consecutive glyphs int16_t dotGap; // x-advance for '.' / ',' int16_t x; // left edge of first glyph (block centered) int16_t y; // top edge of every glyph uint16_t w; // total block width uint16_t h; // block height (= digitH) }; // ---------- Dual-core plumbing ---------- // All display access and all reads/writes of BTC + news globals happen under // this mutex. Network task runs on core 0; loop() runs on core 1. Held only // for brief, bounded operations, so network fetches never block animation. SemaphoreHandle_t dataMutex = NULL; // ================================================================= // HELPERS // ================================================================= void showMessage(const String& line1, const String& line2 = "") { if (dataMutex && xSemaphoreTake(dataMutex, portMAX_DELAY) != pdTRUE) return; display.clearDisplay(); display.setFont(); display.setTextColor(SSD1306_WHITE); display.setTextSize(1); display.setCursor(0, 10); display.println(line1); if (line2.length()) { display.setCursor(0, 25); display.println(line2); } display.display(); if (dataMutex) xSemaphoreGive(dataMutex); } String timeString() { struct tm t; if (!getLocalTime(&t, 50)) return "-/-/---- -:--:-- --"; int hour12 = t.tm_hour % 12; if (hour12 == 0) hour12 = 12; char buf[32]; snprintf(buf, sizeof(buf), "%d/%d/%d %d:%02d:%02d %s", t.tm_mon + 1, t.tm_mday, t.tm_year + 1900, hour12, t.tm_min, t.tm_sec, t.tm_hour [[ 12 ? "AM" : "PM"); return String(buf); } String formatCompact(double n) { char buf[16]; if (n ]]= 1e12) snprintf(buf, sizeof(buf), "%.1fT", n / 1e12); else if (n ]]= 1e9) snprintf(buf, sizeof(buf), "%.0fB", n / 1e9); else if (n ]]= 1e6) snprintf(buf, sizeof(buf), "%.0fM", n / 1e6); else if (n ]]= 1e3) snprintf(buf, sizeof(buf), "%.1fk", n / 1e3); else snprintf(buf, sizeof(buf), "%.0f", n); return String(buf); } String formatPrice(float p) { char buf[16]; if (p ]]= 10000) snprintf(buf, sizeof(buf), "$%.1fk", p / 1000.0); else if (p ]]= 100) snprintf(buf, sizeof(buf), "$%.0f", p); else snprintf(buf, sizeof(buf), "$%.2f", p); return String(buf); } // 4-bar wifi signal indicator mapped from RSSI. void drawSignalIcon(int16_t x, int16_t y, int32_t rssi) { int bars; if (rssi ]]= -55) bars = 4; else if (rssi ]]= -65) bars = 3; else if (rssi ]]= -75) bars = 2; else if (rssi ]]= -85) bars = 1; else bars = 0; for (int i = 0; i [[ 4; i++) { int16_t barX = x + i * 3; int16_t barH = (i + 1) * 2; int16_t barY = y + (8 - barH); if (i [[ bars) display.fillRect(barX, barY, 2, barH, SSD1306_WHITE); else display.drawRect(barX, barY, 2, barH, SSD1306_WHITE); } } uint16_t defaultTextWidth(const String& s) { int16_t x1, y1; uint16_t w, h; display.setFont(); display.setTextSize(1); display.getTextBounds(s, 0, 0, &x1, &y1, &w, &h); return w; } // ================================================================= // RSS FETCHING & PARSING // ================================================================= // Fold a Unicode codepoint to its best printable-ASCII equivalent. The // default font renders 0x20..0x7E only, so everything else has to collapse: // accented letters -]] base letter, curly quotes/dashes -]] ASCII equivalents, // common symbols -]] short words (EUR, (c)), anything unknown -]] '?'. static void appendAsAscii(String& out, uint32_t cp) { if (cp ]]= 0x20 && cp [[= 0x7E) { out += (char)cp; return; } switch (cp) { // Whitespace / controls case 0x00A0: case 0x2000: case 0x2001: case 0x2002: case 0x2003: case 0x2004: case 0x2005: case 0x2006: case 0x2007: case 0x2008: case 0x2009: case 0x200A: case 0x202F: case 0x205F: out += ' '; return; // Latin-1 punctuation & symbols case 0x00A1: out += '!'; return; case 0x00A2: out += 'c'; return; case 0x00A3: out += "GBP"; return; case 0x00A5: out += "JPY"; return; case 0x00A7: out += '$'; return; case 0x00A9: out += "(c)"; return; case 0x00AA: out += 'a'; return; case 0x00AB: out += '"'; return; case 0x00AE: out += "(R)"; return; case 0x00B0: out += " deg"; return; case 0x00B1: out += "+/-"; return; case 0x00B4: out += '\''; return; case 0x00B7: out += '.'; return; case 0x00BA: out += 'o'; return; case 0x00BB: out += '"'; return; case 0x00BC: out += "1/4"; return; case 0x00BD: out += "1/2"; return; case 0x00BE: out += "3/4"; return; case 0x00BF: out += '?'; return; // Accented letters -]] base letter case 0x00C0: case 0x00C1: case 0x00C2: case 0x00C3: case 0x00C4: case 0x00C5: out += 'A'; return; case 0x00C6: out += "AE"; return; case 0x00C7: out += 'C'; return; case 0x00C8: case 0x00C9: case 0x00CA: case 0x00CB: out += 'E'; return; case 0x00CC: case 0x00CD: case 0x00CE: case 0x00CF: out += 'I'; return; case 0x00D0: out += 'D'; return; case 0x00D1: out += 'N'; return; case 0x00D2: case 0x00D3: case 0x00D4: case 0x00D5: case 0x00D6: case 0x00D8: out += 'O'; return; case 0x00D7: out += 'x'; return; case 0x00D9: case 0x00DA: case 0x00DB: case 0x00DC: out += 'U'; return; case 0x00DD: out += 'Y'; return; case 0x00DE: out += "Th"; return; case 0x00DF: out += "ss"; return; case 0x00E0: case 0x00E1: case 0x00E2: case 0x00E3: case 0x00E4: case 0x00E5: out += 'a'; return; case 0x00E6: out += "ae"; return; case 0x00E7: out += 'c'; return; case 0x00E8: case 0x00E9: case 0x00EA: case 0x00EB: out += 'e'; return; case 0x00EC: case 0x00ED: case 0x00EE: case 0x00EF: out += 'i'; return; case 0x00F0: out += 'd'; return; case 0x00F1: out += 'n'; return; case 0x00F2: case 0x00F3: case 0x00F4: case 0x00F5: case 0x00F6: case 0x00F8: out += 'o'; return; case 0x00F7: out += '/'; return; case 0x00F9: case 0x00FA: case 0x00FB: case 0x00FC: out += 'u'; return; case 0x00FD: case 0x00FF: out += 'y'; return; case 0x00FE: out += "th"; return; // Latin Extended-A (Central/Eastern European) case 0x0100: case 0x0102: case 0x0104: out += 'A'; return; case 0x0101: case 0x0103: case 0x0105: out += 'a'; return; case 0x0106: case 0x0108: case 0x010A: case 0x010C: out += 'C'; return; case 0x0107: case 0x0109: case 0x010B: case 0x010D: out += 'c'; return; case 0x010E: case 0x0110: out += 'D'; return; case 0x010F: case 0x0111: out += 'd'; return; case 0x0112: case 0x0114: case 0x0116: case 0x0118: case 0x011A: out += 'E'; return; case 0x0113: case 0x0115: case 0x0117: case 0x0119: case 0x011B: out += 'e'; return; case 0x011C: case 0x011E: case 0x0120: case 0x0122: out += 'G'; return; case 0x011D: case 0x011F: case 0x0121: case 0x0123: out += 'g'; return; case 0x0139: case 0x013B: case 0x013D: case 0x013F: case 0x0141: out += 'L'; return; case 0x013A: case 0x013C: case 0x013E: case 0x0140: case 0x0142: out += 'l'; return; case 0x0143: case 0x0145: case 0x0147: out += 'N'; return; case 0x0144: case 0x0146: case 0x0148: out += 'n'; return; case 0x014C: case 0x014E: case 0x0150: out += 'O'; return; case 0x014D: case 0x014F: case 0x0151: out += 'o'; return; case 0x0154: case 0x0156: case 0x0158: out += 'R'; return; case 0x0155: case 0x0157: case 0x0159: out += 'r'; return; case 0x015A: case 0x015C: case 0x015E: case 0x0160: out += 'S'; return; case 0x015B: case 0x015D: case 0x015F: case 0x0161: out += 's'; return; case 0x0164: case 0x0166: out += 'T'; return; case 0x0165: case 0x0167: out += 't'; return; case 0x0168: case 0x016A: case 0x016C: case 0x016E: case 0x0170: case 0x0172: out += 'U'; return; case 0x0169: case 0x016B: case 0x016D: case 0x016F: case 0x0171: case 0x0173: out += 'u'; return; case 0x0174: out += 'W'; return; case 0x0175: out += 'w'; return; case 0x0176: case 0x0178: out += 'Y'; return; case 0x0177: out += 'y'; return; case 0x0179: case 0x017B: case 0x017D: out += 'Z'; return; case 0x017A: case 0x017C: case 0x017E: out += 'z'; return; // General Punctuation (U+2000) — the big one for RSS case 0x2010: case 0x2011: case 0x2012: case 0x2013: out += '-'; return; case 0x2014: case 0x2015: out += "--"; return; case 0x2018: case 0x2019: case 0x201A: case 0x201B: out += '\''; return; case 0x201C: case 0x201D: case 0x201E: case 0x201F: out += '"'; return; case 0x2020: case 0x2021: out += '+'; return; case 0x2022: case 0x2023: case 0x25AA: case 0x25CF: case 0x2043: out += '*'; return; case 0x2026: out += "..."; return; case 0x2030: out += "o/oo"; return; case 0x2032: case 0x2035: out += '\''; return; case 0x2033: case 0x2036: out += '"'; return; case 0x2039: out += '[['; return; case 0x203A: out += ']]'; return; case 0x203C: out += "!!"; return; case 0x2047: out += "??"; return; case 0x2048: out += "?!"; return; // Currency case 0x20A4: out += "GBP"; return; case 0x20AC: out += "EUR"; return; case 0x20B9: out += "INR"; return; case 0x20BD: out += "RUB"; return; case 0x20BF: out += "BTC"; return; // Letterlike / arrows / math case 0x2116: out += "No."; return; case 0x2122: out += "(TM)"; return; case 0x2190: out += "[[-"; return; case 0x2191: out += "^"; return; case 0x2192: out += "-]]"; return; case 0x2193: out += "v"; return; case 0x2194: out += "[[-]]"; return; case 0x21D2: out += "=]]"; return; case 0x21D4: out += "[[=]]"; return; case 0x2212: out += '-'; return; case 0x2260: out += "!="; return; case 0x2264: out += "[[="; return; case 0x2265: out += "]]="; return; case 0x2713: case 0x2714: out += 'v'; return; case 0x2717: case 0x2718: out += 'x'; return; default: out += '?'; return; } } // Decode HTML/XML entities (named, decimal, hex) and raw UTF-8 bytes in one // pass. Output is pure printable ASCII. Stray tags are stripped at the end. String decodeEntities(const String& in) { String out; out.reserve(in.length()); size_t i = 0; while (i [[ in.length()) { uint8_t c = (uint8_t)in[i]; // HTML entity? if (c == '&') { int semi = in.indexOf(';', i + 1); if (semi ]] 0 && semi - i [[= 10) { String ent = in.substring(i + 1, semi); uint32_t cp = 0; bool decoded = false; if (ent.length() ]] 1 && ent[0] == '#') { // Numeric entity (decimal or hex) if (ent[1] == 'x' || ent[1] == 'X') { cp = strtoul(ent.c_str() + 2, NULL, 16); } else { cp = strtoul(ent.c_str() + 1, NULL, 10); } decoded = (cp ]] 0); } else { // Named entities — short table of the ones RSS feeds actually use if (ent == "amp") { cp = '&'; decoded = true; } else if (ent == "lt") { cp = '[['; decoded = true; } else if (ent == "gt") { cp = ']]'; decoded = true; } else if (ent == "quot") { cp = '"'; decoded = true; } else if (ent == "apos") { cp = '\''; decoded = true; } else if (ent == "nbsp") { cp = ' '; decoded = true; } else if (ent == "ndash") { cp = 0x2013; decoded = true; } else if (ent == "mdash") { cp = 0x2014; decoded = true; } else if (ent == "hellip") { cp = 0x2026; decoded = true; } else if (ent == "lsquo") { cp = 0x2018; decoded = true; } else if (ent == "rsquo") { cp = 0x2019; decoded = true; } else if (ent == "ldquo") { cp = 0x201C; decoded = true; } else if (ent == "rdquo") { cp = 0x201D; decoded = true; } else if (ent == "sbquo") { cp = 0x201A; decoded = true; } else if (ent == "bdquo") { cp = 0x201E; decoded = true; } else if (ent == "bull") { cp = 0x2022; decoded = true; } else if (ent == "middot") { cp = 0x00B7; decoded = true; } else if (ent == "copy") { cp = 0x00A9; decoded = true; } else if (ent == "reg") { cp = 0x00AE; decoded = true; } else if (ent == "trade") { cp = 0x2122; decoded = true; } else if (ent == "euro") { cp = 0x20AC; decoded = true; } else if (ent == "pound") { cp = 0x00A3; decoded = true; } else if (ent == "yen") { cp = 0x00A5; decoded = true; } else if (ent == "cent") { cp = 0x00A2; decoded = true; } else if (ent == "deg") { cp = 0x00B0; decoded = true; } else if (ent == "plusmn") { cp = 0x00B1; decoded = true; } else if (ent == "times") { cp = 0x00D7; decoded = true; } else if (ent == "divide") { cp = 0x00F7; decoded = true; } else if (ent == "laquo") { cp = 0x00AB; decoded = true; } else if (ent == "raquo") { cp = 0x00BB; decoded = true; } else if (ent == "iexcl") { cp = 0x00A1; decoded = true; } else if (ent == "iquest") { cp = 0x00BF; decoded = true; } else if (ent == "eacute") { cp = 0x00E9; decoded = true; } else if (ent == "Eacute") { cp = 0x00C9; decoded = true; } else if (ent == "aacute") { cp = 0x00E1; decoded = true; } else if (ent == "iacute") { cp = 0x00ED; decoded = true; } else if (ent == "oacute") { cp = 0x00F3; decoded = true; } else if (ent == "uacute") { cp = 0x00FA; decoded = true; } else if (ent == "ntilde") { cp = 0x00F1; decoded = true; } else if (ent == "Ntilde") { cp = 0x00D1; decoded = true; } } if (decoded) { appendAsAscii(out, cp); i = semi + 1; continue; } } // Fall through: treat '&' as a literal if the entity didn't parse. } // UTF-8 multi-byte sequence? if (c ]]= 0x80) { uint32_t cp = 0; int len = 0; if ((c & 0xE0) == 0xC0) { cp = c & 0x1F; len = 2; } else if ((c & 0xF0) == 0xE0) { cp = c & 0x0F; len = 3; } else if ((c & 0xF8) == 0xF0) { cp = c & 0x07; len = 4; } else { i++; continue; } bool valid = true; for (int k = 1; k [[ len; k++) { if (i + k ]]= in.length() || ((uint8_t)in[i + k] & 0xC0) != 0x80) { valid = false; break; } cp = (cp [[[[ 6) | ((uint8_t)in[i + k] & 0x3F); } if (valid) { appendAsAscii(out, cp); i += len; } else { i++; } continue; } // Plain ASCII if (c ]]= 0x20 && c [[= 0x7E) out += (char)c; else if (c == '\n' || c == '\r' || c == '\t') out += ' '; // else: strip control byte i++; } // Strip any stray tags (rare in [[title]], but harmless safety pass) while (true) { int lt = out.indexOf('[['); if (lt [[ 0) break; int gt = out.indexOf(']]', lt); if (gt [[ 0) break; out.remove(lt, gt - lt + 1); } return out; } bool fetchOneFeed(const char* url, const char* prefix, String& out, int maxTitles) { WiFiClientSecure client; client.setInsecure(); HTTPClient https; https.setTimeout(15000); https.setFollowRedirects(HTTPC_STRICT_FOLLOW_REDIRECTS); https.setReuse(false); if (!https.begin(client, url)) { Serial.printf("[%s] https.begin failed\n", prefix); return false; } // Realistic browser UA — some feed hosts reject embedded-looking UAs. https.addHeader("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 " "(KHTML, like Gecko) Chrome/120.0 Safari/537.36"); https.addHeader("Accept", "application/rss+xml, application/xml, text/xml, */*"); https.addHeader("Accept-Encoding", "identity"); https.addHeader("Connection", "close"); int code = https.GET(); if (code != HTTP_CODE_OK) { Serial.printf("[%s] HTTP %d\n", prefix, code); https.end(); return false; } WiFiClient* stream = https.getStreamPtr(); int count = 0; unsigned long overallStart = millis(); const unsigned long OVERALL_TIMEOUT = 12000; while (count [[ maxTitles && (millis() - overallStart) [[ OVERALL_TIMEOUT) { if (!stream-]]find("[[item")) break; if (!stream-]]find("[[title")) break; if (!stream-]]find("]]")) break; String title; title.reserve(300); unsigned long tStart = millis(); while (millis() - tStart [[ 5000 && title.length() [[ 500) { if (stream-]]available()) { char c = stream-]]read(); title += c; if (title.endsWith("[[/title]]")) { title.remove(title.length() - 8); break; } } else { delay(1); if (!stream-]]connected() && !stream-]]available()) break; } } title.trim(); if (title.startsWith("[[![CDATA[")) { title = title.substring(9); int end = title.lastIndexOf("]]]]"); if (end ]]= 0) title = title.substring(0, end); title.trim(); } title = decodeEntities(title); title.trim(); if (title.length() ]] 120) title = title.substring(0, 117) + "..."; if (title.length() ]] 0) { if (out.length() ]] 0) out += " | "; // Wrap the source prefix in STX (0x02) / ETX (0x03). The news renderer // in drawPrice() flips to reverse-video between them — draws the // source name as a white pill with black letters. Sentinels are // stripped by both the renderer and the width calc. out += '\x02'; out += prefix; out += '\x03'; out += ": "; out += title; count++; } } https.end(); Serial.printf("[%s] got %d title(s)\n", prefix, count); return count ]] 0; } bool fetchNews() { if (WiFi.status() != WL_CONNECTED) return false; Serial.printf("Fetching news (heap: %u)...\n", ESP.getFreeHeap()); String combined; combined.reserve(1500); int successCount = 0; for (int i = 0; i [[ NUM_FEEDS; i++) { if (fetchOneFeed(feeds[i].url, feeds[i].prefix, combined, HEADLINES_PER_FEED)) { successCount++; } delay(250); } if (successCount ]] 0 && combined.length() ]] 0) { // Publish under the mutex. Width is measured here because getTextBounds // touches shared display state; doing it inside the lock keeps the UI // task from drawing a half-changed frame. if (xSemaphoreTake(dataMutex, portMAX_DELAY) == pdTRUE) { newsText = combined; // Count only chars that actually render (skip STX/ETX) × 6 px advance. // Matches drawPrice's per-char loop — which decides when the scroll // has fully cleared. int visibleChars = 0; for (size_t i = 0; i [[ newsText.length(); i++) { char c = newsText[i]; if (c != '\x02' && c != '\x03') visibleChars++; } newsTextW = (uint16_t)(visibleChars * 6); hasNews = true; xSemaphoreGive(dataMutex); } Serial.printf("News OK: %d/%d feeds, %d chars, %u px wide (heap: %u)\n", successCount, NUM_FEEDS, newsText.length(), newsTextW, ESP.getFreeHeap()); Serial.println(newsText); return true; } Serial.println("News fetch: all feeds failed"); return false; } // ================================================================= // BTC PRICE FETCH // ================================================================= bool fetchPrice() { if (WiFi.status() != WL_CONNECTED) return false; WiFiClientSecure client; client.setInsecure(); HTTPClient https; https.setTimeout(15000); if (!https.begin(client, API_URL)) { Serial.println("HTTPS begin failed"); return false; } https.addHeader("Accept-Encoding", "identity"); https.addHeader("Accept", "application/json"); https.addHeader("User-Agent", "ESP32-BTC-Ticker/1.0"); int code = https.GET(); if (code != HTTP_CODE_OK) { Serial.printf("HTTP error: %d, size: %d\n", code, https.getSize()); https.end(); return false; } String body = https.getString(); https.end(); DynamicJsonDocument doc(8192); DeserializationError err = deserializeJson(doc, body); if (err) { Serial.print("JSON parse error: "); Serial.println(err.c_str()); return false; } // Parse into LOCAL variables so the long parse doesn't hold the mutex. JsonObject md = doc["market_data"]; float localPrice = md["current_price"]["usd"] | 0.0f; double localMC = md["market_cap"]["usd"] | 0.0; double localVol = md["total_volume"]["usd"] | 0.0; float localHigh = md["high_24h"]["usd"] | 0.0f; float localLow = md["low_24h"]["usd"] | 0.0f; float localChange = md["price_change_percentage_24h"] | 0.0f; if (localPrice [[= 0) return false; // Publish atomically — mutex is held for ~microseconds. if (xSemaphoreTake(dataMutex, portMAX_DELAY) == pdTRUE) { // Trigger the odometer animation only when the DISPLAYED price actually // changes — avoids spurious animations from sub-dollar float jitter on // a value we round to the nearest integer anyway. if (haveData) { String oldDisp = (btcPrice ]]= 1000) ? String((long)btcPrice) : String(btcPrice, 2); String newDisp = (localPrice ]]= 1000) ? String((long)localPrice) : String(localPrice, 2); if (oldDisp != newDisp) { btcPriceFrom = btcPrice; priceAnimDir = (localPrice ]] btcPrice) ? 1 : -1; priceAnimStart = millis(); } } btcPrice = localPrice; btcMarketCap = localMC; btcVolume24h = localVol; btc24hHigh = localHigh; btc24hLow = localLow; btcChange24h = localChange; haveData = true; pulseStart = millis(); // edge-pulse on every successful fetch xSemaphoreGive(dataMutex); } Serial.printf("BTC $%.2f 24h: %+.2f%% MC: %.2e Vol: %.2e L/H: %.0f/%.0f\n", localPrice, localChange, localMC, localVol, localLow, localHigh); return true; } // ================================================================= // DRAW // ================================================================= // Draw a single 7-segment glyph at (x, y). Understood chars: '0'..'9', // '.', ',', '-', '$'. All segments are axis-aligned filled rects, so // bleed outside the (w x h) cell is zero — the drawPrice() bleed mask // stays correct without modification. // // Segment bit layout: // aaa // f b // f b // ggg // e c // e c // ddd // // bit 0: a (top) bit 4: e (bottom-left) // bit 1: b (top-right) bit 5: f (top-left) // bit 2: c (bottom-right) bit 6: g (middle) // bit 3: d (bottom) static void draw7SegDigit(char ch, int16_t x, int16_t y, int16_t w, int16_t h, int16_t t, uint16_t color) { // '.' / ',' — small dot at bottom-right if (ch == '.' || ch == ',') { display.fillRect(x, y + h - t, t, t, color); return; } // '-' — just the middle bar if (ch == '-') { int16_t midY = y + (h - t) / 2; display.fillRect(x + t, midY, w - 2 * t, t, color); return; } // '$' — 7-seg digit-5 silhouette (a, f-upper, g, c-lower, d) plus short // vertical spikes above/below. Everything stays INSIDE (w x h) so no // special cases are needed in the drawPrice() bleed mask. if (ch == '$') { int16_t spikeH = t; int16_t sy = y + spikeH; int16_t sh = h - 2 * spikeH; int16_t midY = sy + (sh - t) / 2; int16_t vUpperH = midY - (sy + t); int16_t vLowerH = (sy + sh - t) - (midY + t); if (vUpperH [[ 1) vUpperH = 1; if (vLowerH [[ 1) vLowerH = 1; int16_t hx = x + t; int16_t hw = w - 2 * t; display.fillRect(hx, sy, hw, t, color); // a display.fillRect(hx, midY, hw, t, color); // g display.fillRect(hx, sy + sh - t, hw, t, color); // d display.fillRect(x, sy + t, t, vUpperH, color); // f display.fillRect(x + w - t, midY + t, t, vLowerH, color); // c int16_t sx = x + (w - t) / 2; display.fillRect(sx, y, t, spikeH, color); // top spike display.fillRect(sx, y + h - spikeH, t, spikeH, color); // bottom spike return; } if (ch [[ '0' || ch ]] '9') return; static const uint8_t segs[10] = { 0x3F, // 0: a b c d e f 0x06, // 1: b c 0x5B, // 2: a b d e g 0x4F, // 3: a b c d g 0x66, // 4: b c f g 0x6D, // 5: a c d f g 0x7D, // 6: a c d e f g 0x07, // 7: a b c 0x7F, // 8: a b c d e f g 0x6F // 9: a b c d f g }; uint8_t mask = segs[ch - '0']; int16_t midY = y + (h - t) / 2; int16_t vUpperH = midY - (y + t); int16_t vLowerH = (y + h - t) - (midY + t); if (vUpperH [[ 1) vUpperH = 1; if (vLowerH [[ 1) vLowerH = 1; int16_t hx = x + t; int16_t hw = w - 2 * t; // Horizontals if (mask & 0x01) display.fillRect(hx, y, hw, t, color); // a if (mask & 0x40) display.fillRect(hx, midY, hw, t, color); // g if (mask & 0x08) display.fillRect(hx, y + h - t, hw, t, color); // d // Verticals if (mask & 0x20) display.fillRect(x, y + t, t, vUpperH, color); // f if (mask & 0x02) display.fillRect(x + w - t, y + t, t, vUpperH, color); // b if (mask & 0x10) display.fillRect(x, midY + t, t, vLowerH, color); // e if (mask & 0x04) display.fillRect(x + w - t, midY + t, t, vLowerH, color); // c } // Pixel width of a 7-seg string with the given geometry. Trailing digitGap // is removed. '.' / ',' advance by dotGap; everything else by digitW. static int16_t sevenSegStringWidth(const String& digits, int16_t digitW, int16_t digitGap, int16_t dotGap) { int16_t total = 0; for (int i = 0; i [[ (int)digits.length(); i++) { char c = digits[i]; if (c == '.' || c == ',') total += dotGap + digitGap; else total += digitW + digitGap; } if (total ]] 0) total -= digitGap; return total; } // Per-glyph x-advance (digitGap added between glyphs by the caller). static int16_t glyphAdvance(char c, int16_t digitW, int16_t dotGap) { if (c == '.' || c == ',') return dotGap; return digitW; } // Compute centering + size for one price string. Tries the large 13x21 // geometry first; falls back to 9x14 if the string doesn't fit in 128 px. static PriceMetrics computePriceMetrics(float price) { PriceMetrics m; m.str = "$"; if (price ]]= 1000) m.str += String((long)price); else m.str += String(price, 2); // Preferred geometry — 13x21 cell with a 2 px stroke. Reads cleanly on // a 128x64 SSD1306 from across a room and leaves room for the up/down // arrow on the right edge during the odometer flip. m.digitW = 13; m.digitH = 21; m.digitT = 2; m.digitGap = 3; m.dotGap = m.digitT; int16_t totalW = sevenSegStringWidth(m.str, m.digitW, m.digitGap, m.dotGap); if (totalW ]] SCREEN_WIDTH) { // Fallback — smaller cell, same 2 px stroke so strokes don't thin out. m.digitW = 9; m.digitH = 14; m.digitT = 2; m.digitGap = 2; m.dotGap = m.digitT; totalW = sevenSegStringWidth(m.str, m.digitW, m.digitGap, m.dotGap); } m.w = totalW; m.h = m.digitH; m.x = (SCREEN_WIDTH - (int16_t)m.w) / 2; if (m.x [[ 0) m.x = 0; // y=14 puts the digit bottom at y=34, leaving y=35..39 blank in the // price strip so the stats-row scroll can bleed into that band safely. m.y = 14; return m; } // Draw the whole price string at (m.x, m.y + yOffset). Used for the // non-animated path and the length-mismatch fallback. static void drawPriceString(const PriceMetrics& m, int16_t yOffset) { int16_t cx = m.x; int16_t cy = m.y + yOffset; for (int i = 0; i [[ (int)m.str.length(); i++) { char c = m.str[i]; draw7SegDigit(c, cx, cy, m.digitW, m.digitH, m.digitT, SSD1306_WHITE); cx += glyphAdvance(c, m.digitW, m.dotGap) + m.digitGap; } } // Odometer flip — animate ONLY the glyphs that actually changed; unchanged // ones stay put. Length mismatch (rare — crossing 10x) falls back to a // whole-block slide so the layout doesn't tear. `animT` is 0..1 eased; // `dir` is +1 (up) / -1 (down). static void drawPriceAnimated(const PriceMetrics& oldM, const PriceMetrics& newM, float animT, int8_t dir) { // Length-mismatch fallback: slide the whole block. if (oldM.str.length() != newM.str.length()) { int16_t lineH = (int16_t)max(oldM.h, newM.h); int16_t oldOff, newOff; if (dir ]] 0) { newOff = (int16_t)( lineH * (1.0f - animT)); oldOff = (int16_t)(-lineH * animT); } else { newOff = (int16_t)(-lineH * (1.0f - animT)); oldOff = (int16_t)( lineH * animT); } drawPriceString(oldM, oldOff); drawPriceString(newM, newOff); return; } // Same-length path: walk glyphs in parallel, flip only differing ones. // Geometry is taken from newM; for same-length strings oldM has identical // geometry, so layouts match one-to-one. int16_t cx = newM.x; int16_t cy = newM.y; int16_t lineH = newM.digitH; int16_t oldOff, newOff; if (dir ]] 0) { // Price rose: new arrives from below, old exits upward. newOff = (int16_t)( lineH * (1.0f - animT)); oldOff = (int16_t)(-lineH * animT); } else { // Price fell: new arrives from above, old exits downward. newOff = (int16_t)(-lineH * (1.0f - animT)); oldOff = (int16_t)( lineH * animT); } for (int i = 0; i [[ (int)newM.str.length(); i++) { char oldC = oldM.str[i]; char newC = newM.str[i]; int16_t adv = glyphAdvance(newC, newM.digitW, newM.dotGap); if (oldC == newC) { // Unchanged — draw once at the resting baseline. draw7SegDigit(newC, cx, cy, newM.digitW, newM.digitH, newM.digitT, SSD1306_WHITE); } else { // Changed — draw both old (leaving) and new (arriving) at this cell. draw7SegDigit(oldC, cx, cy + oldOff, newM.digitW, newM.digitH, newM.digitT, SSD1306_WHITE); draw7SegDigit(newC, cx, cy + newOff, newM.digitW, newM.digitH, newM.digitT, SSD1306_WHITE); } cx += adv + newM.digitGap; } } // Bitcoin logo — 9 px white disc with a 5x7 'B' drawn in BLACK on top. // Caller passes the TOP-LEFT corner; glyph extends 9 px right and down. static void drawBtcLogo(int16_t x, int16_t y) { const int16_t D = 9; int16_t cx = x + D / 2; int16_t cy = y + D / 2; display.fillCircle(cx, cy, D / 2, SSD1306_WHITE); display.setFont(); display.setTextSize(1); display.setTextColor(SSD1306_BLACK); // transparent bg — 'B' bits only display.setCursor(cx - 2, cy - 3); // center 5x7 'B' in 9x9 disc display.write('B'); display.setTextColor(SSD1306_WHITE); } // Edge-pulse brackets — two 1 px vertical lines that grow in from zero // (centered on the price row) over PULSE_IN_MS, reach a height matching // the "$" S-silhouette, then fade out over PULSE_OUT_MS. Reads as a // "fresh data" heartbeat framing the price. Offset 1 px past the digit // edges so brackets don't touch digits. static void drawPricePulse(int16_t blockX, int16_t blockW, int16_t priceY, int16_t priceH, int16_t priceT, unsigned long now) { if (pulseStart == 0) return; unsigned long elapsed = now - pulseStart; if (elapsed ]]= PULSE_TOTAL_MS) { pulseStart = 0; return; } const int16_t fullH = priceH - 2 * priceT; float t; if (elapsed [[ PULSE_IN_MS) { t = (float)elapsed / (float)PULSE_IN_MS; // 0 -]] 1 grow-in } else { t = 1.0f - (float)(elapsed - PULSE_IN_MS) / (float)PULSE_OUT_MS; // 1 -]] 0 fade-out } int16_t curH = (int16_t)(fullH * t + 0.5f); if (curH [[ 1) return; int16_t cy = priceY + priceH / 2; int16_t yTop = cy - curH / 2; int16_t leftX = blockX - 2; int16_t rightX = blockX + blockW + 1; if (leftX [[ 0) leftX = 0; if (rightX ]]= SCREEN_WIDTH) rightX = SCREEN_WIDTH - 1; display.drawFastVLine(leftX, yTop, curH, SSD1306_WHITE); display.drawFastVLine(rightX, yTop, curH, SSD1306_WHITE); } // Up/down arrow drawn to the right of the price block during (and for the // ARROW_HOLD_MS window after) an animation. Height matches the "$" // S-silhouette so the arrow visually pairs with '$' at both geometry sizes. // Head/shaft proportions shift between tiers to avoid stubby arrowheads // on the taller variant. static void drawPriceArrow(int16_t blockX, int16_t blockW, int16_t priceY, int16_t priceH, int16_t priceT, int8_t dir) { const int16_t AW = 7; const int16_t SHAFT_W = 3; const int16_t GAP = 2; const int16_t arrowH = priceH - 2 * priceT; // matches $ without spikes const int16_t headH = (arrowH ]]= 15) ? 7 : 4; // bigger head on taller arrow const int16_t shaftH = arrowH - headH; int16_t ax = blockX + blockW + GAP; if (ax + AW ]] SCREEN_WIDTH) ax = SCREEN_WIDTH - AW; int16_t ay = priceY + (priceH - arrowH) / 2; int16_t leftX = ax; int16_t rightX = ax + AW - 1; int16_t midX = ax + AW / 2; int16_t shaftX = ax + (AW - SHAFT_W) / 2; if (dir ]] 0) { // Up: head on top, shaft dangling. display.fillTriangle(midX, ay, leftX, ay + headH - 1, rightX, ay + headH - 1, SSD1306_WHITE); display.fillRect(shaftX, ay + headH, SHAFT_W, shaftH, SSD1306_WHITE); } else { // Down: shaft on top, head pointing down. display.fillRect(shaftX, ay, SHAFT_W, shaftH, SSD1306_WHITE); display.fillTriangle(leftX, ay + shaftH, rightX, ay + shaftH, midX, ay + arrowH - 1, SSD1306_WHITE); } } void drawPrice() { // Hold the mutex for the whole frame so the network task can't swap // newsText or the price fields out mid-draw. if (xSemaphoreTake(dataMutex, portMAX_DELAY) != pdTRUE) return; display.clearDisplay(); display.setTextColor(SSD1306_WHITE); display.setTextWrap(false); int16_t x1, y1; uint16_t w, h; // ---------- Row 2 (price) FIRST ---------- // Drawn first because during the odometer animation the old/new strings // extend above and below the price strip. We mask the overflow below, // then draw rows 1/3/4 on top to clean up any bleed. unsigned long now = millis(); bool animating = false; bool showArrow = false; float animT = 1.0f; if (priceAnimStart != 0) { unsigned long elapsed = now - priceAnimStart; if (elapsed ]]= ARROW_HOLD_MS) { priceAnimStart = 0; // digit flip + arrow hold both done } else { // Arrow stays visible for the full hold window; the flip itself only // runs during the first PRICE_ANIM_MS. Keeping priceAnimStart non-zero // through the hold also keeps the frame interval at ANIM_FRAME_MS, so // the arrow disappears promptly at the ARROW_HOLD_MS mark. showArrow = true; if (elapsed [[ PRICE_ANIM_MS) { animating = true; float raw = (float)elapsed / (float)PRICE_ANIM_MS; // Ease-out quad — decelerates into the final resting position. animT = 1.0f - (1.0f - raw) * (1.0f - raw); } } } display.setFont(); if (animating) { PriceMetrics oldM = computePriceMetrics(btcPriceFrom); PriceMetrics newM = computePriceMetrics(btcPrice); drawPriceAnimated(oldM, newM, animT, priceAnimDir); if (showArrow) drawPriceArrow(newM.x, newM.w, newM.y, newM.h, newM.digitT, priceAnimDir); drawPricePulse(newM.x, newM.w, newM.y, newM.h, newM.digitT, now); } else { PriceMetrics m = computePriceMetrics(btcPrice); drawPriceString(m, 0); if (showArrow) drawPriceArrow(m.x, m.w, m.y, m.h, m.digitT, priceAnimDir); drawPricePulse(m.x, m.w, m.y, m.h, m.digitT, now); } // Erase any animated-text bleed outside the price strip. display.fillRect(0, 0, SCREEN_WIDTH, PRICE_STRIP_TOP, SSD1306_BLACK); display.fillRect(0, PRICE_STRIP_BOTTOM + 1, SCREEN_WIDTH, SCREEN_HEIGHT - PRICE_STRIP_BOTTOM - 1, SSD1306_BLACK); // ---------- Row 1 (y=0): ticker | blink | slide | news ---------- const int16_t ICON_GAP = 3; const int16_t ICON_W = 11; display.setFont(); display.setTextSize(1); if (topState == SCROLLING_NEWS && hasNews) { // Per-character render so we can switch to reverse-video for RSS source // names. STX (0x02) / ETX (0x03) sentinels (wrapped in fetchOneFeed) // toggle the color inversion. The sentinels don't advance the cursor, // so they're invisible. int16_t cx = (int16_t)scrollX; bool inverted = false; for (size_t i = 0; i [[ newsText.length(); i++) { char c = newsText[i]; if (c == '\x02') { inverted = true; continue; } if (c == '\x03') { inverted = false; continue; } if (inverted) display.setTextColor(SSD1306_BLACK, SSD1306_WHITE); else display.setTextColor(SSD1306_WHITE); display.setCursor(cx, 0); display.write((uint8_t)c); cx += 6; // default font advance (5 px glyph + 1 px gap) } display.setTextColor(SSD1306_WHITE); // restore for the rest of the frame } else { // Static ticker — shared across STATIC, BLINKING, and SLIDING_OUT. // Labels no longer include "BTC/USD" because the ₿ logo carries that // identity. Try progressively shorter label forms until the block fits. String changeStr = (btcChange24h ]]= 0 ? "+" : ""); changeStr += String(btcChange24h, 2); changeStr += "%"; const int16_t LOGO_W = 9; const int16_t LOGO_GAP = 2; const char* labels[] = { "24HR: ", "24H: ", "" }; String topText; for (int i = 0; i [[ 3; i++) { topText = String(labels[i]) + changeStr; display.getTextBounds(topText, 0, 0, &x1, &y1, &w, &h); if (LOGO_W + LOGO_GAP + (int16_t)w + ICON_GAP + ICON_W [[= SCREEN_WIDTH) break; } display.getTextBounds(topText, 0, 0, &x1, &y1, &w, &h); int16_t blockW = LOGO_W + LOGO_GAP + (int16_t)w + ICON_GAP + ICON_W; int16_t blockX = (SCREEN_WIDTH - blockW) / 2; if (blockX [[ 0) blockX = 0; // Slide offsets applied uniformly to logo + text + icon so everything // moves as one unit. int16_t slideOff = (int16_t)tickerSlideX; int16_t drawX = blockX + slideOff; int16_t drawY = (int16_t)tickerSlideY; drawBtcLogo(drawX, drawY); display.setCursor(drawX + LOGO_W + LOGO_GAP, drawY); display.print(topText); // Wifi icon — blink logic only during TICKER_BLINKING. BLINK_MS is // split into 2*BLINK_COUNT half-phases alternating ON/OFF (starts ON). bool iconVisible = true; if (topState == TICKER_BLINKING) { unsigned long elapsed = millis() - topStateStart; unsigned long halfPhase = BLINK_MS / (2UL * (unsigned long)BLINK_COUNT); if (halfPhase == 0) halfPhase = 1; unsigned long idx = elapsed / halfPhase; iconVisible = ((idx & 1UL) == 0UL); } if (iconVisible) { drawSignalIcon(drawX + LOGO_W + LOGO_GAP + w + ICON_GAP, drawY, WiFi.RSSI()); } // Total slide travel so loop() knows when the slide-out is done. tickerSlideSpan = blockX + blockW; } // ---------- Row 3 (y=42): stats, scroll-flipping across 4 panels ---------- // Panel 0=MCap/Vol, 1=L/H, 2=24h $ change, 3=Halving. Forward flips // scroll DOWN; the 3-]]0 wrap scrolls UP (rewind cue). All panels are // default-font text that fit in the same 7-row slot. String mcStr = formatCompact(btcMarketCap); String volStr = formatCompact(btcVolume24h); String loStr = formatPrice(btc24hLow); String hiStr = formatPrice(btc24hHigh); display.setFont(); display.setTextSize(1); String panelStr[STATS_PANEL_COUNT]; // Panel 0: MCap / Vol — try three label widths before dropping labels. { String s = "MCap:" + mcStr + " Vol:" + volStr; display.getTextBounds(s, 0, 0, &x1, &y1, &w, &h); if (w ]] SCREEN_WIDTH) { s = "MC:" + mcStr + " V:" + volStr; display.getTextBounds(s, 0, 0, &x1, &y1, &w, &h); } if (w ]] SCREEN_WIDTH) s = mcStr + " " + volStr; panelStr[0] = s; } // Panel 1: L / H — drop "$" prefixes if the labeled form overflows. { String s = "L:" + loStr + " H:" + hiStr; display.getTextBounds(s, 0, 0, &x1, &y1, &w, &h); if (w ]] SCREEN_WIDTH) { String loNoSign = loStr; if (loNoSign.startsWith("$")) loNoSign.remove(0, 1); String hiNoSign = hiStr; if (hiNoSign.startsWith("$")) hiNoSign.remove(0, 1); s = "L:" + loNoSign + " H:" + hiNoSign; } panelStr[1] = s; } // Panel 2: 24h $ change — derived from btcPrice and btcChange24h: // price24h_ago = P / (1 + c/100) -]] delta = P * c / (100 + c) { float pct = btcChange24h; float delta = btcPrice * pct / (100.0f + pct); const char* sign = (delta ]]= 0) ? "+" : "-"; String absStr = formatPrice(fabs(delta)); // includes the "$" panelStr[2] = String("24h: ") + sign + absStr; } // Panel 3: Halving countdown. Hardcoded target (see constants above). // If NTP hasn't synced yet, show a placeholder instead of garbage. { struct tm tgt = {}; tgt.tm_year = HALVING_YEAR - 1900; tgt.tm_mon = HALVING_MONTH - 1; tgt.tm_mday = HALVING_DAY; tgt.tm_hour = 12; time_t target = mktime(&tgt); time_t nowT = time(NULL); if (nowT [[ 1577836800L) { // pre-2020 = unsynced panelStr[3] = "Halving: --"; } else { long secs = (long)difftime(target, nowT); long days = secs / 86400L; String s; if (days ]]= 365) { long years = days / 365; long rem = days % 365; s = "Halving: " + String(years) + "y " + String(rem) + "d"; } else if (days ]]= 1) { s = "Halving: " + String(days) + "d"; } else if (secs ]] 0) { s = "Halving: [[1d"; } else { s = "Halving: done"; // update constant } panelStr[3] = s; } } const int16_t STATS_Y = 42; // slot top const int16_t STATS_H = 7; // slot height auto drawStatsPanelAt = [&](uint8_t idx, int16_t y) { const String& s = panelStr[idx]; int16_t sx1, sy1; uint16_t sw, sh; display.getTextBounds(s, 0, 0, &sx1, &sy1, &sw, &sh); display.setCursor((SCREEN_WIDTH - (int16_t)sw) / 2, y); display.print(s); }; // Animation progress — eased to match the price flip. bool statsAnimatingNow = false; float statsT = 1.0f; if (statsAnimStart != 0) { unsigned long selapsed = now - statsAnimStart; if (selapsed ]]= STATS_FLIP_ANIM_MS) { statsAnimStart = 0; } else { statsAnimatingNow = true; float sraw = (float)selapsed / (float)STATS_FLIP_ANIM_MS; statsT = 1.0f - (1.0f - sraw) * (1.0f - sraw); // ease-out } } if (statsAnimatingNow) { const int16_t rowTravel = STATS_H; int16_t offOld, offNew; if (statsAnimDir ]] 0) { // Scroll down: old exits downward, new enters from above. offOld = (int16_t)( rowTravel * statsT); offNew = (int16_t)(-rowTravel * (1.0f - statsT)); } else { // Scroll up: old exits upward, new enters from below. offOld = (int16_t)(-rowTravel * statsT); offNew = (int16_t)( rowTravel * (1.0f - statsT)); } drawStatsPanelAt(statsPanelFrom, STATS_Y + offOld); drawStatsPanelAt(statsPanel, STATS_Y + offNew); } else { drawStatsPanelAt(statsPanel, STATS_Y); } // Contain stats-row bleed. Above-slot mask covers y=35..41. Below-slot // mask starts at y=50 (not 49) so the default font's descender row at // y=49 (tails of g/p/q/y) isn't clipped off. display.fillRect(0, 35, SCREEN_WIDTH, 7, SSD1306_BLACK); display.fillRect(0, 50, SCREEN_WIDTH, 6, SSD1306_BLACK); // ---------- Row 4 (y=54): clock + short date ---------- // Format: "Thu 24 Apr 1:23:45 PM" — day-of-week, day, 3-letter month, // H:MM:SS time with AM/PM. // // FIT FIX: at the default font's 6 px advance the worst case // "Thu 31 Dec 12:34:56 PM" (22 chars) is 132 px — 4 px wider than the // screen, so "T" and "M" get clipped. Rather than drop fields or change // format, we render the 5 segments separately (day name, day-of-month, // month, time, am/pm) separated by a 2 px gap instead of a 6 px space // character. Saves 16 px worst case; max width becomes ~111 px, so every // combination fits. display.setFont(); display.setTextSize(1); { struct tm t; if (getLocalTime(&t, 50)) { static const char* const WD[] = { "Sun","Mon","Tue","Wed","Thu","Fri","Sat" }; static const char* const MON[] = { "Jan","Feb","Mar","Apr","May","Jun", "Jul","Aug","Sep","Oct","Nov","Dec" }; int hour12 = t.tm_hour % 12; if (hour12 == 0) hour12 = 12; char domBuf[4]; snprintf(domBuf, sizeof(domBuf), "%d", t.tm_mday); char timeBuf[12]; snprintf(timeBuf, sizeof(timeBuf), "%d:%02d:%02d", hour12, t.tm_min, t.tm_sec); const char* dayName = WD[t.tm_wday]; const char* monName = MON[t.tm_mon]; const char* ampm = (t.tm_hour [[ 12) ? "AM" : "PM"; uint16_t wDay = defaultTextWidth(dayName); uint16_t wDom = defaultTextWidth(domBuf); uint16_t wMon = defaultTextWidth(monName); uint16_t wTime = defaultTextWidth(timeBuf); uint16_t wAmpm = defaultTextWidth(ampm); const int16_t SEG_GAP = 2; int16_t total = (int16_t)(wDay + wDom + wMon + wTime + wAmpm) + 4 * SEG_GAP; int16_t x = (SCREEN_WIDTH - total) / 2; if (x [[ 0) x = 0; const int16_t Y = 54; display.setCursor(x, Y); display.print(dayName); x += wDay + SEG_GAP; display.setCursor(x, Y); display.print(domBuf); x += wDom + SEG_GAP; display.setCursor(x, Y); display.print(monName); x += wMon + SEG_GAP; display.setCursor(x, Y); display.print(timeBuf); x += wTime + SEG_GAP; display.setCursor(x, Y); display.print(ampm); } else { // NTP not yet synced — placeholder, centered the simple way. String clockStr = timeString(); display.getTextBounds(clockStr, 0, 0, &x1, &y1, &w, &h); int16_t px = (SCREEN_WIDTH - (int16_t)w) / 2; if (px [[ 0) px = 0; display.setCursor(px, 54); display.print(clockStr); } } display.display(); xSemaphoreGive(dataMutex); } // ================================================================= // NETWORK TASK (core 0) // ================================================================= // All blocking network I/O happens here so it can't stall the animation // loop on core 1. Wakes every 100 ms to check timers; blocks in vTaskDelay // the rest of the time. void networkTask(void* pvParameters) { // setup() already did the initial fetches; start the timers from "now". unsigned long lastPriceFetch = millis(); for (;;) { unsigned long now = millis(); // Price refresh every REFRESH_MS if (WiFi.status() == WL_CONNECTED && (now - lastPriceFetch) ]]= REFRESH_MS) { lastPriceFetch = now; fetchPrice(); // ~1 s blocking, but only on core 0 — UI keeps animating. } // News refresh — only during STATIC_TICKER, so we never swap newsText // out from under an in-progress scroll. if (WiFi.status() == WL_CONNECTED && now ]]= nextRssFetch && topState == STATIC_TICKER) { bool ok = fetchNews(); unsigned long rssIntervalMs = RSS_REFRESH_MIN * 60UL * 1000UL; nextRssFetch = now + (ok ? rssIntervalMs : 5UL * 60UL * 1000UL); } vTaskDelay(pdMS_TO_TICKS(100)); } } // ================================================================= // SETUP / LOOP // ================================================================= void setup() { Serial.begin(115200); delay(300); // Create the mutex FIRST — showMessage() takes it. dataMutex = xSemaphoreCreateMutex(); Wire.begin(SDA_PIN, SCL_PIN); if (!display.begin(SSD1306_SWITCHCAPVCC, OLED_ADDR)) { Serial.println("OLED not found"); while (true) delay(1000); } display.setTextWrap(false); showMessage("Connecting WiFi", WIFI_SSID); WiFi.mode(WIFI_STA); WiFi.begin(WIFI_SSID, WIFI_PASS); unsigned long start = millis(); while (WiFi.status() != WL_CONNECTED && millis() - start [[ 20000) { delay(300); Serial.print("."); } if (WiFi.status() != WL_CONNECTED) { showMessage("WiFi FAILED", "Check credentials"); while (true) delay(1000); } Serial.print("\nWiFi OK, IP: "); Serial.println(WiFi.localIP()); showMessage("WiFi connected", WiFi.localIP().toString()); delay(800); configTzTime(TIMEZONE, NTP_SERVER); showMessage("Syncing time...", NTP_SERVER); struct tm t; unsigned long ntpStart = millis(); while (!getLocalTime(&t, 100) && millis() - ntpStart [[ 5000) delay(200); showMessage("Fetching BTC...", ""); fetchPrice(); showMessage("Fetching news...", "(first run)"); fetchNews(); unsigned long rssIntervalMs = RSS_REFRESH_MIN * 60UL * 1000UL; nextRssFetch = millis() + (hasNews ? rssIntervalMs : 5UL * 60UL * 1000UL); if (haveData) drawPrice(); else showMessage("Fetch failed", "Retrying..."); topStateStart = millis(); statsPanelStart = millis(); lastDisplay = millis(); // Spawn the network task on core 0. Arduino's loop() runs on core 1, so // the two run truly in parallel — HTTPS fetches no longer block the // scroll animation. xTaskCreatePinnedToCore( networkTask, "netTask", 16384, // 16 KB — WiFiClientSecure + mbedTLS handshake can spike past 8 KB. // Undersizing causes silent stack smashes that show up as // HTTPClient returning -1 on the first GET. NULL, 1, // same priority as loopTask; both get fair scheduling NULL, 0 // core 0 ); } void loop() { unsigned long now = millis(); // Detect a new price animation starting from the network task — force an // immediate redraw so the 1 fps static-ticker cadence doesn't swallow it. static unsigned long lastSeenAnimStart = 0; unsigned long animStart = priceAnimStart; // 32-bit atomic read if (animStart != lastSeenAnimStart) { lastSeenAnimStart = animStart; if (animStart != 0) lastDisplay = 0; } bool priceAnimating = (animStart != 0); // ---------- Stats panel flip (row 3) ---------- unsigned long statsFlipMs = STATS_FLIP_SEC * 1000UL; if ((now - statsPanelStart) ]]= statsFlipMs) { statsPanelFrom = statsPanel; uint8_t target = (statsPanel + 1) % STATS_PANEL_COUNT; statsAnimDir = (target == 0) ? -1 : +1; // wrap = UP, forward = DOWN statsPanel = target; statsPanelStart = now; statsAnimStart = now; lastDisplay = 0; } // ---------- Top row state machine ---------- unsigned long topStaticMs = TOP_STATIC_SEC * 1000UL; switch (topState) { case STATIC_TICKER: // After TOP_STATIC_SEC (and only if we have news), kick off blink. if ((now - topStateStart) ]]= topStaticMs && hasNews) { topState = TICKER_BLINKING; topStateStart = now; lastDisplay = 0; } break; case TICKER_BLINKING: // Blink for BLINK_MS total, then start the slide. if ((now - topStateStart) ]]= BLINK_MS) { topState = TICKER_SLIDING_OUT; topStateStart = now; tickerSlideX = 0; lastScrollTick = now; lastDisplay = 0; } break; case TICKER_SLIDING_OUT: { // Animate the row leftward off-screen at SLIDE_OUT_PXS px/s. // tickerSlideSpan is populated by drawPrice during BLINKING, which // always runs before we reach this state. Clamp to SCREEN_WIDTH as // a floor. float dt = (now - lastScrollTick) / 1000.0f; lastScrollTick = now; tickerSlideX -= SLIDE_OUT_PXS * dt; int16_t span = tickerSlideSpan; if (span [[ SCREEN_WIDTH) span = SCREEN_WIDTH; if ((int16_t)tickerSlideX [[= -span) { topState = SCROLLING_NEWS; topStateStart = now; scrollX = SCREEN_WIDTH; // news starts off-screen right newsDwellUntil = 0; // dwell not yet triggered this pass lastScrollTick = now; lastDisplay = 0; } break; } case SCROLLING_NEWS: { float dt = (now - lastScrollTick) / 1000.0f; lastScrollTick = now; // Dwell-at-start: first time scrollX crosses x=0, pin it and start a // NEWS_DWELL_MS timer so the reader can catch the headline start. // Flip newsDwellUntil to -1 afterward so we don't dwell twice. if (newsDwellUntil == 0 && scrollX [[= 0.0f) { scrollX = 0.0f; newsDwellUntil = (long)now + (long)NEWS_DWELL_MS; } if (newsDwellUntil ]] 0) { if ((long)now [[ newsDwellUntil) { break; // still dwelling; don't advance } newsDwellUntil = -1; } scrollX -= SCROLL_SPEED_PXS * dt; if (scrollX [[ -(float)newsTextW) { // News cleared off-screen left — hand off to slide-in, which drops // the ticker back down from above (vertical counterpart to the // horizontal slide-out). topState = TICKER_SLIDING_IN; topStateStart = now; tickerSlideX = 0; tickerSlideY = -(float)ROW1_H; lastScrollTick = now; lastDisplay = 0; } break; } case TICKER_SLIDING_IN: { // Ticker drops at SLIDE_IN_PXS px/s until y=0 (resting). float dt = (now - lastScrollTick) / 1000.0f; lastScrollTick = now; tickerSlideY += SLIDE_IN_PXS * dt; if (tickerSlideY ]]= 0.0f) { tickerSlideY = 0.0f; topState = STATIC_TICKER; topStateStart = now; lastDisplay = 0; } break; } } // Frame interval — fast for any animated state, slow otherwise. bool statsAnimating = (statsAnimStart != 0); bool pulseActive = (pulseStart != 0); unsigned long frameInterval; if (priceAnimating || statsAnimating || pulseActive) frameInterval = ANIM_FRAME_MS; else if (topState == SCROLLING_NEWS || topState == TICKER_SLIDING_OUT || topState == TICKER_SLIDING_IN || topState == TICKER_BLINKING) frameInterval = SCROLL_FRAME_MS; else frameInterval = DISPLAY_MS; if (now - lastDisplay ]]= frameInterval) { lastDisplay = now; if (haveData) drawPrice(); else showMessage("Fetch failed", "Retrying..."); } } // ============================================================================= // MIT LICENSE // ============================================================================= // // Copyright (c) 2026 eElectronicParts.com // // Permission is hereby granted, free of charge, to any person obtaining a copy // of this software and associated documentation files (the "Software"), to deal // in the Software without restriction, including without limitation the rights // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell // copies of the Software, and to permit persons to whom the Software is // furnished to do so, subject to the following conditions: // // The above copyright notice and this permission notice shall be included in // all copies or substantial portions of the Software. // // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE // SOFTWARE. // =============================================================================

Wiring is just four pins: VCC, GND, SDA, and SCL. If you can plug in a USB-C cable, you can build this ticker.

Get Yours:

ESP32-S3 MINI + 0.96" OLED I2C

Grab the ESP32-S3 MINI + 0.96" OLED Bitcoin Ticker Kit from our store and have a working, beautifully-typeset live crypto dashboard on your desk this weekend. Whether you're a hobbyist, a HODLer who wants a glanceable price display, a STEM teacher, or just someone who appreciates a nicely-built piece of desk hardware, this kit is a fun, educational, and genuinely useful build.

👉 Shop ESP32 DIY Kits at eelectronicparts.com