autoResearchLowMemorySetup()

void autoResearchLowMemorySetup ( )

inline

Definition at line 278 of file AutoResearchLowMemory.h.

                                         {
    fl::serial_begin(115200);
 
    // Arm the watchdog so a hung sketch unbricks itself on crash.
    fl::Watchdog::instance().begin(3000);
 
    // Emit a literal-only warning so the autoresearch harness can verify
    // the FL_WARN log pipeline reaches the host.
    FL_WARN_LIT("FL_WARN: low-memory bring-up OK");
 
    // The C++ inline-ODR rule guarantees a single shared instance across
    // every translation unit that calls this inline function, which is
    // exactly what we want (one Remote bound to the singleton Serial
    // transport). The included-once-per-sketch model of `.ino` builds
    // also reduces to a single TU in practice.
    fl::Remote& remote = autoresearch::low_memory::remoteState().remote;
    remote.bind("echo", [](int v) -> int {
        FL_WARN_LIT("FL_WARN: echo invoked");
        return v;
    });
 
#if defined(FL_IS_ARM_LPC_845) && defined(FASTLED_AUTORESEARCH_FAULT_TEST)
    remote.bind("trigger_oom", []() -> bool {
        // Intentional #3302 fault input: ask the 16 KB SRAM target for
        // far more RAM than exists. If the platform allocator returns null
        // instead of trapping, dereference null to exercise HardFault emit.
        volatile char* const p = new char[16UL * 1024UL * 1024UL];  // ok bare allocation
        if (p == nullptr) {
            triggerLowMemoryNullFault();
        }
        p[0] = 0x33;
        triggerLowMemoryNullFault();
        return false;
    });
    remote.bind("trigger_stackblow", []() -> bool {
        (void)recurseLowMemoryStackBlow(0);
        triggerLowMemoryNullFault();
        return false;
    });
#endif  // FL_IS_ARM_LPC_845 && FASTLED_AUTORESEARCH_FAULT_TEST
 
#if defined(FL_IS_ESP8266)  // ok platform specific - ESP8266 bring-up benches
    autoresearch::esp8266::bindEsp8266Benches(remote);
#endif
 
#if defined(FASTLED_AUTORESEARCH_IEEE754_MODE)
    remote.bind("ieee754CodecTest", [](const fl::json& args) -> fl::json {
        (void)args;
        const auto r = autoresearch::ieee754_check::run();
        fl::json response = fl::json::object();
        response.set("success", r.success);
        response.set("tests_run", static_cast<int64_t>(r.tests_run));
        response.set("tests_failed", static_cast<int64_t>(r.tests_failed));
        response.set("first_failure", r.first_failure ? r.first_failure : "");
        response.set("expected_bits", static_cast<int64_t>(r.expected_bits));
        response.set("actual_bits", static_cast<int64_t>(r.actual_bits));
        return response;
    });
#endif
 
#if defined(FL_IS_ARM_LPC) && !defined(FASTLED_AUTORESEARCH_IEEE754_MODE) && \
    !defined(FASTLED_AUTORESEARCH_FAULT_TEST)
    // pinToggleRx (FastLED #3021 Phase 1) — bit-bang square wave on tx_pin
    // and capture SCT edges on rx_pin. CSV stats out.
#if !defined(FASTLED_AUTORESEARCH_LPC_DMA_LOOPBACK)
    // Left out of the RX-DMA loopback builds (--ws2812-loopback/--pwm-dma-cl):
    // with the DMA capture linked, the 64 KB LPC845 has no room for this
    // unrelated ~1 KB diagnostic. --pin-toggle-rx builds keep it.
    remote.bind("pinToggleRx",
        [](int tx_pin, int rx_pin, int freq_hz, int duration_ms) -> fl::string {
            if (tx_pin < 0 || rx_pin < 0 || freq_hz <= 0 || duration_ms <= 0) {
                return fl::string("0,0,0,0,0,0,0");
            }
            const fl::u32 expected_edges =
                2u * static_cast<fl::u32>(freq_hz) *
                     static_cast<fl::u32>(duration_ms) / 1000u;
            // Keep both the RX vector and diagnostic copy buffer small on
            // 16 KB SRAM LPC8xx parts. Larger static buffers regressed early
            // init by leaving too little room for stack/heap (FastLED #3200),
            // while stack buffers previously overflowed during this handler
            // (FastLED #3125).
            constexpr fl::u32 kLowMemEdgeBufSize = 64u;
            fl::u32 cap = expected_edges + (expected_edges / 2u);
            if (cap < 2u) cap = 2u;
            if (cap > kLowMemEdgeBufSize) cap = kLowMemEdgeBufSize;
 
            auto rx = fl::LpcSctRxChannel::create(rx_pin);
            if (!rx) return fl::string("0,0,0,0,0,0,0");
 
            fl::RxConfig cfg;
            cfg.buffer_size = cap;
            cfg.start_low   = true;
            if (!rx->begin(cfg)) return fl::string("0,0,0,0,0,0,0");
 
            pinMode(tx_pin, OUTPUT);
            digitalWrite(tx_pin, LOW);
 
            const fl::u32 half_us = 500000u / static_cast<fl::u32>(freq_hz);
            const fl::u32 cycles  = static_cast<fl::u32>(freq_hz) *
                                     static_cast<fl::u32>(duration_ms) / 1000u;
 
            for (fl::u32 i = 0; i < cycles; ++i) {
                digitalWrite(tx_pin, HIGH);
                delayMicroseconds(half_us);
                rx->pollOnce();
                digitalWrite(tx_pin, LOW);
                delayMicroseconds(half_us);
                rx->pollOnce();
                if ((i & 0x7Fu) == 0u) {
                    fl::Watchdog::instance().feed();
                }
            }
            rx->wait(1);
 
            // Static storage keeps this off the stack; the small fixed size
            // keeps .bss below the LPC845-BRK early-init failure threshold.
            fl::EdgeTime* edges_buf = autoresearch::low_memory::pinToggleState().edges;
            const fl::size n_read = rx->getRawEdgeTimes(
                fl::span<fl::EdgeTime>(edges_buf, sizeof(edges_buf) / sizeof(edges_buf[0])));
 
            LowMemPinTogglePeriodStats stats = computeLowMemPeriodStats(edges_buf, n_read);
 
            fl::sstream s;
            const bool success = (stats.periods > 0);
            s << (success ? 1 : 0) << ',' << static_cast<fl::u32>(n_read) << ','
              << stats.periods << ',' << stats.mean_ns << ',' << stats.sigma_ns << ','
              << stats.min_ns << ',' << stats.max_ns;
            return s.str();
        });
#endif  // !FASTLED_AUTORESEARCH_LPC_DMA_LOOPBACK
 
#if defined(FASTLED_AUTORESEARCH_LPC_WS2812)
    // ws2812SctTest (FastLED #3021 Phase 2) -- WS2812 byte-match loopback.
    remote.bind("ws2812SctTest",
        [](int test_case, int tx_pin, int rx_pin, int capture_ms) -> fl::string {
            if (test_case < 0 || test_case > 4 ||
                tx_pin < 0 || rx_pin < 0 || capture_ms <= 0) {
                return fl::string("0,0,0,0,0,0,0,0");
            }
            int num_leds = 1;
            switch (test_case) {
                case 1: num_leds = 3; break;
                case 4: num_leds = 100; break;
                default: num_leds = 1; break;
            }
            autoresearch::low_memory::Ws2812State& ws_state =
                autoresearch::low_memory::ws2812State();
            CRGB* leds_buf = ws_state.leds;
            for (int i = 0; i < num_leds; ++i) {
                switch (test_case) {
                    case 0: leds_buf[i] = CRGB(0xFF, 0x00, 0x00); break;
                    case 1: {
                        if (i == 0)      leds_buf[i] = CRGB(0xFF, 0x00, 0x00);
                        else if (i == 1) leds_buf[i] = CRGB(0x00, 0xFF, 0x00);
                        else             leds_buf[i] = CRGB(0x00, 0x00, 0xFF);
                        break;
                    }
                    case 2: leds_buf[i] = CRGB(0x00, 0x00, 0x00); break;
                    case 3: leds_buf[i] = CRGB(0xFF, 0xFF, 0xFF); break;
                    case 4: {
                        const uint8_t r = (i % 3 == 0) ? 0xFFu : 0u;
                        const uint8_t g = (i % 3 == 1) ? 0xFFu : 0u;
                        const uint8_t b = (i % 3 == 2) ? 0xFFu : 0u;
                        leds_buf[i] = CRGB(r, g, b);
                        break;
                    }
                }
            }
            const int expected_bytes = num_leds * 3;
            uint8_t* expected_buf = ws_state.expected;
            for (int i = 0; i < num_leds; ++i) {
                expected_buf[i * 3 + 0] = leds_buf[i].g;
                expected_buf[i * 3 + 1] = leds_buf[i].r;
                expected_buf[i * 3 + 2] = leds_buf[i].b;
            }
            auto rx = fl::LpcSctRxChannel::create(rx_pin);
            if (!rx) return fl::string("0,0,0,0,0,0,0,0");
            fl::RxConfig cfg;
            const fl::u32 expected_edges = (fl::u32)num_leds * 24u * 2u;
            fl::u32 cap = expected_edges + (expected_edges / 2u);
            // The low-memory sketch cannot afford the old 2048-edge reserve
            // on a 16 KB SRAM LPC845. 192 edges covers the 1- and 3-LED
            // sanity cases and fails the larger diagnostic cases without
            // starving setup()/loop() stack.
            constexpr fl::u32 kLowMemWs2812EdgeCapacity = 192u;
            if (cap < 48u) cap = 48u;
            if (cap > kLowMemWs2812EdgeCapacity) cap = kLowMemWs2812EdgeCapacity;
            cfg.buffer_size = cap;
            cfg.start_low   = true;
            if (!rx->begin(cfg)) return fl::string("0,0,0,0,0,0,0,0");
 
            constexpr int kFixedTxPin = 10;  // P0_10
            if (tx_pin != kFixedTxPin) {
                return fl::string("0,0,0,0,0,0,0,0");
            }
            if (!ws_state.fastled_initialized) {
                FastLED.addLeds<WS2812, kFixedTxPin, GRB>(leds_buf, 100);
                ws_state.fastled_initialized = true;
            }
            FastLED.show();
            rx->wait(capture_ms);
 
            uint8_t* decoded_buf = ws_state.decoded;
            for (int i = 0; i < expected_bytes; ++i) decoded_buf[i] = 0;
 
            fl::ChipsetTiming4Phase timing =
                fl::make4PhaseTiming(
                    fl::to_runtime_timing<fl::WS2812ChipsetTiming>(),
                    /*reset_us=*/0u);
 
            auto dec = rx->decode(timing, fl::span<u8>(decoded_buf, expected_bytes));
            const fl::u32 decoded_bytes = dec.ok() ? dec.value() : 0u;
 
            fl::u32 matched    = 0;
            fl::u32 mismatched = 0;
            for (fl::u32 i = 0; i < decoded_bytes && i < (fl::u32)expected_bytes; ++i) {
                if (decoded_buf[i] == expected_buf[i]) ++matched;
                else                                    ++mismatched;
            }
            const fl::u32 missing = (fl::u32)expected_bytes - decoded_bytes;
            mismatched += missing;
 
            // Diagnostic-only raw-edge sample. Keep this small in .bss; the
            // decoder uses the RX channel's bounded capture vector above.
            constexpr fl::size kLowMemWs2812ProbeSize = 64u;
            fl::EdgeTime* probe = ws_state.probe;
            const fl::size edges_captured = rx->getRawEdgeTimes(
                fl::span<fl::EdgeTime>(probe, kLowMemWs2812ProbeSize));
 
            const bool success = (mismatched == 0 && decoded_bytes == (fl::u32)expected_bytes);
 
            fl::sstream s;
            s << (success ? 1 : 0) << ',' << test_case << ',' << num_leds << ','
              << expected_bytes << ',' << decoded_bytes << ','
              << matched << ',' << mismatched << ','
              << static_cast<fl::u32>(edges_captured);
            return s.str();
        });
#endif  // FASTLED_AUTORESEARCH_LPC_WS2812
 
    // FastLED #3468: channels-API SCT+DMA clockless AutoResearch
    // harness. Binds pwmDmaClFrameOnce / pwmDmaClFrameBurst /
    // pwmDmaClCaptureSelf. Header self-gates on
    // FL_IS_ARM_LPC_845 && FASTLED_LPC_PWM_DMA.
#if defined(FL_IS_ARM_LPC_845) && defined(FASTLED_LPC_PWM_DMA)
    autoresearch::pwm_dma_cl::bind(remote);
#endif
 
    // FastLED #3456: SPI+DMA async AutoResearch harness. Binds
    // dmaSpiTransferOnce / dmaSpiTransferOverlap / dmaSpiMeasureSck.
    // Header self-gates on FL_IS_ARM_LPC_845 && FASTLED_LPC_SPI_DMA.
#if defined(FL_IS_ARM_LPC_845) && defined(FASTLED_LPC_SPI_DMA)
    autoresearch::dma_spi::bind(remote);
#endif
 
    // #3453/#3611: UART DMA AutoResearch harness. Binds either the raw
    // UART DMA stream bench or the clockless loopback verifier, depending
    // on the build flags injected by `bash autoresearch`.
#if defined(FL_IS_ARM_LPC_845) && FASTLED_AUTORESEARCH_LPC_UART_DMA
    autoresearch::uart_dma::bind(remote);
#endif
 
#endif  // FL_IS_ARM_LPC && !FASTLED_AUTORESEARCH_IEEE754_MODE
}

References args, fl::Watchdog::begin(), fl::RxConfig::buffer_size, FastLED, fl::Watchdog::feed(), FL_WARN_LIT, GRB, fl::Watchdog::instance(), fl::make4PhaseTiming(), fl::json::object(), autoresearch::low_memory::RemoteState::remote, remote, autoresearch::low_memory::remoteState(), autoresearch::ieee754_check::run(), fl::serial_begin(), fl::RxConfig::start_low, fl::sstream::str(), and fl::to_runtime_timing().

Referenced by setup().

Here is the call graph for this function:

Here is the caller graph for this function: