docs

docs_analysis/crc_shift_sim.py

@@ -0,0 +1,103 @@
+# -*- coding: utf-8 -*-
+# Симуляция CRC-схем IR-protocol на "сдвиговых" ошибках.
+# crc8 воспроизводит IR_config.cpp: MSB-first, init=0xFF, без final-xor.
+import random
+random.seed(1)
+POLY1 = 0x31
+POLY2 = 0x8C  # битовое зеркало 0x31
+
+def crc8(data, poly):
+    crc = 0xFF
+    for b in data:
+        crc ^= b
+        for _ in range(8):
+            crc = ((crc << 1) ^ poly) & 0xFF if (crc & 0x80) else (crc << 1) & 0xFF
+    return crc
+
+def fold4(x):            # свернуть 8-бит CRC в 4 бита (xor старший^младший ниббл)
+    return (x ^ (x >> 4)) & 0x0F
+
+# --- схемы контроля: считают "чек" от данных и сверяют ---
+def single_chk(d):  return (crc8(d, POLY1),)                                   # 8 бит, 1 полином
+def double_chk(d):  c1 = crc8(d, POLY1); return (c1, crc8(d + [c1], POLY2))    # текущая: 16 бит
+def nib_fold_chk(d):return ((fold4(crc8(d, POLY1)) << 4) | fold4(crc8(d, POLY2)),)  # предложенная: 4+4 бит
+def nib_trunc_chk(d):return (((crc8(d, POLY1) & 0x0F) << 4) | (crc8(d, POLY2) & 0x0F),)
+
+def bits_of(data):
+    return [(b >> (7 - j)) & 1 for b in data for j in range(8)]
+def bytes_of(bits):
+    return [sum(bits[i + j] << (7 - j) for j in range(8)) for i in range(0, len(bits), 8)]
+
+# --- модели "сдвига" в середине пакета (над битами данных, длина сохраняется) ---
+def slip_delete(data, p):           # выкинуть бит p, сдвинуть хвост влево, добить 0 в конец
+    b = bits_of(data); b = b[:p] + b[p+1:] + [0]; return bytes_of(b)
+def rotate_all_right(data, _):      # циклический сдвиг ВСЕХ бит вправо на 1
+    b = bits_of(data); b = [b[-1]] + b[:-1]; return bytes_of(b)
+def rotate_mid_window(data, p):     # циклический сдвиг окна [p, p+16) на 1 (локальный сдвиг в середине)
+    b = bits_of(data); q = min(p+16, len(b))
+    w = b[p:q]; w = [w[-1]] + w[:-1]; b = b[:p] + w + b[q:]; return bytes_of(b)
+
+MODELS = [("slip-delete (бит-слип)", slip_delete),
+          ("rotate-all (сдвиг всего на 1)", rotate_all_right),
+          ("rotate-mid-window (сдвиг окна в середине)", rotate_mid_window)]
+SCHEMES = [("single (1×CRC8, 8бит)", single_chk),
+           ("double (2×CRC8, 16бит) — текущая", double_chk),
+           ("nibble-fold (4+4бит)", nib_fold_chk),
+           ("nibble-trunc (4+4бит)", nib_trunc_chk)]
+
+def run(datalen, trials):
+    print(f"\n===== данные {datalen} байт, {trials} попыток на модель =====")
+    for mname, model in MODELS:
+        # для каждой схемы: сколько ошибок НЕ обнаружено (чек совпал, а данные изменились)
+        undetected = {s[0]: 0 for s in SCHEMES}
+        changed = 0
+        first_single_miss = None
+        for _ in range(trials):
+            d = [random.randint(0, 255) for _ in range(datalen)]
+            p = random.randint(datalen*8//4, datalen*8*3//4)  # позиция в середине
+            c = model(d, p)
+            if c == d:
+                continue
+            changed += 1
+            for sname, chk in SCHEMES:
+                if chk(c) == chk(d):
+                    undetected[sname] += 1
+                    if sname.startswith("single") and first_single_miss is None:
+                        first_single_miss = (d[:], c[:], p)
+        print(f"  модель: {mname}  (изменённых кадров: {changed})")
+        for sname, _ in SCHEMES:
+            u = undetected[sname]
+            rate = u / changed if changed else 0
+            print(f"     {sname:38s}: пропущено {u:6d}  ({rate*100:.4f}%)")
+        if first_single_miss:
+            d, c, p = first_single_miss
+            print(f"     ПРИМЕР пропуска single (poly1): data={bytes(d).hex()} -> shift@{p} -> {bytes(c).hex()}")
+            print(f"        single: crc1(orig)={crc8(d,POLY1):02x} == crc1(shift)={crc8(c,POLY1):02x}  -> ПРОШЁЛ")
+            print(f"        double: crc2(orig)={double_chk(d)[1]:02x} vs crc2(shift)={double_chk(c)[1]:02x}  -> {'ПРОШЁЛ (не поймал!)' if double_chk(d)==double_chk(c) else 'ПОЙМАЛ'}")
+
+for L in (3, 5, 8):
+    run(L, 200000)
+
+# Гарантированное покрытие burst-ошибок (подряд идущие искажённые биты) — ключ для IR (бит-слипы/всплески)
+print("\n===== Гарантия обнаружения BURST-ошибок (100% всех burst данной длины?) =====")
+def burst_guaranteed(chk, datalen, blen):
+    # перебор всех burst длины blen по всем позициям на нескольких случайных базах; ищем ХОТЬ ОДИН пропуск
+    for _ in range(300):
+        d = [random.randint(0,255) for _ in range(datalen)]
+        base = bits_of(d)
+        for start in range(len(base)-blen+1):
+            b2 = base[:]
+            for k in range(blen):
+                b2[start+k] ^= 1
+            c = bytes_of(b2)
+            if c != d and chk(c) == chk(d):
+                return False  # найден необнаруженный burst
+    return True
+for sname, chk in SCHEMES:
+    maxb = 0
+    for blen in range(1, 25):
+        if burst_guaranteed(chk, 5, blen):
+            maxb = blen
+        else:
+            break
+    print(f"  {sname:38s}: 100%% ловит burst до {maxb} бит подряд")