testRxChannelSanity()

bool testRxChannelSanity	(	fl::shared_ptr< fl::RxChannel >	rx,
		int	pin_tx )

Test RX channel functionality with low-frequency pattern.

Validates the given RX channel can capture edge transitions by generating a simple test pattern (HIGH/LOW toggles) and verifying the captured timing data matches expectations.

Parameters

rx	Shared pointer to the RX channel to test
pin_tx	TX pin number to toggle

Returns

true if RX channel captures expected edges, false otherwise

Examples

RX.ino.

Definition at line 160 of file test.cpp.

                                                                   {
    FL_WARN("Testing RX channel with low-frequency pattern...");
 
    if (!rx) {
        FL_ERROR("Failed to test RX channel - null channel provided");
        return false;
    }
 
    int pin_rx = rx->getPin();
 
    // Configure RX channel for low-frequency test
    fl::RxChannelConfig config(pin_rx);
    config.signal_range_min_ns = 100;       // 100ns glitch filter
    config.signal_range_max_ns = 30000000;  // 30ms idle timeout (ESP-IDF RMT limit: 32767000ns)
    config.start_low = true;                 // Pin starts LOW
 
    // Initialize TX pin and set to LOW
    pinMode(pin_tx, OUTPUT);
    pinMode(pin_rx, INPUT);
    digitalWrite(pin_tx, LOW);
    delay(10);  // Allow pin to settle
 
    if (!rx->begin(config)) {
        FL_ERROR("Failed to initialize RX channel");
        return false;
    }
 
    // Generate simple test pattern: 4 edges (LOW->HIGH->LOW->HIGH)
    // Pattern: HIGH 10ms, LOW 10ms, HIGH 10ms
    FL_WARN("Generating test pattern on GPIO " << pin_tx << "...");
    digitalWrite(pin_tx, HIGH);
    delay(10);
    digitalWrite(pin_tx, LOW);
    delay(10);
    digitalWrite(pin_tx, HIGH);
    delay(10);
    digitalWrite(pin_tx, LOW);
 
    // Wait for capture with timeout
    FL_WARN("Waiting for RX capture...");
    auto wait_result = rx->wait(100);
 
    if (wait_result == fl::RxWaitResult::TIMEOUT) {
        FL_ERROR("RX channel test FAILED - timeout waiting for data");
        FL_ERROR("  No edges captured within 100ms");
        FL_ERROR("  This suggests the RX channel cannot read from GPIO " << pin_rx);
        return false;
    }
 
    // Get captured edges
    fl::array<fl::EdgeTime, 10> edge_buffer;
    size_t edge_count = rx->getRawEdgeTimes(edge_buffer);
 
    if (edge_count < 3) {
        FL_ERROR("RX channel test FAILED - insufficient edges captured");
        FL_ERROR("  Expected at least 3 edges, got " << edge_count);
        FL_ERROR("  Pin loopback may not be working correctly");
        return false;
    }
 
    // Validate timing is reasonable (each edge should be ~10ms apart)
    bool timing_ok = true;
    for (size_t i = 0; i < edge_count && i < 3; i++) {
        uint32_t duration_ms = edge_buffer[i].ns / 1000000;
        if (duration_ms < 5 || duration_ms > 20) {
            FL_WARN("WARNING: Edge " << i << " timing unusual: " << duration_ms << "ms (expected ~10ms)");
            timing_ok = false;
        }
    }
 
    if (timing_ok) {
        FL_WARN("✓ RX channel test PASSED");
        FL_WARN("  Captured " << edge_count << " edges");
        FL_WARN("  Timing appears correct (~10ms per edge)");
        return true;
    } else {
        FL_WARN("✓ RX channel test PASSED (with timing warnings)");
        FL_WARN("  Captured " << edge_count << " edges");
        FL_WARN("  Timing may be affected by system load");
        return true;  // Still pass - we got edges
    }
}

References FL_ERROR, FL_WARN, fl::RxChannelConfig::signal_range_max_ns, fl::RxChannelConfig::signal_range_min_ns, fl::RxChannelConfig::start_low, and fl::TIMEOUT.

Referenced by setup().

Here is the caller graph for this function: