validateEdgeTiming()

bool validateEdgeTiming	(	fl::span< const fl::EdgeTime >	edges,
		size_t	edge_count,
		fl::span< const PinToggle >	expected_pattern,
		uint32_t	tolerance_percent )

Validate captured edge timings against expected pattern.

Prints edge timing data, validates that edges alternate HIGH/LOW correctly, and checks that timing values match the expected pattern within tolerance.

Parameters

edges	Captured edge timing data
edge_count	Number of edges captured
expected_pattern	Expected pin toggle pattern to validate against
tolerance_percent	Tolerance for timing validation (e.g., 15 for ±15%)

Returns

true if validation passes (edges alternate correctly and timing matches), false otherwise

Definition at line 60 of file test.cpp.

                                                    {
 
    FL_WARN("[TEST] Captured " << edge_count << " edges");
 
    if (edge_count == 0) {
        FL_ERROR("No edges captured!");
        return false;
    }
 
    // Print edge timings
    FL_WARN("[TEST] Edge timings:");
    for (size_t i = 0; i < edge_count; i++) {
        FL_WARN("  [" << i << "] " << (edges[i].high ? "HIGH" : "LOW ")
                << " " << edges[i].ns << "ns (" << (edges[i].ns / 1000) << "us)");
    }
 
    // Validate edge alternation
    bool alternation_valid = true;
    for (size_t i = 1; i < edge_count; i++) {
        if (edges[i].high == edges[i-1].high) {
            FL_ERROR("Sequential " << (edges[i].high ? "HIGH" : "LOW")
                    << " values at indices " << (i-1) << " and " << i
                    << " - edges should alternate HIGH/LOW");
            alternation_valid = false;
        }
    }
 
    // Validate timing accuracy against expected pattern
    bool timing_valid = true;
    FL_WARN("[TEST] Validating timing accuracy (±" << tolerance_percent << "% tolerance):");
 
    // Expected edge count is expected_pattern.size() - 1 because the last edge
    // ends with timeout (no subsequent transition to measure duration)
    size_t expected_edge_count = expected_pattern.size() - 1;
    if (edge_count != expected_edge_count) {
        FL_WARN("WARNING: Edge count mismatch - expected " << expected_edge_count
                << ", got " << edge_count);
        timing_valid = false;
    }
 
    size_t compare_count = edge_count < expected_edge_count ? edge_count : expected_edge_count;
    for (size_t i = 0; i < compare_count; i++) {
        uint32_t expected_us = expected_pattern[i].delay_us;
        uint32_t actual_us = edges[i].ns / 1000;
        bool expected_high = expected_pattern[i].is_high;
        bool actual_high = edges[i].high;
 
        // Calculate tolerance range
        uint32_t tolerance_us = (expected_us * tolerance_percent) / 100;
        uint32_t min_us = expected_us - tolerance_us;
        uint32_t max_us = expected_us + tolerance_us;
 
        // Validate timing and level
        bool timing_ok = (actual_us >= min_us) && (actual_us <= max_us);
        bool level_ok = (expected_high == actual_high);
 
        if (timing_ok && level_ok) {
            FL_WARN("  [" << i << "] ✓ " << (actual_high ? "HIGH" : "LOW ")
                    << " " << actual_us << "us (expected " << expected_us
                    << "us ±" << tolerance_us << "us)");
        } else {
            if (!level_ok) {
                FL_WARN("  [" << i << "] ✗ Level mismatch: expected "
                        << (expected_high ? "HIGH" : "LOW") << ", got "
                        << (actual_high ? "HIGH" : "LOW"));
                timing_valid = false;
            }
            if (!timing_ok) {
                FL_WARN("  [" << i << "] ✗ Timing out of range: " << actual_us
                        << "us (expected " << expected_us << "us ±" << tolerance_us
                        << "us, range: " << min_us << "-" << max_us << "us)");
                timing_valid = false;
            }
        }
    }
 
    // Validate results
    if (!alternation_valid) {
        FL_ERROR("Edge timings are not properly alternating");
        FL_ERROR("Expected pattern: HIGH, LOW, HIGH, LOW, ...");
        FL_ERROR("Actual pattern contains sequential identical states");
        return false;
    } else if (!timing_valid) {
        FL_ERROR("Captured edge timings do not match expected pattern");
        FL_ERROR("Check timing accuracy and tolerance settings");
        return false;
    } else if (edge_count >= 5) {
        FL_WARN("[TEST] ✓ PASS: Captured " << edge_count << " edges with proper alternation");
        FL_WARN("[TEST] ✓ PASS: All timing values match expected pattern within tolerance");
        FL_WARN("[TEST] ✓ RX channel working correctly!");
        return true;
    } else {
        FL_WARN("WARNING: Only captured " << edge_count << " edges (expected >=5)");
        return false;
    }
}

References FL_ERROR, FL_WARN, and fl::span< T, Extent >::size().

Referenced by loop().

Here is the call graph for this function:

Here is the caller graph for this function: