[FL-1800] IRDA: enc/decoder refactoring, Add NEC42 (#705)

* WIP: IRDA: multilen protocol refactoring, NEC42 * IRDA: Refactoring encoder/decoder Co-authored-by: あく <alleteam@gmail.com>
2021-09-15 20:22:58 +03:00
parent 4768177cf5
commit 4f233ff0a3
21 changed files with 551 additions and 437 deletions
--- a/lib/irda/encoder_decoder/common/irda_common_decoder.c
+++ b/lib/irda/encoder_decoder/common/irda_common_decoder.c
@@ -1,4 +1,5 @@
 #include "furi/check.h"
+#include "furi/common_defines.h"
 #include "irda.h"
 #include "irda_common_i.h"
 #include <stdbool.h>
@@ -39,11 +40,12 @@ static bool irda_check_preamble(IrdaCommonDecoder* decoder) {
    bool result = false;
    bool start_level = (decoder->level + decoder->timings_cnt + 1) % 2;

+    if (decoder->timings_cnt == 0)
+        return false;
+
    // align to start at Mark timing
    if (!start_level) {
-        if (decoder->timings_cnt > 0) {
-            decoder->timings_cnt = consume_samples(decoder->timings, decoder->timings_cnt, 1);
-        }
+        decoder->timings_cnt = consume_samples(decoder->timings, decoder->timings_cnt, 1);
    }

    if (decoder->protocol->timings.preamble_mark == 0) {
@@ -66,45 +68,75 @@ static bool irda_check_preamble(IrdaCommonDecoder* decoder) {
    return result;
 }

-/* Pulse Distance Modulation */
-IrdaStatus irda_common_decode_pdm(IrdaCommonDecoder* decoder) {
+
+/**
+ * decoder->protocol->databit_len[0] contains biggest amount of bits, for this protocol.
+ * decoder->protocol->databit_len[1...] contains lesser values, but which can be decoded
+ * for some protocol modifications.
+ */
+static IrdaStatus irda_common_decode_bits(IrdaCommonDecoder* decoder) {
    furi_assert(decoder);

-    uint32_t* timings = decoder->timings;
-    IrdaStatus status = IrdaStatusError;
+    IrdaStatus status = IrdaStatusOk;
+    const IrdaTimings* timings = &decoder->protocol->timings;
+
+    while (decoder->timings_cnt && (status == IrdaStatusOk)) {
+        bool level = (decoder->level + decoder->timings_cnt + 1) % 2;
+        uint32_t timing = decoder->timings[0];
+
+        /* check if short protocol version can be decoded */
+        if (timings->min_split_time && !level && (timing > timings->min_split_time)) {
+            for (int i = 1; decoder->protocol->databit_len[i] && (i < COUNT_OF(decoder->protocol->databit_len)); ++i) {
+                if (decoder->protocol->databit_len[i] == decoder->databit_cnt) {
+                    return IrdaStatusReady;
+                }
+            }
+        }
+
+        status = decoder->protocol->decode(decoder, level, timing);
+        furi_assert(status == IrdaStatusError || status == IrdaStatusOk);
+        if (status == IrdaStatusError) {
+            break;
+        }
+        decoder->timings_cnt = consume_samples(decoder->timings, decoder->timings_cnt, 1);
+
+        /* check if largest protocol version can be decoded */
+        if (level && (decoder->protocol->databit_len[0] == decoder->databit_cnt)) {
+            status = IrdaStatusReady;
+            break;
+        }
+    }
+
+    return status;
+}
+
+/* Pulse Distance-Width Modulation */
+IrdaStatus irda_common_decode_pdwm(IrdaCommonDecoder* decoder, bool level, uint32_t timing) {
+    furi_assert(decoder);
+
+    IrdaStatus status = IrdaStatusOk;
    uint32_t bit_tolerance = decoder->protocol->timings.bit_tolerance;
    uint16_t bit1_mark = decoder->protocol->timings.bit1_mark;
    uint16_t bit1_space = decoder->protocol->timings.bit1_space;
    uint16_t bit0_mark = decoder->protocol->timings.bit0_mark;
    uint16_t bit0_space = decoder->protocol->timings.bit0_space;

-    while (1) {
-        // Stop bit
-        if ((decoder->databit_cnt == decoder->protocol->databit_len) && (decoder->timings_cnt == 1)) {
-            if (MATCH_TIMING(timings[0], bit1_mark, bit_tolerance)) {
-                decoder->timings_cnt = 0;
-                status = IrdaStatusReady;
-            } else {
-                status = IrdaStatusError;
-            }
-            break;
-        }
+    bool analyze_timing = level ^ (bit1_mark == bit0_mark);
+    uint16_t bit1 = level ? bit1_mark : bit1_space;
+    uint16_t bit0 = level ? bit0_mark : bit0_space;
+    uint16_t no_info_timing = (bit1_mark == bit0_mark) ? bit1_mark : bit1_space;

-        if (decoder->timings_cnt >= 2) {
-            if (MATCH_TIMING(timings[0], bit1_mark, bit_tolerance)
-                && MATCH_TIMING(timings[1], bit1_space, bit_tolerance)) {
-                accumulate_lsb(decoder, 1);
-            } else if (MATCH_TIMING(timings[0], bit0_mark, bit_tolerance)
-                && MATCH_TIMING(timings[1], bit0_space, bit_tolerance)) {
-                accumulate_lsb(decoder, 0);
-            } else {
-                status = IrdaStatusError;
-                break;
-            }
-            decoder->timings_cnt = consume_samples(decoder->timings, decoder->timings_cnt, 2);
+    if (analyze_timing) {
+        if (MATCH_TIMING(timing, bit1, bit_tolerance)) {
+            accumulate_lsb(decoder, 1);
+        } else if (MATCH_TIMING(timing, bit0, bit_tolerance)) {
+            accumulate_lsb(decoder, 0);
        } else {
-            status = IrdaStatusOk;
-            break;
+            status = IrdaStatusError;
+        }
+    } else {
+        if (!MATCH_TIMING(timing, no_info_timing, bit_tolerance)) {
+            status = IrdaStatusError;
        }
    }

@@ -112,111 +144,59 @@ IrdaStatus irda_common_decode_pdm(IrdaCommonDecoder* decoder) {
 }

 /* level switch detection goes in middle of time-quant */
-IrdaStatus irda_common_decode_manchester(IrdaCommonDecoder* decoder) {
+IrdaStatus irda_common_decode_manchester(IrdaCommonDecoder* decoder, bool level, uint32_t timing) {
    furi_assert(decoder);
-    IrdaStatus status = IrdaStatusOk;
    uint16_t bit = decoder->protocol->timings.bit1_mark;
    uint16_t tolerance = decoder->protocol->timings.bit_tolerance;

-    while (decoder->timings_cnt) {
-        uint32_t timing = decoder->timings[0];
-        bool* switch_detect = &decoder->switch_detect;
-        furi_assert((*switch_detect == true) || (*switch_detect == false));
+    bool* switch_detect = &decoder->switch_detect;
+    furi_assert((*switch_detect == true) || (*switch_detect == false));

-        bool single_timing = MATCH_TIMING(timing, bit, tolerance);
-        bool double_timing = MATCH_TIMING(timing, 2*bit, tolerance);
+    bool single_timing = MATCH_TIMING(timing, bit, tolerance);
+    bool double_timing = MATCH_TIMING(timing, 2*bit, tolerance);

-        if(!single_timing && !double_timing) {
-            status = IrdaStatusError;
-            break;
-        }
-
-        if ((decoder->protocol->manchester_start_from_space) && (decoder->databit_cnt == 0)) {
-            *switch_detect = 1; /* fake as we were previously in the middle of time-quant */
-            decoder->data[0] = 0;   /* first captured timing should be Mark */
-            ++decoder->databit_cnt;
-        }
-
-        if (*switch_detect == 0) {
-            if (double_timing) {
-                status = IrdaStatusError;
-                break;
-            }
-            /* only single timing - level switch required in the middle of time-quant */
-            *switch_detect = 1;
-        } else {
-            /* double timing means we in the middle of time-quant again */
-            if (single_timing)
-                *switch_detect = 0;
-        }
-
-        decoder->timings_cnt = consume_samples(decoder->timings, decoder->timings_cnt, 1);
-        status = IrdaStatusOk;
-        bool level = (decoder->level + decoder->timings_cnt) % 2;
-
-        if (decoder->databit_cnt < decoder->protocol->databit_len) {
-            if (*switch_detect) {
-                accumulate_lsb(decoder, level);
-            }
-            if (decoder->databit_cnt == decoder->protocol->databit_len) {
-                if (level) {
-                    status = IrdaStatusReady;
-                    break;
-                }
-            }
-        } else {
-            furi_assert(level);
-            /* cover case: sequence should be stopped after last bit was received */
-            if (single_timing) {
-                status = IrdaStatusReady;
-                break;
-            } else {
-                status = IrdaStatusError;
-            }
-        }
+    if(!single_timing && !double_timing) {
+        return IrdaStatusError;
    }

-    return status;
+    if (decoder->protocol->manchester_start_from_space && (decoder->databit_cnt == 0)) {
+        *switch_detect = 1; /* fake as we were previously in the middle of time-quant */
+        accumulate_lsb(decoder, 0);
+    }
+
+    if (*switch_detect == 0) {
+        if (double_timing) {
+            return IrdaStatusError;
+        }
+        /* only single timing - level switch required in the middle of time-quant */
+        *switch_detect = 1;
+    } else {
+        /* double timing means we're in the middle of time-quant again */
+        if (single_timing)
+            *switch_detect = 0;
+    }
+
+    if (*switch_detect) {
+        accumulate_lsb(decoder, level);
+    }
+
+    return IrdaStatusOk;
 }

-/* Pulse Width Modulation */
-IrdaStatus irda_common_decode_pwm(IrdaCommonDecoder* decoder) {
-    furi_assert(decoder);
+IrdaMessage* irda_common_decoder_check_ready(IrdaCommonDecoder* decoder) {
+    IrdaMessage* message = NULL;

-    uint32_t* timings = decoder->timings;
-    IrdaStatus status = IrdaStatusOk;
-    uint32_t bit_tolerance = decoder->protocol->timings.bit_tolerance;
-    uint16_t bit1_mark = decoder->protocol->timings.bit1_mark;
-    uint16_t bit1_space = decoder->protocol->timings.bit1_space;
-    uint16_t bit0_mark = decoder->protocol->timings.bit0_mark;
-
-    while (decoder->timings_cnt) {
-        bool level = (decoder->level + decoder->timings_cnt + 1) % 2;
-
-        if (level) {
-            if (MATCH_TIMING(timings[0], bit1_mark, bit_tolerance)) {
-                accumulate_lsb(decoder, 1);
-            } else if (MATCH_TIMING(timings[0], bit0_mark, bit_tolerance)) {
-                accumulate_lsb(decoder, 0);
-            } else {
-                status = IrdaStatusError;
-                break;
-            }
+    if (decoder->protocol->interpret(decoder)) {
+        decoder->databit_cnt = 0;
+        message = &decoder->message;
+        if (decoder->protocol->decode_repeat) {
+            decoder->state = IrdaCommonDecoderStateProcessRepeat;
        } else {
-            if (!MATCH_TIMING(timings[0], bit1_space, bit_tolerance)) {
-                status = IrdaStatusError;
-                break;
-            }
-        }
-        decoder->timings_cnt = consume_samples(decoder->timings, decoder->timings_cnt, 1);
-
-        if (decoder->databit_cnt == decoder->protocol->databit_len) {
-            status = IrdaStatusReady;
-            break;
+            decoder->state = IrdaCommonDecoderStateWaitPreamble;
        }
    }

-    return status;
+    return message;
 }

 IrdaMessage* irda_common_decode(IrdaCommonDecoder* decoder, bool level, uint32_t duration) {
@@ -245,12 +225,13 @@ IrdaMessage* irda_common_decode(IrdaCommonDecoder* decoder, bool level, uint32_t
            }
            break;
        case IrdaCommonDecoderStateDecode:
-            status = decoder->protocol->decode(decoder);
+            status = irda_common_decode_bits(decoder);
            if (status == IrdaStatusReady) {
-                if (decoder->protocol->interpret(decoder)) {
-                    message = &decoder->message;
-                    decoder->state = IrdaCommonDecoderStateProcessRepeat;
-                } else {
+                message = irda_common_decoder_check_ready(decoder);
+                if (message) {
+                    continue;
+                } else if (decoder->protocol->databit_len[0] == decoder->databit_cnt) {
+                    /* error: can't decode largest protocol - begin decoding from start */
                    decoder->state = IrdaCommonDecoderStateWaitPreamble;
                }
            } else if (status == IrdaStatusError) {
@@ -259,10 +240,6 @@ IrdaMessage* irda_common_decode(IrdaCommonDecoder* decoder, bool level, uint32_t
            }
            break;
        case IrdaCommonDecoderStateProcessRepeat:
-            if (!decoder->protocol->decode_repeat) {
-                decoder->state = IrdaCommonDecoderStateWaitPreamble;
-                continue;
-            }
            status = decoder->protocol->decode_repeat(decoder);
            if (status == IrdaStatusError) {
                irda_common_decoder_reset_state(decoder);
@@ -282,9 +259,14 @@ IrdaMessage* irda_common_decode(IrdaCommonDecoder* decoder, bool level, uint32_t
 void* irda_common_decoder_alloc(const IrdaCommonProtocolSpec* protocol) {
    furi_assert(protocol);

+    /* protocol->databit_len[0] has to contain biggest value of bits that can be decoded */
+    for (int i = 1; i < COUNT_OF(protocol->databit_len); ++i) {
+        furi_assert(protocol->databit_len[i] <= protocol->databit_len[0]);
+    }
+
    uint32_t alloc_size = sizeof(IrdaCommonDecoder)
-                          + protocol->databit_len / 8
-                          + !!(protocol->databit_len % 8);
+                          + protocol->databit_len[0] / 8
+                          + !!(protocol->databit_len[0] % 8);
    IrdaCommonDecoder* decoder = furi_alloc(alloc_size);
    memset(decoder, 0, alloc_size);
    decoder->protocol = protocol;