Update

lib/subghz/protocols/protocol_items.c

@@ -75,6 +75,11 @@ const SubGhzProtocol* const subghz_protocol_registry_items[] = {
     &subghz_protocol_star_line,
     &subghz_protocol_scher_khan,
     &subghz_protocol_sheriff_cfm,
+    &subghz_protocol_renault_hitag,
+    &subghz_protocol_renault_siemens,
+    &subghz_protocol_renault_valeo,
+    &subghz_protocol_renault_valeo_fsk,
+    &subghz_protocol_renault_marelli,
 };
 
 const SubGhzProtocolRegistry subghz_protocol_registry = {

lib/subghz/protocols/protocol_items.h

@@ -77,3 +77,8 @@
 #include "star_line.h"
 #include "scher_khan.h"
 #include "sheriff_cfm.h"
+#include "renault_hitag.h"
+#include "renault_siemens.h"
+#include "renault_valeo.h"
+#include "renault_valeo_fsk.h"
+#include "renault_marelli.h"

lib/subghz/protocols/renault_classifier.c

@@ -0,0 +1,14 @@
+#include "renault_classifier.h"
+#include <stdint.h>
+
+//   Hitag:   40–63  bits
+//   Siemens: 64–80  bits
+//   Valeo:   81–96  bits
+//   Marelli: 97–110 bits
+RenaultProtocolType renault_classify(uint8_t bits) {
+    if(bits >= 40 && bits <= 63) return RenaultProtoHitag;
+    if(bits >= 64 && bits <= 80) return RenaultProtoSiemens;
+    if(bits >= 81 && bits <= 96) return RenaultProtoValeo;
+    if(bits >= 97 && bits <= 110) return RenaultProtoMarelli;
+    return RenaultProtoUnknown;
+}

lib/subghz/protocols/renault_classifier.h

@@ -0,0 +1,13 @@
+#pragma once
+
+#include <stdint.h>
+
+typedef enum {
+    RenaultProtoUnknown,
+    RenaultProtoHitag,
+    RenaultProtoSiemens,
+    RenaultProtoValeo,
+    RenaultProtoMarelli,
+} RenaultProtocolType;
+
+RenaultProtocolType renault_classify(uint8_t bits);

lib/subghz/protocols/renault_hitag.c

@@ -0,0 +1,264 @@
+#include "renault_hitag.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/generic.h"
+
+#define TAG "RenaultHitag"
+
+// Hitag2 / PCF7936 keyfob — OOK PWM
+// te_short ≈ 200 µs (bit 0 mark)
+// te_long  ≈ 400 µs (bit 1 mark)
+// Space between bits ≈ te_short
+// Gap between frames > 3 × te_long
+
+#define HITAG_TE_SHORT  200
+#define HITAG_TE_LONG   400
+#define HITAG_TE_DELTA  120
+#define HITAG_MIN_BITS  40
+#define HITAG_MAX_BITS  63
+#define HITAG_GAP_MIN   (HITAG_TE_LONG * 3)
+
+typedef enum {
+    HitagStepReset = 0,
+    HitagStepWaitMark,
+    HitagStepWaitSpace,
+} HitagStep;
+
+// ─── Struct ──────────────────────────────────────────────────────────────────
+
+typedef struct {
+    SubGhzProtocolDecoderBase base;
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+    uint64_t data;
+    uint8_t bit_count;
+    uint8_t parser_step;
+} RenaultHitagDecoder;
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+static inline uint32_t hitag_abs_diff(uint32_t a, uint32_t b) {
+    return (a > b) ? (a - b) : (b - a);
+}
+
+static void renault_hitag_extract_fields(RenaultHitagDecoder* inst) {
+    uint8_t total = inst->generic.data_count_bit;
+    if(total >= 48) {
+        inst->generic.btn = (uint8_t)((inst->generic.data >> (total - 4)) & 0xF);
+        inst->generic.serial = (uint32_t)((inst->generic.data >> 16) & 0x0FFFFFFF);
+        inst->generic.cnt = (uint32_t)(inst->generic.data & 0xFFFF);
+    } else if(total >= 40) {
+        inst->generic.btn = (uint8_t)((inst->generic.data >> (total - 4)) & 0xF);
+        inst->generic.serial = (uint32_t)((inst->generic.data >> 12) & 0x0FFFFFF);
+        inst->generic.cnt = (uint32_t)(inst->generic.data & 0x0FFF);
+    } else {
+        inst->generic.btn = 0;
+        inst->generic.serial = (uint32_t)(inst->generic.data >> 16);
+        inst->generic.cnt = (uint32_t)(inst->generic.data & 0xFFFF);
+    }
+}
+
+static void renault_hitag_try_accept(RenaultHitagDecoder* inst) {
+    if(inst->bit_count >= HITAG_MIN_BITS && inst->bit_count <= HITAG_MAX_BITS) {
+        inst->generic.data = inst->data;
+        inst->generic.data_count_bit = inst->bit_count;
+        renault_hitag_extract_fields(inst);
+        if(inst->base.callback) {
+            inst->base.callback(&inst->base, inst->base.context);
+        }
+    }
+}
+
+// ─── Alloc / Free / Reset ────────────────────────────────────────────────────
+
+static void* renault_hitag_alloc(SubGhzEnvironment* env) {
+    UNUSED(env);
+    RenaultHitagDecoder* inst = malloc(sizeof(RenaultHitagDecoder));
+    memset(inst, 0, sizeof(RenaultHitagDecoder));
+    inst->base.protocol = &subghz_protocol_renault_hitag;
+    inst->generic.protocol_name = inst->base.protocol->name;
+    return inst;
+}
+
+static void renault_hitag_free(void* ctx) {
+    furi_assert(ctx);
+    free(ctx);
+}
+
+static void renault_hitag_reset(void* ctx) {
+    furi_assert(ctx);
+    RenaultHitagDecoder* inst = ctx;
+    inst->bit_count = 0;
+    inst->data = 0;
+    inst->parser_step = HitagStepReset;
+}
+
+// ─── Feed — OOK PWM decoder ─────────────────────────────────────────────────
+
+static void renault_hitag_feed(void* ctx, bool level, uint32_t duration) {
+    furi_assert(ctx);
+    RenaultHitagDecoder* inst = ctx;
+
+    switch(inst->parser_step) {
+
+    case HitagStepReset:
+        if(level) {
+            if(hitag_abs_diff(duration, HITAG_TE_SHORT) < HITAG_TE_DELTA) {
+                inst->data = (inst->data << 1);
+                inst->bit_count++;
+                inst->parser_step = HitagStepWaitSpace;
+            } else if(hitag_abs_diff(duration, HITAG_TE_LONG) < HITAG_TE_DELTA) {
+                inst->data = (inst->data << 1) | 1;
+                inst->bit_count++;
+                inst->parser_step = HitagStepWaitSpace;
+            }
+        }
+        break;
+
+    case HitagStepWaitSpace:
+        if(!level) {
+            if(hitag_abs_diff(duration, HITAG_TE_SHORT) < HITAG_TE_DELTA) {
+                inst->parser_step = HitagStepWaitMark;
+            } else if(duration >= HITAG_GAP_MIN) {
+                renault_hitag_try_accept(inst);
+                inst->data = 0;
+                inst->bit_count = 0;
+                inst->parser_step = HitagStepReset;
+            } else {
+                renault_hitag_try_accept(inst);
+                inst->data = 0;
+                inst->bit_count = 0;
+                inst->parser_step = HitagStepReset;
+            }
+        }
+        break;
+
+    case HitagStepWaitMark:
+        if(level) {
+            if(hitag_abs_diff(duration, HITAG_TE_SHORT) < HITAG_TE_DELTA) {
+                inst->data = (inst->data << 1);
+                inst->bit_count++;
+                inst->parser_step = HitagStepWaitSpace;
+            } else if(hitag_abs_diff(duration, HITAG_TE_LONG) < HITAG_TE_DELTA) {
+                inst->data = (inst->data << 1) | 1;
+                inst->bit_count++;
+                inst->parser_step = HitagStepWaitSpace;
+            } else {
+                renault_hitag_try_accept(inst);
+                inst->data = 0;
+                inst->bit_count = 0;
+                inst->parser_step = HitagStepReset;
+            }
+        } else {
+            if(duration >= HITAG_GAP_MIN) {
+                renault_hitag_try_accept(inst);
+                inst->data = 0;
+                inst->bit_count = 0;
+                inst->parser_step = HitagStepReset;
+            }
+        }
+        break;
+
+    default:
+        renault_hitag_reset(ctx);
+        break;
+    }
+
+    if(inst->bit_count > HITAG_MAX_BITS) {
+        renault_hitag_try_accept(inst);
+        inst->data = 0;
+        inst->bit_count = 0;
+        inst->parser_step = HitagStepReset;
+    }
+}
+
+// ─── Hash ────────────────────────────────────────────────────────────────────
+
+static uint8_t renault_hitag_get_hash(void* ctx) {
+    furi_assert(ctx);
+    RenaultHitagDecoder* inst = ctx;
+    return (uint8_t)(inst->generic.data ^
+                     (inst->generic.data >> 8) ^
+                     (inst->generic.data >> 16) ^
+                     (inst->generic.data >> 24));
+}
+
+// ─── Serialize / Deserialize ─────────────────────────────────────────────────
+
+static SubGhzProtocolStatus renault_hitag_serialize(
+    void* ctx,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(ctx);
+    RenaultHitagDecoder* inst = ctx;
+    return subghz_block_generic_serialize(&inst->generic, flipper_format, preset);
+}
+
+static SubGhzProtocolStatus
+    renault_hitag_deserialize(void* ctx, FlipperFormat* flipper_format) {
+    furi_assert(ctx);
+    RenaultHitagDecoder* inst = ctx;
+    SubGhzProtocolStatus ret = subghz_block_generic_deserialize_check_count_bit(
+        &inst->generic, flipper_format, HITAG_MIN_BITS);
+    if(ret == SubGhzProtocolStatusOk) {
+        inst->data = inst->generic.data;
+        inst->bit_count = inst->generic.data_count_bit;
+        renault_hitag_extract_fields(inst);
+    }
+    return ret;
+}
+
+// ─── get_string ──────────────────────────────────────────────────────────────
+
+static void renault_hitag_get_string(void* ctx, FuriString* output) {
+    furi_assert(ctx);
+    RenaultHitagDecoder* inst = ctx;
+
+    renault_hitag_extract_fields(inst);
+
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = inst->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.current_cnt = inst->generic.cnt;
+    subghz_block_generic_global.cnt_length_bit = 16;
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:%016llX\r\n"
+        "Sn:%07lX Btn:%X\r\n"
+        "Cnt:%04lX\r\n",
+        inst->generic.protocol_name,
+        inst->generic.data_count_bit,
+        (unsigned long long)inst->generic.data,
+        (unsigned long)inst->generic.serial,
+        (unsigned int)inst->generic.btn,
+        (unsigned long)inst->generic.cnt);
+}
+
+// ─── Descriptor ──────────────────────────────────────────────────────────────
+
+const SubGhzProtocolDecoder renault_hitag_decoder = {
+    .alloc = renault_hitag_alloc,
+    .free = renault_hitag_free,
+    .feed = renault_hitag_feed,
+    .reset = renault_hitag_reset,
+    .get_hash_data = renault_hitag_get_hash,
+    .serialize = renault_hitag_serialize,
+    .deserialize = renault_hitag_deserialize,
+    .get_string = renault_hitag_get_string,
+};
+
+const SubGhzProtocol subghz_protocol_renault_hitag = {
+    .name = SUBGHZ_PROTOCOL_RENAULT_HITAG_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 |
+            SubGhzProtocolFlag_AM |
+            SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load |
+            SubGhzProtocolFlag_Save,
+    .decoder = &renault_hitag_decoder,
+    .encoder = NULL,
+};

lib/subghz/protocols/renault_hitag.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <lib/subghz/protocols/base.h>
+
+#define SUBGHZ_PROTOCOL_RENAULT_HITAG_NAME "Renault_Hitag"
+
+extern const SubGhzProtocol subghz_protocol_renault_hitag;

lib/subghz/protocols/renault_marelli.c

@@ -0,0 +1,673 @@
+#include "renault_marelli.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+#include "../blocks/custom_btn_i.h"
+#include <lib/toolbox/manchester_decoder.h>
+#include <lib/toolbox/manchester_encoder.h>
+#include <furi_hal_subghz.h>
+
+#define TAG "RenaultMarelli"
+
+//   Magneti Marelli BSI keyfob protocol (PCF7946) — Renault variant
+//   Found on: Renault Clio III, Modus, Kangoo II, and some Dacia models
+//   sharing the Fiat/Renault Marelli platform (~2004-2014)
+//
+//   RF: 433.92 MHz, Manchester encoding (FSK modulation)
+//   Two timing variants with identical frame structure:
+//     Type A (standard):          te_short ~260us, te_long ~520us
+//     Type B (fast/compact):      te_short ~100us, te_long ~200us
+//   TE is auto-detected from preamble pulse averaging.
+//
+//   Frame layout (103-104 bits = 13 bytes):
+//     Bytes 0-1:  0xFFFF/0xFFFC preamble residue
+//     Bytes 2-5:  Serial (32 bits)
+//     Byte 6:     [Button:4 | Epoch:4]
+//     Byte 7:     [Counter:5 | Scramble:2 | Fixed:1]
+//     Bytes 8-12: Encrypted payload (40 bits)
+
+#define REN_MARELLI_PREAMBLE_PULSE_MIN 50
+#define REN_MARELLI_PREAMBLE_PULSE_MAX 350
+#define REN_MARELLI_PREAMBLE_MIN       80
+#define REN_MARELLI_MAX_DATA_BITS      104
+#define REN_MARELLI_MIN_DATA_BITS      80
+#define REN_MARELLI_GAP_TE_MULT        4
+#define REN_MARELLI_SYNC_TE_MIN_MULT   4
+#define REN_MARELLI_SYNC_TE_MAX_MULT   12
+#define REN_MARELLI_RETX_GAP_MIN       5000
+#define REN_MARELLI_RETX_SYNC_MIN      400
+#define REN_MARELLI_RETX_SYNC_MAX      2800
+#define REN_MARELLI_TE_TYPE_AB_BOUNDARY 180
+
+static const SubGhzBlockConst subghz_protocol_renault_marelli_const = {
+    .te_short = 260,
+    .te_long = 520,
+    .te_delta = 80,
+    .min_count_bit_for_found = 80,
+};
+
+struct SubGhzProtocolDecoderRenaultMarelli {
+    SubGhzProtocolDecoderBase base;
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+    ManchesterState manchester_state;
+    uint8_t decoder_state;
+    uint16_t preamble_count;
+    uint8_t raw_data[13];
+    uint8_t bit_count;
+    uint32_t extra_data;
+    uint32_t te_last;
+    uint32_t te_sum;
+    uint16_t te_count;
+    uint32_t te_detected;
+};
+
+struct SubGhzProtocolEncoderRenaultMarelli {
+    SubGhzProtocolEncoderBase base;
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+    uint8_t raw_data[13];
+    uint32_t extra_data;
+    uint8_t bit_count;
+    uint32_t te_detected;
+};
+
+typedef enum {
+    RenMarelliDecoderStepReset = 0,
+    RenMarelliDecoderStepPreamble = 1,
+    RenMarelliDecoderStepSync = 2,
+    RenMarelliDecoderStepData = 3,
+    RenMarelliDecoderStepRetxSync = 4,
+} RenMarelliDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_renault_marelli_decoder = {
+    .alloc = subghz_protocol_decoder_renault_marelli_alloc,
+    .free = subghz_protocol_decoder_renault_marelli_free,
+    .feed = subghz_protocol_decoder_renault_marelli_feed,
+    .reset = subghz_protocol_decoder_renault_marelli_reset,
+    .get_hash_data = subghz_protocol_decoder_renault_marelli_get_hash_data,
+    .serialize = subghz_protocol_decoder_renault_marelli_serialize,
+    .deserialize = subghz_protocol_decoder_renault_marelli_deserialize,
+    .get_string = subghz_protocol_decoder_renault_marelli_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_renault_marelli_encoder = {
+    .alloc = subghz_protocol_encoder_renault_marelli_alloc,
+    .free = subghz_protocol_encoder_renault_marelli_free,
+    .deserialize = subghz_protocol_encoder_renault_marelli_deserialize,
+    .stop = subghz_protocol_encoder_renault_marelli_stop,
+    .yield = subghz_protocol_encoder_renault_marelli_yield,
+};
+
+const SubGhzProtocol subghz_protocol_renault_marelli = {
+    .name = RENAULT_MARELLI_PROTOCOL_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_FM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+    .decoder = &subghz_protocol_renault_marelli_decoder,
+    .encoder = &subghz_protocol_renault_marelli_encoder,
+};
+
+// ============================================================================
+// Encoder
+// ============================================================================
+
+#define REN_MARELLI_ENCODER_UPLOAD_MAX 1500
+#define REN_MARELLI_ENCODER_REPEAT     3
+#define REN_MARELLI_PREAMBLE_PAIRS     100
+
+void* subghz_protocol_encoder_renault_marelli_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderRenaultMarelli* instance =
+        calloc(1, sizeof(SubGhzProtocolEncoderRenaultMarelli));
+    furi_check(instance);
+    instance->base.protocol = &subghz_protocol_renault_marelli;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->encoder.repeat = REN_MARELLI_ENCODER_REPEAT;
+    instance->encoder.size_upload = REN_MARELLI_ENCODER_UPLOAD_MAX;
+    instance->encoder.upload =
+        malloc(REN_MARELLI_ENCODER_UPLOAD_MAX * sizeof(LevelDuration));
+    furi_check(instance->encoder.upload);
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_renault_marelli_free(void* context) {
+    furi_check(context);
+    SubGhzProtocolEncoderRenaultMarelli* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+static bool renault_marelli_encoder_get_upload(SubGhzProtocolEncoderRenaultMarelli* instance) {
+    uint32_t te = instance->te_detected;
+    if(te == 0) te = subghz_protocol_renault_marelli_const.te_short;
+
+    uint32_t te_short = te;
+    uint32_t te_long = te * 2;
+    uint32_t gap_duration = te * 12;
+    uint32_t sync_duration = te * 8;
+
+    size_t index = 0;
+    size_t max_upload = REN_MARELLI_ENCODER_UPLOAD_MAX;
+    uint8_t data_bits = instance->bit_count;
+    if(data_bits == 0) data_bits = instance->generic.data_count_bit;
+    if(data_bits < REN_MARELLI_MIN_DATA_BITS || data_bits > REN_MARELLI_MAX_DATA_BITS) {
+        return false;
+    }
+
+    // Preamble: alternating short HIGH/LOW
+    for(uint8_t i = 0; i < REN_MARELLI_PREAMBLE_PAIRS && (index + 1) < max_upload; i++) {
+        instance->encoder.upload[index++] = level_duration_make(true, te_short);
+        if(i < REN_MARELLI_PREAMBLE_PAIRS - 1) {
+            instance->encoder.upload[index++] = level_duration_make(false, te_short);
+        }
+    }
+
+    // Gap after preamble
+    if(index < max_upload) {
+        instance->encoder.upload[index++] =
+            level_duration_make(false, te_short + gap_duration);
+    }
+
+    // Sync pulse
+    if(index < max_upload) {
+        instance->encoder.upload[index++] = level_duration_make(true, sync_duration);
+    }
+
+    // Manchester-encode data bits
+    bool in_mid1 = true;
+
+    for(uint8_t bit_i = 0; bit_i < data_bits && (index + 1) < max_upload; bit_i++) {
+        uint8_t byte_idx = bit_i / 8;
+        uint8_t bit_pos = 7 - (bit_i % 8);
+        bool data_bit = (instance->raw_data[byte_idx] >> bit_pos) & 1;
+
+        if(in_mid1) {
+            if(data_bit) {
+                instance->encoder.upload[index++] = level_duration_make(false, te_short);
+                instance->encoder.upload[index++] = level_duration_make(true, te_short);
+            } else {
+                instance->encoder.upload[index++] = level_duration_make(false, te_long);
+                in_mid1 = false;
+            }
+        } else {
+            if(data_bit) {
+                instance->encoder.upload[index++] = level_duration_make(true, te_long);
+                in_mid1 = true;
+            } else {
+                instance->encoder.upload[index++] = level_duration_make(true, te_short);
+                instance->encoder.upload[index++] = level_duration_make(false, te_short);
+            }
+        }
+    }
+
+    // Trailing gap
+    if(in_mid1) {
+        if(index < max_upload) {
+            instance->encoder.upload[index++] =
+                level_duration_make(false, te_short + gap_duration * 3);
+        }
+    } else {
+        if(index > 0) {
+            instance->encoder.upload[index - 1] =
+                level_duration_make(false, te_short + gap_duration * 3);
+        }
+    }
+
+    instance->encoder.size_upload = index;
+    return index > 0;
+}
+
+static void renault_marelli_encoder_rebuild_raw_data(
+    SubGhzProtocolEncoderRenaultMarelli* instance) {
+    memset(instance->raw_data, 0, sizeof(instance->raw_data));
+
+    uint64_t key = instance->generic.data;
+    for(int i = 0; i < 8; i++) {
+        instance->raw_data[i] = (uint8_t)(key >> (56 - i * 8));
+    }
+
+    uint8_t extra_bits =
+        instance->generic.data_count_bit > 64 ? (instance->generic.data_count_bit - 64) : 0;
+    for(uint8_t i = 0; i < extra_bits && i < 32; i++) {
+        uint8_t byte_idx = 8 + (i / 8);
+        uint8_t bit_pos = 7 - (i % 8);
+        if(instance->extra_data & (1UL << (extra_bits - 1 - i))) {
+            instance->raw_data[byte_idx] |= (1 << bit_pos);
+        }
+    }
+
+    instance->bit_count = instance->generic.data_count_bit;
+}
+
+SubGhzProtocolStatus subghz_protocol_encoder_renault_marelli_deserialize(
+    void* context,
+    FlipperFormat* flipper_format) {
+    furi_check(context);
+    SubGhzProtocolEncoderRenaultMarelli* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+
+    do {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) break;
+
+        uint32_t extra = 0;
+        if(flipper_format_read_uint32(flipper_format, "Extra", &extra, 1)) {
+            instance->extra_data = extra;
+        }
+
+        uint32_t te = 0;
+        if(flipper_format_read_uint32(flipper_format, "TE", &te, 1)) {
+            instance->te_detected = te;
+        }
+
+        renault_marelli_encoder_rebuild_raw_data(instance);
+
+        if(!renault_marelli_encoder_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+
+        instance->encoder.repeat = REN_MARELLI_ENCODER_REPEAT;
+        instance->encoder.front = 0;
+        instance->encoder.is_running = true;
+
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_renault_marelli_stop(void* context) {
+    furi_check(context);
+    SubGhzProtocolEncoderRenaultMarelli* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_renault_marelli_yield(void* context) {
+    furi_check(context);
+    SubGhzProtocolEncoderRenaultMarelli* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration ret = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        if(!subghz_block_generic_global.endless_tx) {
+            instance->encoder.repeat--;
+        }
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+// ============================================================================
+// Decoder
+// ============================================================================
+
+static void renault_marelli_rebuild_raw_data(SubGhzProtocolDecoderRenaultMarelli* instance) {
+    memset(instance->raw_data, 0, sizeof(instance->raw_data));
+
+    uint64_t key = instance->generic.data;
+    for(int i = 0; i < 8; i++) {
+        instance->raw_data[i] = (uint8_t)(key >> (56 - i * 8));
+    }
+
+    uint8_t extra_bits =
+        instance->generic.data_count_bit > 64 ? (instance->generic.data_count_bit - 64) : 0;
+    for(uint8_t i = 0; i < extra_bits && i < 32; i++) {
+        uint8_t byte_idx = 8 + (i / 8);
+        uint8_t bit_pos = 7 - (i % 8);
+        if(instance->extra_data & (1UL << (extra_bits - 1 - i))) {
+            instance->raw_data[byte_idx] |= (1 << bit_pos);
+        }
+    }
+
+    instance->bit_count = instance->generic.data_count_bit;
+
+    if(instance->bit_count >= 56) {
+        instance->generic.serial =
+            ((uint32_t)instance->raw_data[2] << 24) |
+            ((uint32_t)instance->raw_data[3] << 16) |
+            ((uint32_t)instance->raw_data[4] << 8) |
+            ((uint32_t)instance->raw_data[5]);
+        instance->generic.btn = (instance->raw_data[6] >> 4) & 0xF;
+        instance->generic.cnt = (instance->raw_data[7] >> 3) & 0x1F;
+    }
+}
+
+static void renault_marelli_prepare_data(SubGhzProtocolDecoderRenaultMarelli* instance) {
+    instance->bit_count = 0;
+    instance->extra_data = 0;
+    instance->generic.data = 0;
+    memset(instance->raw_data, 0, sizeof(instance->raw_data));
+    manchester_advance(
+        instance->manchester_state,
+        ManchesterEventReset,
+        &instance->manchester_state,
+        NULL);
+    instance->decoder_state = RenMarelliDecoderStepData;
+}
+
+void* subghz_protocol_decoder_renault_marelli_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderRenaultMarelli* instance =
+        calloc(1, sizeof(SubGhzProtocolDecoderRenaultMarelli));
+    furi_check(instance);
+    instance->base.protocol = &subghz_protocol_renault_marelli;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_renault_marelli_free(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderRenaultMarelli* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_renault_marelli_reset(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderRenaultMarelli* instance = context;
+    instance->decoder_state = RenMarelliDecoderStepReset;
+    instance->preamble_count = 0;
+    instance->bit_count = 0;
+    instance->extra_data = 0;
+    instance->te_last = 0;
+    instance->te_sum = 0;
+    instance->te_count = 0;
+    instance->te_detected = 0;
+    instance->generic.data = 0;
+    memset(instance->raw_data, 0, sizeof(instance->raw_data));
+    instance->manchester_state = ManchesterStateMid1;
+}
+
+void subghz_protocol_decoder_renault_marelli_feed(void* context, bool level, uint32_t duration) {
+    furi_check(context);
+    SubGhzProtocolDecoderRenaultMarelli* instance = context;
+
+    uint32_t te_short = instance->te_detected
+                            ? instance->te_detected
+                            : (uint32_t)subghz_protocol_renault_marelli_const.te_short;
+    uint32_t te_long = te_short * 2;
+    uint32_t te_delta = te_short / 2;
+    if(te_delta < 30) te_delta = 30;
+    uint32_t diff;
+
+    switch(instance->decoder_state) {
+    case RenMarelliDecoderStepReset:
+        if(level) {
+            if(duration >= REN_MARELLI_PREAMBLE_PULSE_MIN &&
+               duration <= REN_MARELLI_PREAMBLE_PULSE_MAX) {
+                instance->decoder_state = RenMarelliDecoderStepPreamble;
+                instance->preamble_count = 1;
+                instance->te_sum = duration;
+                instance->te_count = 1;
+                instance->te_last = duration;
+            }
+        } else {
+            if(duration > REN_MARELLI_RETX_GAP_MIN) {
+                instance->decoder_state = RenMarelliDecoderStepRetxSync;
+                instance->te_last = duration;
+            }
+        }
+        break;
+
+    case RenMarelliDecoderStepPreamble:
+        if(duration >= REN_MARELLI_PREAMBLE_PULSE_MIN &&
+           duration <= REN_MARELLI_PREAMBLE_PULSE_MAX) {
+            instance->preamble_count++;
+            instance->te_sum += duration;
+            instance->te_count++;
+            instance->te_last = duration;
+        } else if(!level) {
+            if(instance->preamble_count >= REN_MARELLI_PREAMBLE_MIN &&
+               instance->te_count > 0) {
+                instance->te_detected = instance->te_sum / instance->te_count;
+                uint32_t gap_threshold =
+                    instance->te_detected * REN_MARELLI_GAP_TE_MULT;
+
+                if(duration > gap_threshold) {
+                    instance->decoder_state = RenMarelliDecoderStepSync;
+                    instance->te_last = duration;
+                } else {
+                    instance->decoder_state = RenMarelliDecoderStepReset;
+                }
+            } else {
+                instance->decoder_state = RenMarelliDecoderStepReset;
+            }
+        } else {
+            instance->decoder_state = RenMarelliDecoderStepReset;
+        }
+        break;
+
+    case RenMarelliDecoderStepSync: {
+        uint32_t sync_min = instance->te_detected * REN_MARELLI_SYNC_TE_MIN_MULT;
+        uint32_t sync_max = instance->te_detected * REN_MARELLI_SYNC_TE_MAX_MULT;
+
+        if(level && duration >= sync_min && duration <= sync_max) {
+            renault_marelli_prepare_data(instance);
+            instance->te_last = duration;
+        } else {
+            instance->decoder_state = RenMarelliDecoderStepReset;
+        }
+        break;
+    }
+
+    case RenMarelliDecoderStepRetxSync:
+        if(level && duration >= REN_MARELLI_RETX_SYNC_MIN &&
+           duration <= REN_MARELLI_RETX_SYNC_MAX) {
+            if(!instance->te_detected) {
+                instance->te_detected = duration / 8;
+                if(instance->te_detected < 70) instance->te_detected = 100;
+                if(instance->te_detected > 350) instance->te_detected = 260;
+            }
+            renault_marelli_prepare_data(instance);
+            instance->te_last = duration;
+        } else {
+            instance->decoder_state = RenMarelliDecoderStepReset;
+        }
+        break;
+
+    case RenMarelliDecoderStepData: {
+        ManchesterEvent event = ManchesterEventReset;
+        bool frame_complete = false;
+
+        diff = (duration > te_short) ? (duration - te_short) : (te_short - duration);
+        if(diff < te_delta) {
+            event = level ? ManchesterEventShortLow : ManchesterEventShortHigh;
+        } else {
+            diff = (duration > te_long) ? (duration - te_long) : (te_long - duration);
+            if(diff < te_delta) {
+                event = level ? ManchesterEventLongLow : ManchesterEventLongHigh;
+            }
+        }
+
+        if(event != ManchesterEventReset) {
+            bool data_bit;
+            if(manchester_advance(
+                   instance->manchester_state,
+                   event,
+                   &instance->manchester_state,
+                   &data_bit)) {
+                uint32_t new_bit = data_bit ? 1 : 0;
+
+                if(instance->bit_count < REN_MARELLI_MAX_DATA_BITS) {
+                    uint8_t byte_idx = instance->bit_count / 8;
+                    uint8_t bit_pos = 7 - (instance->bit_count % 8);
+                    if(new_bit) {
+                        instance->raw_data[byte_idx] |= (1 << bit_pos);
+                    }
+                }
+
+                if(instance->bit_count < 64) {
+                    instance->generic.data = (instance->generic.data << 1) | new_bit;
+                } else {
+                    instance->extra_data = (instance->extra_data << 1) | new_bit;
+                }
+
+                instance->bit_count++;
+
+                if(instance->bit_count >= REN_MARELLI_MAX_DATA_BITS) {
+                    frame_complete = true;
+                }
+            }
+        } else {
+            if(instance->bit_count >= REN_MARELLI_MIN_DATA_BITS) {
+                frame_complete = true;
+            } else {
+                instance->decoder_state = RenMarelliDecoderStepReset;
+            }
+        }
+
+        if(frame_complete) {
+            instance->generic.data_count_bit = instance->bit_count;
+
+            instance->generic.serial =
+                ((uint32_t)instance->raw_data[2] << 24) |
+                ((uint32_t)instance->raw_data[3] << 16) |
+                ((uint32_t)instance->raw_data[4] << 8) |
+                ((uint32_t)instance->raw_data[5]);
+            instance->generic.btn = (instance->raw_data[6] >> 4) & 0xF;
+            instance->generic.cnt = (instance->raw_data[7] >> 3) & 0x1F;
+
+            if(instance->base.callback) {
+                instance->base.callback(&instance->base, instance->base.context);
+            }
+
+            instance->decoder_state = RenMarelliDecoderStepReset;
+        }
+
+        instance->te_last = duration;
+        break;
+    }
+    }
+}
+
+uint8_t subghz_protocol_decoder_renault_marelli_get_hash_data(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderRenaultMarelli* instance = context;
+    SubGhzBlockDecoder decoder = {
+        .decode_data = instance->generic.data,
+        .decode_count_bit =
+            instance->generic.data_count_bit > 64 ? 64 : instance->generic.data_count_bit,
+    };
+    return subghz_protocol_blocks_get_hash_data(
+        &decoder, (decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_renault_marelli_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_check(context);
+    SubGhzProtocolDecoderRenaultMarelli* instance = context;
+
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+
+    if(ret == SubGhzProtocolStatusOk) {
+        flipper_format_write_uint32(flipper_format, "Extra", &instance->extra_data, 1);
+
+        uint32_t extra_bits = instance->generic.data_count_bit > 64
+                                  ? (instance->generic.data_count_bit - 64)
+                                  : 0;
+        flipper_format_write_uint32(flipper_format, "Extra_bits", &extra_bits, 1);
+
+        uint32_t te = instance->te_detected;
+        flipper_format_write_uint32(flipper_format, "TE", &te, 1);
+    }
+
+    return ret;
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_renault_marelli_deserialize(
+    void* context,
+    FlipperFormat* flipper_format) {
+    furi_check(context);
+    SubGhzProtocolDecoderRenaultMarelli* instance = context;
+
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_deserialize(&instance->generic, flipper_format);
+
+    if(ret == SubGhzProtocolStatusOk) {
+        uint32_t extra = 0;
+        if(flipper_format_read_uint32(flipper_format, "Extra", &extra, 1)) {
+            instance->extra_data = extra;
+        }
+
+        uint32_t te = 0;
+        if(flipper_format_read_uint32(flipper_format, "TE", &te, 1)) {
+            instance->te_detected = te;
+        }
+
+        renault_marelli_rebuild_raw_data(instance);
+    }
+
+    return ret;
+}
+
+static const char* renault_marelli_button_name(uint8_t btn) {
+    switch(btn) {
+    case 0x1:
+        return "Lock";
+    case 0x2:
+        return "Unlock";
+    case 0x4:
+        return "Trunk";
+    case 0x7:
+        return "Lock";
+    case 0xB:
+        return "Unlock";
+    case 0xD:
+        return "Trunk";
+    default:
+        return "Unknown";
+    }
+}
+
+void subghz_protocol_decoder_renault_marelli_get_string(void* context, FuriString* output) {
+    furi_check(context);
+    SubGhzProtocolDecoderRenaultMarelli* instance = context;
+
+    uint8_t epoch = instance->raw_data[6] & 0xF;
+    uint8_t counter = (instance->raw_data[7] >> 3) & 0x1F;
+    const char* variant = (instance->te_detected &&
+                           instance->te_detected < REN_MARELLI_TE_TYPE_AB_BOUNDARY)
+                              ? "B"
+                              : "A";
+    uint8_t scramble = (instance->raw_data[7] >> 1) & 0x3;
+    uint8_t fixed = instance->raw_data[7] & 0x1;
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Enc:%02X%02X%02X%02X%02X Scr:%02X\r\n"
+        "Raw:%02X%02X Fixed:%X\r\n"
+        "Sn:%08X Cnt:%02X\r\n"
+        "Btn:%02X:[%s] Ep:%02X\r\n"
+        "Tp:%s\r\n",
+        instance->generic.protocol_name,
+        (int)instance->bit_count,
+        instance->raw_data[8],
+        instance->raw_data[9],
+        instance->raw_data[10],
+        instance->raw_data[11],
+        instance->raw_data[12],
+        (unsigned)scramble,
+        instance->raw_data[6],
+        instance->raw_data[7],
+        (unsigned)fixed,
+        (unsigned int)instance->generic.serial,
+        (unsigned)counter,
+        (unsigned)instance->generic.btn,
+        renault_marelli_button_name(instance->generic.btn),
+        (unsigned)epoch,
+        variant);
+}

lib/subghz/protocols/renault_marelli.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "base.h"
+#include <flipper_format/flipper_format.h>
+
+#define RENAULT_MARELLI_PROTOCOL_NAME "Ren_MARELLI"
+
+typedef struct SubGhzProtocolDecoderRenaultMarelli SubGhzProtocolDecoderRenaultMarelli;
+typedef struct SubGhzProtocolEncoderRenaultMarelli SubGhzProtocolEncoderRenaultMarelli;
+
+extern const SubGhzProtocol subghz_protocol_renault_marelli;
+
+void* subghz_protocol_decoder_renault_marelli_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_decoder_renault_marelli_free(void* context);
+void subghz_protocol_decoder_renault_marelli_reset(void* context);
+void subghz_protocol_decoder_renault_marelli_feed(void* context, bool level, uint32_t duration);
+uint8_t subghz_protocol_decoder_renault_marelli_get_hash_data(void* context);
+SubGhzProtocolStatus subghz_protocol_decoder_renault_marelli_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_renault_marelli_deserialize(void* context, FlipperFormat* flipper_format);
+void subghz_protocol_decoder_renault_marelli_get_string(void* context, FuriString* output);
+
+void* subghz_protocol_encoder_renault_marelli_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_encoder_renault_marelli_free(void* context);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_renault_marelli_deserialize(void* context, FlipperFormat* flipper_format);
+void subghz_protocol_encoder_renault_marelli_stop(void* context);
+LevelDuration subghz_protocol_encoder_renault_marelli_yield(void* context);

lib/subghz/protocols/renault_siemens.c

@@ -0,0 +1,253 @@
+#include "renault_siemens.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/generic.h"
+
+#define TAG "RenaultSiemens"
+
+// Siemens VDO keyfob — OOK PWM
+// te_short ≈ 250 µs (bit 0 mark)
+// te_long  ≈ 500 µs (bit 1 mark)
+// Space ≈ te_short
+// Gap > 3 × te_long
+
+#define SIEMENS_TE_SHORT  250
+#define SIEMENS_TE_LONG   500
+#define SIEMENS_TE_DELTA  120
+#define SIEMENS_MIN_BITS  64
+#define SIEMENS_MAX_BITS  80
+#define SIEMENS_GAP_MIN   (SIEMENS_TE_LONG * 3)
+
+typedef enum {
+    SiemensStepReset = 0,
+    SiemensStepWaitMark,
+    SiemensStepWaitSpace,
+} SiemensStep;
+
+// ─── Struct ──────────────────────────────────────────────────────────────────
+
+typedef struct {
+    SubGhzProtocolDecoderBase base;
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+    uint64_t data;
+    uint8_t bit_count;
+    uint8_t parser_step;
+} RenaultSiemensDecoder;
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+static inline uint32_t siemens_abs_diff(uint32_t a, uint32_t b) {
+    return (a > b) ? (a - b) : (b - a);
+}
+
+static void renault_siemens_extract_fields(RenaultSiemensDecoder* inst) {
+    inst->generic.serial = (uint32_t)(inst->generic.data >> 32);
+    inst->generic.btn = (uint8_t)((inst->generic.data >> 28) & 0xF);
+    inst->generic.cnt = (uint32_t)(inst->generic.data & 0xFFFF);
+}
+
+static void renault_siemens_try_accept(RenaultSiemensDecoder* inst) {
+    if(inst->bit_count >= SIEMENS_MIN_BITS && inst->bit_count <= SIEMENS_MAX_BITS) {
+        inst->generic.data = inst->data;
+        inst->generic.data_count_bit = inst->bit_count;
+        renault_siemens_extract_fields(inst);
+        if(inst->base.callback) {
+            inst->base.callback(&inst->base, inst->base.context);
+        }
+    }
+}
+
+// ─── Alloc / Free / Reset ────────────────────────────────────────────────────
+
+static void* renault_siemens_alloc(SubGhzEnvironment* env) {
+    UNUSED(env);
+    RenaultSiemensDecoder* inst = malloc(sizeof(RenaultSiemensDecoder));
+    memset(inst, 0, sizeof(RenaultSiemensDecoder));
+    inst->base.protocol = &subghz_protocol_renault_siemens;
+    inst->generic.protocol_name = inst->base.protocol->name;
+    return inst;
+}
+
+static void renault_siemens_free(void* ctx) {
+    furi_assert(ctx);
+    free(ctx);
+}
+
+static void renault_siemens_reset(void* ctx) {
+    furi_assert(ctx);
+    RenaultSiemensDecoder* inst = ctx;
+    inst->data = 0;
+    inst->bit_count = 0;
+    inst->parser_step = SiemensStepReset;
+}
+
+// ─── Feed — OOK PWM decoder ─────────────────────────────────────────────────
+
+static void renault_siemens_feed(void* ctx, bool level, uint32_t duration) {
+    furi_assert(ctx);
+    RenaultSiemensDecoder* inst = ctx;
+
+    switch(inst->parser_step) {
+
+    case SiemensStepReset:
+        if(level) {
+            if(siemens_abs_diff(duration, SIEMENS_TE_SHORT) < SIEMENS_TE_DELTA) {
+                inst->data = (inst->data << 1);
+                inst->bit_count++;
+                inst->parser_step = SiemensStepWaitSpace;
+            } else if(siemens_abs_diff(duration, SIEMENS_TE_LONG) < SIEMENS_TE_DELTA) {
+                inst->data = (inst->data << 1) | 1;
+                inst->bit_count++;
+                inst->parser_step = SiemensStepWaitSpace;
+            }
+        }
+        break;
+
+    case SiemensStepWaitSpace:
+        if(!level) {
+            if(siemens_abs_diff(duration, SIEMENS_TE_SHORT) < SIEMENS_TE_DELTA) {
+                inst->parser_step = SiemensStepWaitMark;
+            } else if(duration >= SIEMENS_GAP_MIN) {
+                renault_siemens_try_accept(inst);
+                inst->data = 0;
+                inst->bit_count = 0;
+                inst->parser_step = SiemensStepReset;
+            } else {
+                renault_siemens_try_accept(inst);
+                inst->data = 0;
+                inst->bit_count = 0;
+                inst->parser_step = SiemensStepReset;
+            }
+        }
+        break;
+
+    case SiemensStepWaitMark:
+        if(level) {
+            if(siemens_abs_diff(duration, SIEMENS_TE_SHORT) < SIEMENS_TE_DELTA) {
+                inst->data = (inst->data << 1);
+                inst->bit_count++;
+                inst->parser_step = SiemensStepWaitSpace;
+            } else if(siemens_abs_diff(duration, SIEMENS_TE_LONG) < SIEMENS_TE_DELTA) {
+                inst->data = (inst->data << 1) | 1;
+                inst->bit_count++;
+                inst->parser_step = SiemensStepWaitSpace;
+            } else {
+                renault_siemens_try_accept(inst);
+                inst->data = 0;
+                inst->bit_count = 0;
+                inst->parser_step = SiemensStepReset;
+            }
+        } else {
+            if(duration >= SIEMENS_GAP_MIN) {
+                renault_siemens_try_accept(inst);
+                inst->data = 0;
+                inst->bit_count = 0;
+                inst->parser_step = SiemensStepReset;
+            }
+        }
+        break;
+
+    default:
+        renault_siemens_reset(ctx);
+        break;
+    }
+
+    if(inst->bit_count > SIEMENS_MAX_BITS) {
+        renault_siemens_try_accept(inst);
+        inst->data = 0;
+        inst->bit_count = 0;
+        inst->parser_step = SiemensStepReset;
+    }
+}
+
+// ─── Hash ────────────────────────────────────────────────────────────────────
+
+static uint8_t renault_siemens_get_hash(void* ctx) {
+    furi_assert(ctx);
+    RenaultSiemensDecoder* inst = ctx;
+    return (uint8_t)(inst->generic.data ^
+                     (inst->generic.data >> 8) ^
+                     (inst->generic.data >> 16) ^
+                     (inst->generic.data >> 24));
+}
+
+// ─── Serialize / Deserialize ─────────────────────────────────────────────────
+
+static SubGhzProtocolStatus renault_siemens_serialize(
+    void* ctx,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(ctx);
+    RenaultSiemensDecoder* inst = ctx;
+    return subghz_block_generic_serialize(&inst->generic, flipper_format, preset);
+}
+
+static SubGhzProtocolStatus
+    renault_siemens_deserialize(void* ctx, FlipperFormat* flipper_format) {
+    furi_assert(ctx);
+    RenaultSiemensDecoder* inst = ctx;
+    SubGhzProtocolStatus ret = subghz_block_generic_deserialize_check_count_bit(
+        &inst->generic, flipper_format, SIEMENS_MIN_BITS);
+    if(ret == SubGhzProtocolStatusOk) {
+        inst->data = inst->generic.data;
+        inst->bit_count = inst->generic.data_count_bit;
+        renault_siemens_extract_fields(inst);
+    }
+    return ret;
+}
+
+// ─── get_string ──────────────────────────────────────────────────────────────
+
+static void renault_siemens_get_string(void* ctx, FuriString* output) {
+    furi_assert(ctx);
+    RenaultSiemensDecoder* inst = ctx;
+
+    renault_siemens_extract_fields(inst);
+
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = inst->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.current_cnt = inst->generic.cnt;
+    subghz_block_generic_global.cnt_length_bit = 16;
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:%016llX\r\n"
+        "Sn:%08lX Btn:%X\r\n"
+        "Cnt:%04lX\r\n",
+        inst->generic.protocol_name,
+        inst->generic.data_count_bit,
+        (unsigned long long)inst->generic.data,
+        (unsigned long)inst->generic.serial,
+        (unsigned int)inst->generic.btn,
+        (unsigned long)inst->generic.cnt);
+}
+
+// ─── Descriptor ──────────────────────────────────────────────────────────────
+
+const SubGhzProtocolDecoder renault_siemens_decoder = {
+    .alloc = renault_siemens_alloc,
+    .free = renault_siemens_free,
+    .feed = renault_siemens_feed,
+    .reset = renault_siemens_reset,
+    .get_hash_data = renault_siemens_get_hash,
+    .serialize = renault_siemens_serialize,
+    .deserialize = renault_siemens_deserialize,
+    .get_string = renault_siemens_get_string,
+};
+
+const SubGhzProtocol subghz_protocol_renault_siemens = {
+    .name = SUBGHZ_PROTOCOL_RENAULT_SIEMENS_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 |
+            SubGhzProtocolFlag_AM |
+            SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load |
+            SubGhzProtocolFlag_Save,
+    .decoder = &renault_siemens_decoder,
+    .encoder = NULL,
+};

lib/subghz/protocols/renault_siemens.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <lib/subghz/protocols/base.h>
+
+#define SUBGHZ_PROTOCOL_RENAULT_SIEMENS_NAME "Renault_Siemens"
+
+extern const SubGhzProtocol subghz_protocol_renault_siemens;

lib/subghz/protocols/renault_valeo.c

@@ -0,0 +1,334 @@
+#include "renault_valeo.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/generic.h"
+#include "keeloq_common.h"
+#include "../subghz_keystore.h"
+#include "../subghz_keystore_i.h"
+#include <m-array.h>
+
+#define TAG "RenaultValeo"
+
+// Valeo OOK keyfob — Captur 2017 / Clio IV / PCF7961
+// OOK PWM encoding:
+//   te_short ≈ 66 µs  → bit 0 (mark)
+//   te_long  ≈ 264 µs → bit 1 (mark)
+//   Space between bits ≈ te_short (66 µs)
+//   Gap between frames > 500 µs
+//
+// Trama (64-96 bits):
+//   [MSB..32] fix: btn[4] + serial[28]
+//   [31..0]   hop: 32 bits KeeLoq encrypted
+
+#define VALEO_TE_SHORT  66
+#define VALEO_TE_LONG   264
+#define VALEO_TE_DELTA  60
+#define VALEO_MIN_BITS  64
+#define VALEO_MAX_BITS  96
+#define VALEO_GAP_MIN   500
+
+typedef enum {
+    ValeoStepReset = 0,
+    ValeoStepWaitMark,
+    ValeoStepWaitSpace,
+} ValeoStep;
+
+// ─── Struct ──────────────────────────────────────────────────────────────────
+
+typedef struct {
+    SubGhzProtocolDecoderBase base;
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint64_t data;
+    uint8_t bit_count;
+    uint8_t parser_step;
+    SubGhzKeystore* keystore;
+    const char* manufacture_name;
+} RenaultValeoDecoder;
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+static inline uint32_t valeo_abs_diff(uint32_t a, uint32_t b) {
+    return (a > b) ? (a - b) : (b - a);
+}
+
+// ─── KeeLoq decode ───────────────────────────────────────────────────────────
+
+static void renault_valeo_decode_keeloq(RenaultValeoDecoder* inst) {
+    if(!inst->keystore) return;
+
+    uint32_t fix = (uint32_t)(inst->data >> 32);
+    uint32_t hop = (uint32_t)(inst->data & 0xFFFFFFFF);
+
+    uint8_t btn = (fix >> 28) & 0xF;
+    uint32_t serial = fix & 0x0FFFFFFF;
+
+    inst->generic.serial = serial;
+    inst->generic.btn = btn;
+    inst->manufacture_name = "Unknown";
+
+    for
+        M_EACH(mf, *subghz_keystore_get_data(inst->keystore), SubGhzKeyArray_t) {
+            // Normal Learning (Valeo primary)
+            if(mf->type == KEELOQ_LEARNING_NORMAL ||
+               mf->type == KEELOQ_LEARNING_UNKNOWN) {
+                uint64_t man = subghz_protocol_keeloq_common_normal_learning(fix, mf->key);
+                uint32_t decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                if((decrypt >> 28) == btn &&
+                   ((decrypt >> 16) & 0xFF) == (serial & 0xFF)) {
+                    inst->generic.cnt = decrypt & 0xFFFF;
+                    inst->manufacture_name = furi_string_get_cstr(mf->name);
+                    return;
+                }
+            }
+            // Simple Learning fallback
+            if(mf->type == KEELOQ_LEARNING_SIMPLE ||
+               mf->type == KEELOQ_LEARNING_UNKNOWN) {
+                uint32_t decrypt = subghz_protocol_keeloq_common_decrypt(hop, mf->key);
+                if((decrypt >> 28) == btn &&
+                   ((decrypt >> 16) & 0xFF) == (serial & 0xFF)) {
+                    inst->generic.cnt = decrypt & 0xFFFF;
+                    inst->manufacture_name = furi_string_get_cstr(mf->name);
+                    return;
+                }
+            }
+        }
+}
+
+// ─── Alloc / Free / Reset ────────────────────────────────────────────────────
+
+static void* renault_valeo_alloc(SubGhzEnvironment* env) {
+    RenaultValeoDecoder* inst = malloc(sizeof(RenaultValeoDecoder));
+    memset(inst, 0, sizeof(RenaultValeoDecoder));
+    inst->base.protocol = &subghz_protocol_renault_valeo;
+    inst->generic.protocol_name = inst->base.protocol->name;
+    inst->keystore = subghz_environment_get_keystore(env);
+    inst->manufacture_name = "Unknown";
+    return inst;
+}
+
+static void renault_valeo_free(void* ctx) {
+    furi_assert(ctx);
+    free(ctx);
+}
+
+static void renault_valeo_reset(void* ctx) {
+    furi_assert(ctx);
+    RenaultValeoDecoder* inst = ctx;
+    inst->data = 0;
+    inst->bit_count = 0;
+    inst->parser_step = ValeoStepReset;
+}
+
+// ─── Feed — OOK PWM ─────────────────────────────────────────────────────────
+
+static void renault_valeo_try_accept(RenaultValeoDecoder* inst) {
+    if(inst->bit_count >= VALEO_MIN_BITS && inst->bit_count <= VALEO_MAX_BITS) {
+        inst->generic.data = inst->data;
+        inst->generic.data_count_bit = inst->bit_count;
+        renault_valeo_decode_keeloq(inst);
+        if(inst->base.callback) {
+            inst->base.callback(&inst->base, inst->base.context);
+        }
+    }
+}
+
+static void renault_valeo_feed(void* ctx, bool level, uint32_t duration) {
+    furi_assert(ctx);
+    RenaultValeoDecoder* inst = ctx;
+
+    switch(inst->parser_step) {
+
+    case ValeoStepReset:
+        if(level) {
+            if(valeo_abs_diff(duration, VALEO_TE_SHORT) < VALEO_TE_DELTA) {
+                inst->data = (inst->data << 1);
+                inst->bit_count++;
+                inst->parser_step = ValeoStepWaitSpace;
+            } else if(valeo_abs_diff(duration, VALEO_TE_LONG) < VALEO_TE_DELTA) {
+                inst->data = (inst->data << 1) | 1;
+                inst->bit_count++;
+                inst->parser_step = ValeoStepWaitSpace;
+            }
+        }
+        break;
+
+    case ValeoStepWaitSpace:
+        if(!level) {
+            if(valeo_abs_diff(duration, VALEO_TE_SHORT) < VALEO_TE_DELTA) {
+                inst->parser_step = ValeoStepWaitMark;
+            } else if(duration >= VALEO_GAP_MIN) {
+                renault_valeo_try_accept(inst);
+                inst->data = 0;
+                inst->bit_count = 0;
+                inst->parser_step = ValeoStepReset;
+            } else {
+                // Allow some tolerance on space — accept wider spaces as inter-bit
+                if(duration < VALEO_GAP_MIN) {
+                    inst->parser_step = ValeoStepWaitMark;
+                } else {
+                    renault_valeo_try_accept(inst);
+                    inst->data = 0;
+                    inst->bit_count = 0;
+                    inst->parser_step = ValeoStepReset;
+                }
+            }
+        }
+        break;
+
+    case ValeoStepWaitMark:
+        if(level) {
+            if(valeo_abs_diff(duration, VALEO_TE_SHORT) < VALEO_TE_DELTA) {
+                inst->data = (inst->data << 1);
+                inst->bit_count++;
+                inst->parser_step = ValeoStepWaitSpace;
+            } else if(valeo_abs_diff(duration, VALEO_TE_LONG) < VALEO_TE_DELTA) {
+                inst->data = (inst->data << 1) | 1;
+                inst->bit_count++;
+                inst->parser_step = ValeoStepWaitSpace;
+            } else {
+                renault_valeo_try_accept(inst);
+                inst->data = 0;
+                inst->bit_count = 0;
+                inst->parser_step = ValeoStepReset;
+            }
+        } else {
+            if(duration >= VALEO_GAP_MIN) {
+                renault_valeo_try_accept(inst);
+                inst->data = 0;
+                inst->bit_count = 0;
+                inst->parser_step = ValeoStepReset;
+            }
+        }
+        break;
+
+    default:
+        renault_valeo_reset(ctx);
+        break;
+    }
+
+    if(inst->bit_count > VALEO_MAX_BITS) {
+        renault_valeo_try_accept(inst);
+        inst->data = 0;
+        inst->bit_count = 0;
+        inst->parser_step = ValeoStepReset;
+    }
+}
+
+// ─── Hash ────────────────────────────────────────────────────────────────────
+
+static uint8_t renault_valeo_get_hash(void* ctx) {
+    furi_assert(ctx);
+    RenaultValeoDecoder* inst = ctx;
+    return (uint8_t)(inst->generic.data ^
+                     (inst->generic.data >> 8) ^
+                     (inst->generic.data >> 16) ^
+                     (inst->generic.data >> 24));
+}
+
+// ─── Serialize / Deserialize ─────────────────────────────────────────────────
+
+static SubGhzProtocolStatus renault_valeo_serialize(
+    void* ctx,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(ctx);
+    RenaultValeoDecoder* inst = ctx;
+    SubGhzProtocolStatus res =
+        subghz_block_generic_serialize(&inst->generic, flipper_format, preset);
+    if(res == SubGhzProtocolStatusOk) {
+        if(!flipper_format_write_string_cstr(
+               flipper_format, "Manufacture", inst->manufacture_name)) {
+            res = SubGhzProtocolStatusErrorParserOthers;
+        }
+    }
+    return res;
+}
+
+static SubGhzProtocolStatus
+    renault_valeo_deserialize(void* ctx, FlipperFormat* flipper_format) {
+    furi_assert(ctx);
+    RenaultValeoDecoder* inst = ctx;
+    SubGhzProtocolStatus res =
+        subghz_block_generic_deserialize_check_count_bit(
+            &inst->generic, flipper_format, VALEO_MIN_BITS);
+    if(res == SubGhzProtocolStatusOk) {
+        inst->data = inst->generic.data;
+        inst->bit_count = inst->generic.data_count_bit;
+
+        // Read manufacture name safely
+        FuriString* mf = furi_string_alloc();
+        if(flipper_format_read_string(flipper_format, "Manufacture", mf)) {
+            // Store a copy since mf will be freed
+            if(furi_string_size(mf) > 0) {
+                inst->manufacture_name = "Loaded";
+            }
+        }
+        furi_string_free(mf);
+
+        // Re-extract fields
+        uint32_t fix = (uint32_t)(inst->generic.data >> 32);
+        inst->generic.serial = fix & 0x0FFFFFFF;
+        inst->generic.btn = (fix >> 28) & 0xF;
+    }
+    return res;
+}
+
+// ─── get_string ──────────────────────────────────────────────────────────────
+
+static void renault_valeo_get_string(void* ctx, FuriString* output) {
+    furi_assert(ctx);
+    RenaultValeoDecoder* inst = ctx;
+
+    uint32_t fix = (uint32_t)(inst->generic.data >> 32);
+    inst->generic.serial = fix & 0x0FFFFFFF;
+    inst->generic.btn = (fix >> 28) & 0xF;
+
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = inst->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.current_cnt = inst->generic.cnt;
+    subghz_block_generic_global.cnt_length_bit = 16;
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:%016llX\r\n"
+        "Sn:%07lX Btn:%X\r\n"
+        "Cnt:%04lX Mf:%s\r\n",
+        inst->generic.protocol_name,
+        inst->generic.data_count_bit,
+        (unsigned long long)inst->generic.data,
+        (unsigned long)inst->generic.serial,
+        (unsigned int)inst->generic.btn,
+        (unsigned long)inst->generic.cnt,
+        inst->manufacture_name);
+}
+
+// ─── Descriptor ──────────────────────────────────────────────────────────────
+
+static const SubGhzProtocolDecoder renault_valeo_decoder = {
+    .alloc = renault_valeo_alloc,
+    .free = renault_valeo_free,
+    .feed = renault_valeo_feed,
+    .reset = renault_valeo_reset,
+    .get_hash_data = renault_valeo_get_hash,
+    .serialize = renault_valeo_serialize,
+    .deserialize = renault_valeo_deserialize,
+    .get_string = renault_valeo_get_string,
+};
+
+const SubGhzProtocol subghz_protocol_renault_valeo = {
+    .name = SUBGHZ_PROTOCOL_RENAULT_VALEO_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 |
+            SubGhzProtocolFlag_AM |
+            SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load |
+            SubGhzProtocolFlag_Save,
+    .decoder = &renault_valeo_decoder,
+    .encoder = NULL,
+};

lib/subghz/protocols/renault_valeo.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <lib/subghz/protocols/base.h>
+
+#define SUBGHZ_PROTOCOL_RENAULT_VALEO_NAME "Renault_Valeo"
+
+extern const SubGhzProtocol subghz_protocol_renault_valeo;

lib/subghz/protocols/renault_valeo_fsk.c

@@ -0,0 +1,316 @@
+#include "renault_valeo_fsk.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/generic.h"
+#include "keeloq_common.h"
+#include "../subghz_keystore.h"
+#include "../subghz_keystore_i.h"
+#include <lib/toolbox/manchester_decoder.h>
+#include <m-array.h>
+
+#define TAG "RenaultValeoFSK"
+
+// Valeo FSK (Megane III, Scenic III, Ren3) — 2FSKDev476Async
+// Manchester encoding over FSK
+// te_short = 500 µs (half-bit cell)
+// te_long  = 1000 µs (full-bit cell)
+// te_delta = 200 µs
+// Preamble: alternating half-cells (min 8)
+
+#define VALEO_FSK_TE_SHORT   500
+#define VALEO_FSK_TE_LONG    1000
+#define VALEO_FSK_TE_DELTA   200
+#define VALEO_FSK_MIN_BITS   64
+#define VALEO_FSK_MAX_BITS   96
+#define VALEO_FSK_PREAMBLE_MIN 8
+
+#ifndef DURATION_DIFF
+#define DURATION_DIFF(x, y) (((x) > (y)) ? ((x) - (y)) : ((y) - (x)))
+#endif
+
+typedef enum {
+    ValeoFSKStepReset = 0,
+    ValeoFSKStepPreamble,
+    ValeoFSKStepDecode,
+} ValeoFSKStep;
+
+// ─── Struct ──────────────────────────────────────────────────────────────────
+
+typedef struct {
+    SubGhzProtocolDecoderBase base;
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint64_t data;
+    uint8_t bit_count;
+    uint8_t preamble_count;
+    ManchesterState manchester_state;
+    SubGhzKeystore* keystore;
+    const char* manufacture_name;
+} RenaultValeoFSKDecoder;
+
+// ─── KeeLoq decode ───────────────────────────────────────────────────────────
+
+static void renault_valeo_fsk_decode_keeloq(RenaultValeoFSKDecoder* inst) {
+    if(!inst->keystore) return;
+
+    uint32_t fix = (uint32_t)(inst->data >> 32);
+    uint32_t hop = (uint32_t)(inst->data & 0xFFFFFFFF);
+
+    uint8_t btn = (fix >> 28) & 0xF;
+    uint32_t serial = fix & 0x0FFFFFFF;
+
+    inst->generic.serial = serial;
+    inst->generic.btn = btn;
+    inst->manufacture_name = "Unknown";
+
+    for
+        M_EACH(mf, *subghz_keystore_get_data(inst->keystore), SubGhzKeyArray_t) {
+            if(mf->type == KEELOQ_LEARNING_NORMAL ||
+               mf->type == KEELOQ_LEARNING_UNKNOWN) {
+                uint64_t man = subghz_protocol_keeloq_common_normal_learning(fix, mf->key);
+                uint32_t decrypt = subghz_protocol_keeloq_common_decrypt(hop, man);
+                if((decrypt >> 28) == btn &&
+                   ((decrypt >> 16) & 0xFF) == (serial & 0xFF)) {
+                    inst->generic.cnt = decrypt & 0xFFFF;
+                    inst->manufacture_name = furi_string_get_cstr(mf->name);
+                    return;
+                }
+            }
+            if(mf->type == KEELOQ_LEARNING_SIMPLE ||
+               mf->type == KEELOQ_LEARNING_UNKNOWN) {
+                uint32_t decrypt = subghz_protocol_keeloq_common_decrypt(hop, mf->key);
+                if((decrypt >> 28) == btn &&
+                   ((decrypt >> 16) & 0xFF) == (serial & 0xFF)) {
+                    inst->generic.cnt = decrypt & 0xFFFF;
+                    inst->manufacture_name = furi_string_get_cstr(mf->name);
+                    return;
+                }
+            }
+        }
+}
+
+// ─── Accept helper ───────────────────────────────────────────────────────────
+
+static void renault_valeo_fsk_try_accept(RenaultValeoFSKDecoder* inst) {
+    if(inst->bit_count >= VALEO_FSK_MIN_BITS &&
+       inst->bit_count <= VALEO_FSK_MAX_BITS) {
+        inst->generic.data = inst->data;
+        inst->generic.data_count_bit = inst->bit_count;
+        renault_valeo_fsk_decode_keeloq(inst);
+        if(inst->base.callback) {
+            inst->base.callback(&inst->base, inst->base.context);
+        }
+    }
+}
+
+// ─── Alloc / Free / Reset ────────────────────────────────────────────────────
+
+static void* renault_valeo_fsk_alloc(SubGhzEnvironment* env) {
+    RenaultValeoFSKDecoder* inst = malloc(sizeof(RenaultValeoFSKDecoder));
+    memset(inst, 0, sizeof(RenaultValeoFSKDecoder));
+    inst->base.protocol = &subghz_protocol_renault_valeo_fsk;
+    inst->generic.protocol_name = inst->base.protocol->name;
+    inst->keystore = subghz_environment_get_keystore(env);
+    inst->manufacture_name = "Unknown";
+    inst->manchester_state = ManchesterStateMid1;
+    inst->decoder.parser_step = ValeoFSKStepReset;
+    return inst;
+}
+
+static void renault_valeo_fsk_free(void* ctx) {
+    furi_assert(ctx);
+    free(ctx);
+}
+
+static void renault_valeo_fsk_reset(void* ctx) {
+    furi_assert(ctx);
+    RenaultValeoFSKDecoder* inst = ctx;
+    inst->data = 0;
+    inst->bit_count = 0;
+    inst->preamble_count = 0;
+    inst->manchester_state = ManchesterStateMid1;
+    inst->decoder.parser_step = ValeoFSKStepReset;
+}
+
+// ─── Feed — Manchester over FSK ──────────────────────────────────────────────
+
+static void renault_valeo_fsk_feed(void* ctx, bool level, uint32_t duration) {
+    furi_assert(ctx);
+    RenaultValeoFSKDecoder* inst = ctx;
+
+    // Classify duration
+    ManchesterEvent event = ManchesterEventReset;
+
+    if(DURATION_DIFF(duration, VALEO_FSK_TE_SHORT) < VALEO_FSK_TE_DELTA) {
+        event = level ? ManchesterEventShortHigh : ManchesterEventShortLow;
+    } else if(DURATION_DIFF(duration, VALEO_FSK_TE_LONG) < VALEO_FSK_TE_DELTA) {
+        event = level ? ManchesterEventLongHigh : ManchesterEventLongLow;
+    } else {
+        // Out of range — gap or noise
+        renault_valeo_fsk_try_accept(inst);
+        renault_valeo_fsk_reset(ctx);
+        return;
+    }
+
+    switch(inst->decoder.parser_step) {
+
+    case ValeoFSKStepReset:
+        if(event == ManchesterEventShortHigh || event == ManchesterEventShortLow) {
+            inst->preamble_count = 1;
+            inst->decoder.parser_step = ValeoFSKStepPreamble;
+        }
+        break;
+
+    case ValeoFSKStepPreamble:
+        if(event == ManchesterEventShortHigh || event == ManchesterEventShortLow) {
+            inst->preamble_count++;
+            if(inst->preamble_count >= VALEO_FSK_PREAMBLE_MIN) {
+                inst->data = 0;
+                inst->bit_count = 0;
+                inst->manchester_state = ManchesterStateMid1;
+                inst->decoder.parser_step = ValeoFSKStepDecode;
+            }
+        } else {
+            renault_valeo_fsk_reset(ctx);
+        }
+        break;
+
+    case ValeoFSKStepDecode: {
+        bool bit_out = false;
+        ManchesterState next_state;
+
+        if(manchester_advance(
+               inst->manchester_state, event, &next_state, &bit_out)) {
+            inst->data = (inst->data << 1) | (bit_out ? 1 : 0);
+            inst->bit_count++;
+
+            if(inst->bit_count >= VALEO_FSK_MAX_BITS) {
+                renault_valeo_fsk_try_accept(inst);
+                renault_valeo_fsk_reset(ctx);
+                return;
+            }
+        }
+        inst->manchester_state = next_state;
+        break;
+    }
+
+    default:
+        renault_valeo_fsk_reset(ctx);
+        break;
+    }
+}
+
+// ─── Hash ────────────────────────────────────────────────────────────────────
+
+static uint8_t renault_valeo_fsk_get_hash(void* ctx) {
+    furi_assert(ctx);
+    RenaultValeoFSKDecoder* inst = ctx;
+    return (uint8_t)(inst->generic.data ^
+                     (inst->generic.data >> 8) ^
+                     (inst->generic.data >> 16) ^
+                     (inst->generic.data >> 24));
+}
+
+// ─── Serialize / Deserialize ─────────────────────────────────────────────────
+
+static SubGhzProtocolStatus renault_valeo_fsk_serialize(
+    void* ctx,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_assert(ctx);
+    RenaultValeoFSKDecoder* inst = ctx;
+    SubGhzProtocolStatus res =
+        subghz_block_generic_serialize(&inst->generic, flipper_format, preset);
+    if(res == SubGhzProtocolStatusOk) {
+        if(!flipper_format_write_string_cstr(
+               flipper_format, "Manufacture", inst->manufacture_name)) {
+            res = SubGhzProtocolStatusErrorParserOthers;
+        }
+    }
+    return res;
+}
+
+static SubGhzProtocolStatus
+    renault_valeo_fsk_deserialize(void* ctx, FlipperFormat* flipper_format) {
+    furi_assert(ctx);
+    RenaultValeoFSKDecoder* inst = ctx;
+    SubGhzProtocolStatus res =
+        subghz_block_generic_deserialize_check_count_bit(
+            &inst->generic, flipper_format, VALEO_FSK_MIN_BITS);
+    if(res == SubGhzProtocolStatusOk) {
+        inst->data = inst->generic.data;
+        inst->bit_count = inst->generic.data_count_bit;
+
+        FuriString* mf = furi_string_alloc();
+        if(flipper_format_read_string(flipper_format, "Manufacture", mf)) {
+            if(furi_string_size(mf) > 0) {
+                inst->manufacture_name = "Loaded";
+            }
+        }
+        furi_string_free(mf);
+
+        uint32_t fix = (uint32_t)(inst->generic.data >> 32);
+        inst->generic.serial = fix & 0x0FFFFFFF;
+        inst->generic.btn = (fix >> 28) & 0xF;
+    }
+    return res;
+}
+
+// ─── get_string ──────────────────────────────────────────────────────────────
+
+static void renault_valeo_fsk_get_string(void* ctx, FuriString* output) {
+    furi_assert(ctx);
+    RenaultValeoFSKDecoder* inst = ctx;
+
+    uint32_t fix = (uint32_t)(inst->generic.data >> 32);
+    inst->generic.serial = fix & 0x0FFFFFFF;
+    inst->generic.btn = (fix >> 28) & 0xF;
+
+    subghz_block_generic_global.btn_is_available = true;
+    subghz_block_generic_global.current_btn = inst->generic.btn;
+    subghz_block_generic_global.btn_length_bit = 4;
+    subghz_block_generic_global.cnt_is_available = true;
+    subghz_block_generic_global.current_cnt = inst->generic.cnt;
+    subghz_block_generic_global.cnt_length_bit = 16;
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:%016llX\r\n"
+        "Sn:%07lX Btn:%X\r\n"
+        "Cnt:%04lX Mf:%s\r\n",
+        inst->generic.protocol_name,
+        inst->generic.data_count_bit,
+        (unsigned long long)inst->generic.data,
+        (unsigned long)inst->generic.serial,
+        (unsigned int)inst->generic.btn,
+        (unsigned long)inst->generic.cnt,
+        inst->manufacture_name);
+}
+
+// ─── Descriptor ──────────────────────────────────────────────────────────────
+
+static const SubGhzProtocolDecoder renault_valeo_fsk_decoder = {
+    .alloc = renault_valeo_fsk_alloc,
+    .free = renault_valeo_fsk_free,
+    .feed = renault_valeo_fsk_feed,
+    .reset = renault_valeo_fsk_reset,
+    .get_hash_data = renault_valeo_fsk_get_hash,
+    .serialize = renault_valeo_fsk_serialize,
+    .deserialize = renault_valeo_fsk_deserialize,
+    .get_string = renault_valeo_fsk_get_string,
+};
+
+const SubGhzProtocol subghz_protocol_renault_valeo_fsk = {
+    .name = SUBGHZ_PROTOCOL_RENAULT_VALEO_FSK_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 |
+            SubGhzProtocolFlag_FM |
+            SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load |
+            SubGhzProtocolFlag_Save,
+    .decoder = &renault_valeo_fsk_decoder,
+    .encoder = NULL,
+};

lib/subghz/protocols/renault_valeo_fsk.h

@@ -0,0 +1,7 @@
+#pragma once
+
+#include <lib/subghz/protocols/base.h>
+
+#define SUBGHZ_PROTOCOL_RENAULT_VALEO_FSK_NAME "Renault_Valeo_FSK"
+
+extern const SubGhzProtocol subghz_protocol_renault_valeo_fsk;