Added Ford V1, Kia V7 and Honda Static, thanks RalphWiggum!

This reverts commit a55189e2a4.

.gitignore

@@ -81,4 +81,12 @@ node_modules/
 
 #companion app
 /companion
-/Flipper-Android-App
+/Flipper-Android-App
+
+#WIP not ready to push protocols
+
+lib/subghz/protocols/subghz_protocol_honda_pandora.c
+lib/subghz/protocols/honda_rolling.c
+lib/subghz/protocols/honda_rolling.h
+lib/subghz/protocols/honda_pandora.c
+lib/subghz/protocols/honda_pandora.h

README.md

@@ -48,8 +48,9 @@ This project may incorporate, adapt, or build upon **other open-source projects*
 | Porsche | Porsche AG | 433/868 MHz | AM | Yes | Yes | No |
 | PSA (Peugeot/Citroën/DS) | PSA GROUP | 433 MHz | AM/FM | Yes | Yes | Yes |
 | Ford | Ford V0 | 315/433 MHz | AM | Yes | Yes | Yes |
+| Ford | Ford V1 | 315/433 MHz | FM | Yes | Yes | Yes |
 | Fiat | Fiat SpA | 433 MHz | AM | Yes | Yes | Yes |
-| Fiat | Marelli/Delphi | 433 MHz | AM | No | Yes | No |
+| Fiat | Marelli/Delphi | 433 MHz | AM | No | Yes | Yes |
 | Renault (old models) | Marelli | 433 MHz | AM | No | Yes | No|
 | Mazda | Siemens (5WK49365D) | 315/433 MHz | AM/FM | Yes | Yes | Yes |
 | Kia/Hyundai | KIA/HYU V0 | 433 MHz | FM | Yes | Yes | Yes |
@@ -58,13 +59,17 @@ This project may incorporate, adapt, or build upon **other open-source projects*
 | Kia/Hyundai | KIA/HYU V3/V4 | 315/433 MHz | AM/FM | Yes | Yes | Yes |
 | Kia/Hyundai | KIA/HYU V5 | 433 MHz | FM | Yes | Yes | Yes |
 | Kia/Hyundai | KIA/HYU V6 | 433 MHz | FM | Yes | Yes | Yes |
+| Kia/Hyundai | KIA V7 | 433 MHz | FM | Yes | Yes | Yes |
 | Subaru | Subaru | 433 MHz | AM | Yes | Yes | No |
 | Suzuki | Suzuki | 433 MHz | FM | Yes | Yes | Yes |
 | Mitsubishi | Mitsubishi V0 | 868 MHz | FM | Yes | Yes | No |
+| Honda | Honda Type A/B | 433 MHz | FM (custom) | Yes | Yes | No |
 | Starline | Star Line | 433 MHz | AM | Yes | Yes | No |
 | Scher-Khan | Scher-Khan | 433 MHz | FM | Yes | Yes | No |
 | Scher-Khan | Magic Code PRO1/PRO2 | 433 MHz | FM | Yes | Yes | Yes |
 | Sheriff | Sheriff CFM (ZX-750/930) | 433 MHz | AM | Yes | Yes | No |
+| Chrysler/Dodge/Jeep | FOBIK GQ43VT | 315/433 MHz | AM | Yes | Yes | No |
+| Honda | Honda Static | 433 MHz | AM | Yes | Yes | No |
 
 ### Gate / Access Protocols
 

applications/main/subghz/resources/subghz/assets/setting_user

@@ -119,3 +119,13 @@ Custom_preset_data: 02 0D 07 04 08 32 0B 06 10 67 11 83 12 04 13 02 15 24 18 18
 Custom_preset_name: FM15k
 Custom_preset_module: CC1101
 Custom_preset_data: 02 0D 03 47 08 32 0B 06 10 A7 11 32 12 00 13 00 14 00 15 32 18 18 19 1D 1B 04 1C 00 1D 92 20 FB 21 B6 22 17 00 00 00 12 0E 34 60 C5 C1 C0
+
+Custom_preset_name: Honda1
+Custom_preset_module: CC1101
+#                                                          G2    G3    G4    D                 L0    L1    L2
+Custom_preset_data: 02 0D 0B 06 08 32 07 04 14 00 13 02 12 04 11 36 10 69 15 32 18 18 19 16 1D 91 1C 00 1B 07 20 FB 22 10 21 56 00 00 C0 00 00 00 00 00 00 00
+
+Custom_preset_name: Honda2
+Custom_preset_module: CC1101
+#                                                          G2    G3    G4    D                 L0    L1    L2
+Custom_preset_data: 02 0D 0B 06 08 32 07 04 14 00 13 02 12 07 11 36 10 E9 15 32 18 18 19 16 1D 92 1C 40 1B 03 20 FB 22 10 21 56 00 00 C0 00 00 00 00 00 00 00

lib/subghz/protocols/bmw_cas4.c

@@ -0,0 +1,305 @@
+#include "bmw_cas4.h"
+
+#include "../blocks/const.h"
+#include "../blocks/decoder.h"
+#include "../blocks/encoder.h"
+#include "../blocks/generic.h"
+#include "../blocks/math.h"
+#include <lib/toolbox/manchester_decoder.h>
+
+#define TAG "BmwCas4"
+
+static const SubGhzBlockConst subghz_protocol_bmw_cas4_const = {
+    .te_short = 500,
+    .te_long = 1000,
+    .te_delta = 150,
+    .min_count_bit_for_found = 64,
+};
+
+#define BMW_CAS4_PREAMBLE_PULSE_MIN 300u
+#define BMW_CAS4_PREAMBLE_PULSE_MAX 700u
+#define BMW_CAS4_PREAMBLE_MIN       10u
+#define BMW_CAS4_DATA_BITS           64u
+#define BMW_CAS4_GAP_MIN             1800u
+#define BMW_CAS4_BYTE0_MARKER        0x30u
+#define BMW_CAS4_BYTE6_MARKER        0xC5u
+
+struct SubGhzProtocolDecoderBmwCas4 {
+    SubGhzProtocolDecoderBase base;
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+    ManchesterState manchester_state;
+    uint8_t decoder_state;
+    uint16_t preamble_count;
+    uint8_t raw_data[8];
+    uint8_t bit_count;
+    uint32_t te_last;
+};
+
+struct SubGhzProtocolEncoderBmwCas4 {
+    SubGhzProtocolEncoderBase base;
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    BmwCas4DecoderStepReset = 0,
+    BmwCas4DecoderStepPreamble,
+    BmwCas4DecoderStepData,
+} BmwCas4DecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_bmw_cas4_decoder = {
+    .alloc = subghz_protocol_decoder_bmw_cas4_alloc,
+    .free = subghz_protocol_decoder_bmw_cas4_free,
+    .feed = subghz_protocol_decoder_bmw_cas4_feed,
+    .reset = subghz_protocol_decoder_bmw_cas4_reset,
+    .get_hash_data = subghz_protocol_decoder_bmw_cas4_get_hash_data,
+    .serialize = subghz_protocol_decoder_bmw_cas4_serialize,
+    .deserialize = subghz_protocol_decoder_bmw_cas4_deserialize,
+    .get_string = subghz_protocol_decoder_bmw_cas4_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_bmw_cas4_encoder = {
+    .alloc = subghz_protocol_encoder_bmw_cas4_alloc,
+    .free = subghz_protocol_encoder_bmw_cas4_free,
+    .deserialize = subghz_protocol_encoder_bmw_cas4_deserialize,
+    .stop = subghz_protocol_encoder_bmw_cas4_stop,
+    .yield = subghz_protocol_encoder_bmw_cas4_yield,
+};
+
+const SubGhzProtocol subghz_protocol_bmw_cas4 = {
+    .name = BMW_CAS4_PROTOCOL_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM |
+            SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save,
+    .decoder = &subghz_protocol_bmw_cas4_decoder,
+    .encoder = &subghz_protocol_bmw_cas4_encoder,
+};
+
+// Encoder stubs
+
+void* subghz_protocol_encoder_bmw_cas4_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderBmwCas4* instance = calloc(1, sizeof(SubGhzProtocolEncoderBmwCas4));
+    furi_check(instance);
+    instance->base.protocol = &subghz_protocol_bmw_cas4;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->encoder.is_running = false;
+    instance->encoder.size_upload = 1;
+    instance->encoder.upload = malloc(sizeof(LevelDuration));
+    furi_check(instance->encoder.upload);
+    return instance;
+}
+
+void subghz_protocol_encoder_bmw_cas4_free(void* context) {
+    furi_check(context);
+    SubGhzProtocolEncoderBmwCas4* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_bmw_cas4_deserialize(void* context, FlipperFormat* flipper_format) {
+    UNUSED(context);
+    UNUSED(flipper_format);
+    return SubGhzProtocolStatusError;
+}
+
+void subghz_protocol_encoder_bmw_cas4_stop(void* context) {
+    furi_check(context);
+    SubGhzProtocolEncoderBmwCas4* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_bmw_cas4_yield(void* context) {
+    UNUSED(context);
+    return level_duration_reset();
+}
+
+// Decoder
+
+static void bmw_cas4_rebuild_raw_data(SubGhzProtocolDecoderBmwCas4* 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));
+    }
+    instance->bit_count = instance->generic.data_count_bit;
+}
+
+void* subghz_protocol_decoder_bmw_cas4_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderBmwCas4* instance = calloc(1, sizeof(SubGhzProtocolDecoderBmwCas4));
+    furi_check(instance);
+    instance->base.protocol = &subghz_protocol_bmw_cas4;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_bmw_cas4_free(void* context) {
+    furi_check(context);
+    free(context);
+}
+
+void subghz_protocol_decoder_bmw_cas4_reset(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderBmwCas4* instance = context;
+    instance->decoder_state = BmwCas4DecoderStepReset;
+    instance->preamble_count = 0;
+    instance->bit_count = 0;
+    instance->te_last = 0;
+    instance->generic.data = 0;
+    memset(instance->raw_data, 0, sizeof(instance->raw_data));
+    instance->manchester_state = ManchesterStateMid1;
+}
+
+void subghz_protocol_decoder_bmw_cas4_feed(void* context, bool level, uint32_t duration) {
+    furi_check(context);
+    SubGhzProtocolDecoderBmwCas4* instance = context;
+
+    uint32_t te_short = subghz_protocol_bmw_cas4_const.te_short;
+    uint32_t te_long = subghz_protocol_bmw_cas4_const.te_long;
+    uint32_t te_delta = subghz_protocol_bmw_cas4_const.te_delta;
+    uint32_t diff;
+
+    switch(instance->decoder_state) {
+    case BmwCas4DecoderStepReset:
+        if(level && duration >= BMW_CAS4_PREAMBLE_PULSE_MIN &&
+           duration <= BMW_CAS4_PREAMBLE_PULSE_MAX) {
+            instance->decoder_state = BmwCas4DecoderStepPreamble;
+            instance->preamble_count = 1;
+            instance->te_last = duration;
+        }
+        break;
+
+    case BmwCas4DecoderStepPreamble:
+        if(duration >= BMW_CAS4_PREAMBLE_PULSE_MIN &&
+           duration <= BMW_CAS4_PREAMBLE_PULSE_MAX) {
+            instance->preamble_count++;
+            instance->te_last = duration;
+        } else if(!level && duration >= BMW_CAS4_GAP_MIN) {
+            if(instance->preamble_count >= BMW_CAS4_PREAMBLE_MIN) {
+                instance->bit_count = 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 = BmwCas4DecoderStepData;
+            } else {
+                instance->decoder_state = BmwCas4DecoderStepReset;
+            }
+        } else {
+            instance->decoder_state = BmwCas4DecoderStepReset;
+        }
+        break;
+
+    case BmwCas4DecoderStepData: {
+        if(instance->bit_count >= BMW_CAS4_DATA_BITS) {
+            instance->decoder_state = BmwCas4DecoderStepReset;
+            break;
+        }
+
+        ManchesterEvent event = ManchesterEventReset;
+
+        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 < BMW_CAS4_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);
+                    }
+                    instance->generic.data = (instance->generic.data << 1) | new_bit;
+                }
+
+                instance->bit_count++;
+
+                if(instance->bit_count == BMW_CAS4_DATA_BITS) {
+                    if(instance->raw_data[0] == BMW_CAS4_BYTE0_MARKER &&
+                       instance->raw_data[6] == BMW_CAS4_BYTE6_MARKER) {
+                        instance->generic.data_count_bit = BMW_CAS4_DATA_BITS;
+                        if(instance->base.callback) {
+                            instance->base.callback(&instance->base, instance->base.context);
+                        }
+                    }
+                    instance->decoder_state = BmwCas4DecoderStepReset;
+                }
+            }
+        } else {
+            instance->decoder_state = BmwCas4DecoderStepReset;
+        }
+
+        instance->te_last = duration;
+        break;
+    }
+    }
+}
+
+uint8_t subghz_protocol_decoder_bmw_cas4_get_hash_data(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderBmwCas4* instance = context;
+    SubGhzBlockDecoder dec = {
+        .decode_data = instance->generic.data,
+        .decode_count_bit = instance->generic.data_count_bit,
+    };
+    return subghz_protocol_blocks_get_hash_data(&dec, (dec.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_bmw_cas4_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_check(context);
+    SubGhzProtocolDecoderBmwCas4* instance = context;
+    return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_bmw_cas4_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_check(context);
+    SubGhzProtocolDecoderBmwCas4* instance = context;
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_deserialize(&instance->generic, flipper_format);
+    if(ret == SubGhzProtocolStatusOk) {
+        bmw_cas4_rebuild_raw_data(instance);
+    }
+    return ret;
+}
+
+void subghz_protocol_decoder_bmw_cas4_get_string(void* context, FuriString* output) {
+    furi_check(context);
+    SubGhzProtocolDecoderBmwCas4* instance = context;
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Raw:%02X %02X%02X%02X%02X%02X %02X %02X\r\n",
+        instance->generic.protocol_name,
+        (int)instance->generic.data_count_bit,
+        instance->raw_data[0],
+        instance->raw_data[1], instance->raw_data[2],
+        instance->raw_data[3], instance->raw_data[4], instance->raw_data[5],
+        instance->raw_data[6],
+        instance->raw_data[7]);
+}

lib/subghz/protocols/bmw_cas4.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "base.h"
+#include <flipper_format/flipper_format.h>
+
+#define BMW_CAS4_PROTOCOL_NAME "BMW CAS4"
+
+typedef struct SubGhzProtocolDecoderBmwCas4 SubGhzProtocolDecoderBmwCas4;
+typedef struct SubGhzProtocolEncoderBmwCas4 SubGhzProtocolEncoderBmwCas4;
+
+extern const SubGhzProtocol subghz_protocol_bmw_cas4;
+
+void* subghz_protocol_decoder_bmw_cas4_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_decoder_bmw_cas4_free(void* context);
+void subghz_protocol_decoder_bmw_cas4_reset(void* context);
+void subghz_protocol_decoder_bmw_cas4_feed(void* context, bool level, uint32_t duration);
+uint8_t subghz_protocol_decoder_bmw_cas4_get_hash_data(void* context);
+SubGhzProtocolStatus subghz_protocol_decoder_bmw_cas4_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_bmw_cas4_deserialize(void* context, FlipperFormat* flipper_format);
+void subghz_protocol_decoder_bmw_cas4_get_string(void* context, FuriString* output);
+
+void* subghz_protocol_encoder_bmw_cas4_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_encoder_bmw_cas4_free(void* context);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_bmw_cas4_deserialize(void* context, FlipperFormat* flipper_format);
+void subghz_protocol_encoder_bmw_cas4_stop(void* context);
+LevelDuration subghz_protocol_encoder_bmw_cas4_yield(void* context);

lib/subghz/protocols/chrysler.c

@@ -0,0 +1,643 @@
+#include "chrysler.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"
+
+#define TAG "Chrysler"
+
+//   Chrysler keyfob rolling code protocol
+//   Found on: PT Cruiser, Dodge, Jeep (~2004-2010)
+//
+//   RF: 433.92 MHz, OOK PWM encoding
+//   Bit timing: ~4000us total period
+//     Bit 0: ~300us HIGH + ~3700us LOW
+//     Bit 1: ~600us HIGH + ~3400us LOW
+//   Frame: 24-bit zero preamble + gap ~15600us + 80-bit data
+//   Retransmission: same frame sent twice per press
+//
+//   80-bit frame layout (10 bytes):
+//     Byte 0: [counter:4 | device_id:4]
+//       Counter: 4-bit, bit-reversed, decrementing
+//       Device ID: constant per keyfob (e.g. 0xB)
+//     Bytes 1-4: nibble-interleaved rolling code + button
+//       MSB(b0)=0: high nibbles = rolling, low nibbles = button
+//       MSB(b0)=1: low nibbles = rolling, high nibbles = button
+//     Byte 5: check byte (b1 XOR 0xC3 when MSB=0, b1 when MSB=1)
+//     Byte 6: b1 XOR mask (mask depends on MSB and button)
+//     Bytes 7-9: b2-b4 XOR fixed mask (redundancy copy)
+//
+//   Rolling code: single 8-bit value XOR'd with per-device serial offsets
+//   across all 4 byte positions. The 4 bytes are related by constant XOR
+//   (the serial).
+
+static const SubGhzBlockConst subghz_protocol_chrysler_const = {
+    .te_short = 300,
+    .te_long = 600,
+    .te_delta = 150,
+    .min_count_bit_for_found = 80,
+};
+
+#define CHRYSLER_BIT_PERIOD     4000u
+#define CHRYSLER_BIT_TOLERANCE  800u
+#define CHRYSLER_PREAMBLE_MIN   15u
+#define CHRYSLER_PREAMBLE_GAP   10000u
+#define CHRYSLER_DATA_BITS      80u
+#define CHRYSLER_SHORT_MAX      450u
+#define CHRYSLER_LONG_MIN       450u
+#define CHRYSLER_LONG_MAX       800u
+
+struct SubGhzProtocolDecoderChrysler {
+    SubGhzProtocolDecoderBase base;
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+    uint8_t decoder_state;
+    uint16_t preamble_count;
+    uint8_t raw_data[10];
+    uint8_t bit_count;
+    uint32_t te_last;
+};
+
+struct SubGhzProtocolEncoderChrysler {
+    SubGhzProtocolEncoderBase base;
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+    uint8_t raw_data[10];
+};
+
+typedef enum {
+    ChryslerDecoderStepReset = 0,
+    ChryslerDecoderStepPreamble,
+    ChryslerDecoderStepGap,
+    ChryslerDecoderStepData,
+} ChryslerDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_chrysler_decoder = {
+    .alloc = subghz_protocol_decoder_chrysler_alloc,
+    .free = subghz_protocol_decoder_chrysler_free,
+    .feed = subghz_protocol_decoder_chrysler_feed,
+    .reset = subghz_protocol_decoder_chrysler_reset,
+    .get_hash_data = subghz_protocol_decoder_chrysler_get_hash_data,
+    .serialize = subghz_protocol_decoder_chrysler_serialize,
+    .deserialize = subghz_protocol_decoder_chrysler_deserialize,
+    .get_string = subghz_protocol_decoder_chrysler_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_chrysler_encoder = {
+    .alloc = subghz_protocol_encoder_chrysler_alloc,
+    .free = subghz_protocol_encoder_chrysler_free,
+    .deserialize = subghz_protocol_encoder_chrysler_deserialize,
+    .stop = subghz_protocol_encoder_chrysler_stop,
+    .yield = subghz_protocol_encoder_chrysler_yield,
+};
+
+const SubGhzProtocol subghz_protocol_chrysler = {
+    .name = CHRYSLER_PROTOCOL_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_315 | SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM |
+            SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+    .decoder = &subghz_protocol_chrysler_decoder,
+    .encoder = &subghz_protocol_chrysler_encoder,
+};
+
+static uint8_t chrysler_reverse_nibble(uint8_t n) {
+    return (uint8_t)(((n & 1) << 3) | ((n & 2) << 1) | ((n & 4) >> 1) | ((n & 8) >> 3));
+}
+
+// Encoder
+
+#define CHRYSLER_ENCODER_UPLOAD_MAX 800
+#define CHRYSLER_ENCODER_REPEAT     3
+#define CHRYSLER_PREAMBLE_BITS      24
+#define CHRYSLER_PREAMBLE_GAP_US    15600
+
+static uint8_t chrysler_custom_to_btn(uint8_t custom) {
+    switch(custom) {
+    case 1:
+        return 0x01; // Lock
+    case 2:
+        return 0x02; // Unlock
+    default:
+        return 0;
+    }
+}
+
+static void chrysler_advance_rolling(uint8_t* d) {
+    // Advance the counter and rolling code for the next transmission.
+    //
+    // Counter: 4-bit bit-reversed in upper nibble of b0, decrementing.
+    // Rolling code: nibble-interleaved into bytes 1-4, swapped based on MSB(b0).
+    //
+    // Step 1: Extract current rolling nibbles and button nibbles
+    uint8_t msb = (d[0] >> 7) & 1;
+    uint8_t rolling[4], button[4];
+    for(int i = 0; i < 4; i++) {
+        if(msb == 0) {
+            rolling[i] = (d[1 + i] >> 4) & 0xF;
+            button[i] = d[1 + i] & 0xF;
+        } else {
+            rolling[i] = d[1 + i] & 0xF;
+            button[i] = (d[1 + i] >> 4) & 0xF;
+        }
+    }
+
+    // Step 2: Decrement the bit-reversed counter
+    uint8_t cnt_raw = (d[0] >> 4) & 0xF;
+    uint8_t cnt = chrysler_reverse_nibble(cnt_raw);
+    cnt = (cnt - 1) & 0xF;
+    cnt_raw = chrysler_reverse_nibble(cnt);
+    uint8_t new_msb = (cnt_raw >> 3) & 1;
+
+    // Step 3: Reassemble byte 0
+    d[0] = (cnt_raw << 4) | (d[0] & 0x0F);
+
+    // Step 4: Re-interleave nibbles with new MSB
+    // The rolling nibbles stay the same for one step (they change every 2 presses,
+    // i.e. when MSB returns to the same value). The button nibbles may differ
+    // between MSB=0 and MSB=1 states.
+    for(int i = 0; i < 4; i++) {
+        if(new_msb == 0) {
+            d[1 + i] = (rolling[i] << 4) | (button[i] & 0xF);
+        } else {
+            d[1 + i] = ((button[i] & 0xF) << 4) | rolling[i];
+        }
+    }
+}
+
+static void chrysler_encoder_rebuild(SubGhzProtocolEncoderChrysler* instance) {
+    uint8_t* d = instance->raw_data;
+    uint8_t msb = (d[0] >> 7) & 1;
+    uint8_t btn = instance->generic.btn;
+
+    uint8_t custom = subghz_custom_btn_get();
+    if(custom != 0) {
+        uint8_t new_btn = chrysler_custom_to_btn(custom);
+        if(new_btn != 0) btn = new_btn;
+    }
+
+    // Determine b1^b6 mask based on button and MSB
+    uint8_t b1_xor_b6;
+    if(msb == 0) {
+        b1_xor_b6 = (btn == 0x01) ? 0x04 : 0x08;
+    } else {
+        b1_xor_b6 = 0x62;
+    }
+
+    // Rebuild byte 5
+    d[5] = (msb == 0) ? (d[1] ^ 0xC3) : d[1];
+
+    // Rebuild byte 6
+    d[6] = d[1] ^ b1_xor_b6;
+
+    // Rebuild bytes 7-9 from bytes 2-4
+    if(msb == 0) {
+        d[7] = d[2] ^ 0x63;
+        d[8] = d[3] ^ 0x59;
+        d[9] = d[4] ^ 0x46;
+    } else {
+        d[7] = d[2] ^ 0x9A;
+        d[8] = d[3] ^ 0xC6;
+        d[9] = d[4] ^ ((btn == 0x01) ? 0x20 : 0x10);
+    }
+}
+
+static bool chrysler_encoder_get_upload(SubGhzProtocolEncoderChrysler* instance) {
+    uint32_t te_short = subghz_protocol_chrysler_const.te_short;
+    uint32_t te_bit_period = CHRYSLER_BIT_PERIOD;
+    size_t index = 0;
+    size_t max_upload = CHRYSLER_ENCODER_UPLOAD_MAX;
+
+    // Preamble: 24 zero bits (short HIGH + long LOW each)
+    for(uint8_t i = 0; i < CHRYSLER_PREAMBLE_BITS && (index + 1) < max_upload; i++) {
+        instance->encoder.upload[index++] = level_duration_make(true, te_short);
+        instance->encoder.upload[index++] =
+            level_duration_make(false, te_bit_period - te_short);
+    }
+
+    // Gap between preamble and data
+    if(index > 0) {
+        instance->encoder.upload[index - 1] =
+            level_duration_make(false, CHRYSLER_PREAMBLE_GAP_US);
+    }
+
+    // Data: 80 bits PWM
+    for(uint8_t bit_i = 0; bit_i < CHRYSLER_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;
+
+        uint32_t high_dur = data_bit ? 600 : te_short;
+        uint32_t low_dur = te_bit_period - high_dur;
+
+        instance->encoder.upload[index++] = level_duration_make(true, high_dur);
+        instance->encoder.upload[index++] = level_duration_make(false, low_dur);
+    }
+
+    // Final gap after frame
+    if(index > 0) {
+        instance->encoder.upload[index - 1] =
+            level_duration_make(false, CHRYSLER_PREAMBLE_GAP_US);
+    }
+
+    instance->encoder.size_upload = index;
+    return index > 0;
+}
+
+void* subghz_protocol_encoder_chrysler_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderChrysler* instance = calloc(1, sizeof(SubGhzProtocolEncoderChrysler));
+    furi_check(instance);
+    instance->base.protocol = &subghz_protocol_chrysler;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->encoder.repeat = CHRYSLER_ENCODER_REPEAT;
+    instance->encoder.size_upload = CHRYSLER_ENCODER_UPLOAD_MAX;
+    instance->encoder.upload = malloc(CHRYSLER_ENCODER_UPLOAD_MAX * sizeof(LevelDuration));
+    furi_check(instance->encoder.upload);
+    instance->encoder.is_running = false;
+    return instance;
+}
+
+void subghz_protocol_encoder_chrysler_free(void* context) {
+    furi_check(context);
+    SubGhzProtocolEncoderChrysler* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_chrysler_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_check(context);
+    SubGhzProtocolEncoderChrysler* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+
+    do {
+        ret = subghz_block_generic_deserialize(&instance->generic, flipper_format);
+        if(ret != SubGhzProtocolStatusOk) break;
+
+        // Rebuild raw_data from generic.data (bytes 0-7)
+        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));
+        }
+
+        // Read extra bytes 8-9
+        uint32_t extra = 0;
+        if(flipper_format_read_uint32(flipper_format, "Extra", &extra, 1)) {
+            instance->raw_data[8] = (extra >> 8) & 0xFF;
+            instance->raw_data[9] = extra & 0xFF;
+        }
+
+        // Advance rolling code (decrement counter, swap nibble interleaving)
+        chrysler_advance_rolling(instance->raw_data);
+
+        // Rebuild check bytes with (possibly changed) button
+        chrysler_encoder_rebuild(instance);
+
+        if(!chrysler_encoder_get_upload(instance)) {
+            ret = SubGhzProtocolStatusErrorEncoderGetUpload;
+            break;
+        }
+
+        instance->encoder.repeat = CHRYSLER_ENCODER_REPEAT;
+        instance->encoder.front = 0;
+        instance->encoder.is_running = true;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_chrysler_stop(void* context) {
+    furi_check(context);
+    SubGhzProtocolEncoderChrysler* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_chrysler_yield(void* context) {
+    furi_check(context);
+    SubGhzProtocolEncoderChrysler* 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;
+        chrysler_advance_rolling(instance->raw_data);
+        chrysler_encoder_rebuild(instance);
+        chrysler_encoder_get_upload(instance);
+    }
+
+    return ret;
+}
+
+// Decoder
+
+static void chrysler_parse_data(SubGhzProtocolDecoderChrysler* instance) {
+    uint8_t* d = instance->raw_data;
+
+    uint8_t cnt_raw = (d[0] >> 4) & 0xF;
+    uint8_t cnt = chrysler_reverse_nibble(cnt_raw);
+    uint8_t dev_id = d[0] & 0xF;
+    uint8_t msb = (d[0] >> 7) & 1;
+
+    // Determine button from b1^b6 mask
+    uint8_t b1_xor_b6 = d[1] ^ d[6];
+    uint8_t btn = 0;
+    if(msb == 0) {
+        if(b1_xor_b6 == 0x04)
+            btn = 0x01; // Lock
+        else if(b1_xor_b6 == 0x08)
+            btn = 0x02; // Unlock
+        else
+            btn = 0x00;
+    } else {
+        btn = 0xFF; // Can't distinguish from MSB=1 mask (both = 0x62)
+    }
+
+    // Serial: XOR offsets between byte positions (constant per device)
+    // We derive it from the relationship between byte positions
+    // serial_bytes[i] = rolling_value XOR bytes[1+i]_rolling_nibble
+    // Since all positions share the same LFSR, XOR between positions is the serial
+
+    instance->generic.serial =
+        ((uint32_t)(d[1] ^ d[2]) << 24) |
+        ((uint32_t)(d[1] ^ d[3]) << 16) |
+        ((uint32_t)(d[1] ^ d[4]) << 8) |
+        ((uint32_t)dev_id);
+
+    instance->generic.cnt = cnt;
+    instance->generic.btn = (btn != 0xFF) ? btn : 0;
+
+    // Store full 80-bit data
+    instance->generic.data =
+        ((uint64_t)d[0] << 56) | ((uint64_t)d[1] << 48) |
+        ((uint64_t)d[2] << 40) | ((uint64_t)d[3] << 32) |
+        ((uint64_t)d[4] << 24) | ((uint64_t)d[5] << 16) |
+        ((uint64_t)d[6] << 8) | ((uint64_t)d[7]);
+    instance->generic.data_count_bit = CHRYSLER_DATA_BITS;
+}
+
+static bool chrysler_validate(SubGhzProtocolDecoderChrysler* instance) {
+    uint8_t* d = instance->raw_data;
+    uint8_t msb = (d[0] >> 7) & 1;
+
+    // Check byte 5: should be b1 XOR 0xC3 (MSB=0) or b1 (MSB=1)
+    if(msb == 0) {
+        if(d[5] != (d[1] ^ 0xC3)) return false;
+    } else {
+        if(d[5] != d[1]) return false;
+    }
+
+    // Check bytes 6-9 vs 1-4 XOR mask consistency
+    // b1^b6 should be a known mask
+    uint8_t b1_xor_b6 = d[1] ^ d[6];
+    if(msb == 0) {
+        if(b1_xor_b6 != 0x04 && b1_xor_b6 != 0x08) return false;
+    } else {
+        if(b1_xor_b6 != 0x62) return false;
+    }
+
+    // Check bytes 2-4 vs 7-9 XOR mask is consistent
+    // The XOR mask for bytes 2-4 vs 7-9 should be the same across all 3 pairs
+    uint8_t mask2 = d[2] ^ d[7];
+    uint8_t mask3 = d[3] ^ d[8];
+    uint8_t mask4 = d[4] ^ d[9];
+
+    // Masks should be one of the known patterns
+    if(msb == 0) {
+        if(mask2 != 0x63 || mask3 != 0x59 || mask4 != 0x46) return false;
+    } else {
+        // MSB=1 masks: 9A C6 20 or 9A C6 10
+        if(mask2 != 0x9A || mask3 != 0xC6) return false;
+        if(mask4 != 0x20 && mask4 != 0x10) return false;
+    }
+
+    return true;
+}
+
+static void chrysler_rebuild_raw_data(SubGhzProtocolDecoderChrysler* 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));
+    }
+    instance->bit_count = instance->generic.data_count_bit;
+}
+
+void* subghz_protocol_decoder_chrysler_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderChrysler* instance = calloc(1, sizeof(SubGhzProtocolDecoderChrysler));
+    furi_check(instance);
+    instance->base.protocol = &subghz_protocol_chrysler;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    return instance;
+}
+
+void subghz_protocol_decoder_chrysler_free(void* context) {
+    furi_check(context);
+    free(context);
+}
+
+void subghz_protocol_decoder_chrysler_reset(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderChrysler* instance = context;
+    instance->decoder_state = ChryslerDecoderStepReset;
+    instance->preamble_count = 0;
+    instance->bit_count = 0;
+    instance->te_last = 0;
+    instance->generic.data = 0;
+    memset(instance->raw_data, 0, sizeof(instance->raw_data));
+}
+
+void subghz_protocol_decoder_chrysler_feed(void* context, bool level, uint32_t duration) {
+    furi_check(context);
+    SubGhzProtocolDecoderChrysler* instance = context;
+
+    switch(instance->decoder_state) {
+    case ChryslerDecoderStepReset:
+        if(level && duration <= CHRYSLER_SHORT_MAX && duration > 100) {
+            instance->te_last = duration;
+            instance->decoder_state = ChryslerDecoderStepPreamble;
+            instance->preamble_count = 1;
+        }
+        break;
+
+    case ChryslerDecoderStepPreamble:
+        if(!level) {
+            uint32_t total = instance->te_last + duration;
+            if(DURATION_DIFF(total, CHRYSLER_BIT_PERIOD) < CHRYSLER_BIT_TOLERANCE &&
+               instance->te_last <= CHRYSLER_SHORT_MAX) {
+                instance->preamble_count++;
+            } else if(duration > CHRYSLER_PREAMBLE_GAP &&
+                      instance->preamble_count >= CHRYSLER_PREAMBLE_MIN) {
+                instance->decoder_state = ChryslerDecoderStepGap;
+            } else {
+                instance->decoder_state = ChryslerDecoderStepReset;
+            }
+        } else {
+            if(duration <= CHRYSLER_SHORT_MAX && duration > 100) {
+                instance->te_last = duration;
+            } else {
+                instance->decoder_state = ChryslerDecoderStepReset;
+            }
+        }
+        break;
+
+    case ChryslerDecoderStepGap:
+        if(level) {
+            instance->te_last = duration;
+            instance->bit_count = 0;
+            memset(instance->raw_data, 0, sizeof(instance->raw_data));
+            instance->decoder_state = ChryslerDecoderStepData;
+        } else {
+            instance->decoder_state = ChryslerDecoderStepReset;
+        }
+        break;
+
+    case ChryslerDecoderStepData:
+        if(level) {
+            instance->te_last = duration;
+        } else {
+            uint32_t total = instance->te_last + duration;
+            if(DURATION_DIFF(total, CHRYSLER_BIT_PERIOD) < CHRYSLER_BIT_TOLERANCE) {
+                bool bit_val = (instance->te_last >= CHRYSLER_LONG_MIN);
+
+                if(instance->bit_count < CHRYSLER_DATA_BITS) {
+                    uint8_t byte_idx = instance->bit_count / 8;
+                    uint8_t bit_pos = 7 - (instance->bit_count % 8);
+                    if(bit_val) {
+                        instance->raw_data[byte_idx] |= (1 << bit_pos);
+                    }
+                    instance->bit_count++;
+                }
+
+                if(instance->bit_count == CHRYSLER_DATA_BITS) {
+                    if(chrysler_validate(instance)) {
+                        chrysler_parse_data(instance);
+                        if(instance->base.callback) {
+                            instance->base.callback(&instance->base, instance->base.context);
+                        }
+                    }
+                    instance->decoder_state = ChryslerDecoderStepReset;
+                }
+            } else {
+                if(instance->bit_count >= CHRYSLER_DATA_BITS) {
+                    if(chrysler_validate(instance)) {
+                        chrysler_parse_data(instance);
+                        if(instance->base.callback) {
+                            instance->base.callback(&instance->base, instance->base.context);
+                        }
+                    }
+                }
+                instance->decoder_state = ChryslerDecoderStepReset;
+            }
+        }
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_chrysler_get_hash_data(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderChrysler* instance = context;
+    SubGhzBlockDecoder dec = {
+        .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(&dec, (dec.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_chrysler_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_check(context);
+    SubGhzProtocolDecoderChrysler* instance = context;
+
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+
+    if(ret == SubGhzProtocolStatusOk) {
+        uint32_t extra = ((uint32_t)instance->raw_data[8] << 8) | instance->raw_data[9];
+        flipper_format_write_uint32(flipper_format, "Extra", &extra, 1);
+    }
+
+    return ret;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_chrysler_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_check(context);
+    SubGhzProtocolDecoderChrysler* instance = context;
+
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_deserialize(&instance->generic, flipper_format);
+
+    if(ret == SubGhzProtocolStatusOk) {
+        chrysler_rebuild_raw_data(instance);
+
+        uint32_t extra = 0;
+        if(flipper_format_read_uint32(flipper_format, "Extra", &extra, 1)) {
+            instance->raw_data[8] = (extra >> 8) & 0xFF;
+            instance->raw_data[9] = extra & 0xFF;
+        }
+    }
+
+    return ret;
+}
+
+static const char* chrysler_button_name(uint8_t btn) {
+    switch(btn) {
+    case 0x01:
+        return "Lock";
+    case 0x02:
+        return "Unlock";
+    default:
+        return "Unknown";
+    }
+}
+
+void subghz_protocol_decoder_chrysler_get_string(void* context, FuriString* output) {
+    furi_check(context);
+    SubGhzProtocolDecoderChrysler* instance = context;
+
+    uint8_t* d = instance->raw_data;
+    uint8_t cnt_raw = (d[0] >> 4) & 0xF;
+    uint8_t cnt = chrysler_reverse_nibble(cnt_raw);
+    uint8_t dev_id = d[0] & 0xF;
+    uint8_t msb = (d[0] >> 7) & 1;
+
+    uint8_t b1_xor_b6 = d[1] ^ d[6];
+    uint8_t btn = instance->generic.btn;
+    if(msb == 0) {
+        if(b1_xor_b6 == 0x04)
+            btn = 0x01;
+        else if(b1_xor_b6 == 0x08)
+            btn = 0x02;
+    }
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Raw:%02X%02X%02X%02X%02X %02X%02X%02X%02X%02X\r\n"
+        "Cnt:%X Btn:%s Dev:%X\r\n"
+        "Sn:%08lX\r\n",
+        instance->generic.protocol_name,
+        (int)instance->generic.data_count_bit,
+        d[0], d[1], d[2], d[3], d[4],
+        d[5], d[6], d[7], d[8], d[9],
+        (unsigned)cnt,
+        chrysler_button_name(btn),
+        (unsigned)dev_id,
+        (unsigned long)instance->generic.serial);
+}

lib/subghz/protocols/chrysler.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "base.h"
+#include <flipper_format/flipper_format.h>
+
+#define CHRYSLER_PROTOCOL_NAME "Chrysler"
+
+typedef struct SubGhzProtocolDecoderChrysler SubGhzProtocolDecoderChrysler;
+typedef struct SubGhzProtocolEncoderChrysler SubGhzProtocolEncoderChrysler;
+
+extern const SubGhzProtocol subghz_protocol_chrysler;
+
+void* subghz_protocol_decoder_chrysler_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_decoder_chrysler_free(void* context);
+void subghz_protocol_decoder_chrysler_reset(void* context);
+void subghz_protocol_decoder_chrysler_feed(void* context, bool level, uint32_t duration);
+uint8_t subghz_protocol_decoder_chrysler_get_hash_data(void* context);
+SubGhzProtocolStatus subghz_protocol_decoder_chrysler_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_chrysler_deserialize(void* context, FlipperFormat* flipper_format);
+void subghz_protocol_decoder_chrysler_get_string(void* context, FuriString* output);
+
+void* subghz_protocol_encoder_chrysler_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_encoder_chrysler_free(void* context);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_chrysler_deserialize(void* context, FlipperFormat* flipper_format);
+void subghz_protocol_encoder_chrysler_stop(void* context);
+LevelDuration subghz_protocol_encoder_chrysler_yield(void* context);

lib/subghz/protocols/fiat_marelli.c

@@ -41,6 +41,17 @@
 #define FIAT_MARELLI_RETX_SYNC_MAX      2800
 #define FIAT_MARELLI_TE_TYPE_AB_BOUNDARY 180
 
+static uint8_t fiat_marelli_crc8(const uint8_t* data, size_t len) {
+    uint8_t crc = 0x03;
+    for(size_t i = 0; i < len; i++) {
+        crc ^= data[i];
+        for(uint8_t b = 0; b < 8; b++) {
+            crc = (crc & 0x80) ? ((crc << 1) ^ 0x01) : (crc << 1);
+        }
+    }
+    return crc;
+}
+
 static const SubGhzBlockConst subghz_protocol_fiat_marelli_const = {
     .te_short = 260,
     .te_long = 520,
@@ -235,6 +246,10 @@ static void fiat_marelli_encoder_rebuild_raw_data(SubGhzProtocolEncoderFiatMarel
     }
 
     instance->bit_count = instance->generic.data_count_bit;
+
+    if(instance->bit_count >= 104) {
+        instance->raw_data[12] = fiat_marelli_crc8(instance->raw_data, 12);
+    }
 }
 
 SubGhzProtocolStatus
@@ -518,16 +533,24 @@ void subghz_protocol_decoder_fiat_marelli_feed(void* context, bool level, uint32
         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;
+            bool crc_ok = true;
+            if(instance->bit_count >= 104) {
+                uint8_t calc = fiat_marelli_crc8(instance->raw_data, 12);
+                crc_ok = (calc == instance->raw_data[12]);
+            }
 
-            if(instance->base.callback) {
-                instance->base.callback(&instance->base, instance->base.context);
+            if(crc_ok) {
+                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 = FiatMarelliDecoderStepReset;
@@ -628,9 +651,15 @@ void subghz_protocol_decoder_fiat_marelli_get_string(void* context, FuriString*
     uint8_t scramble = (instance->raw_data[7] >> 1) & 0x3;
     uint8_t fixed    =  instance->raw_data[7] & 0x1;
 
+    const char* crc_str = "";
+    if(instance->bit_count >= 104) {
+        uint8_t calc = fiat_marelli_crc8(instance->raw_data, 12);
+        crc_str = (calc == instance->raw_data[12]) ? " CRC:OK" : " CRC:FAIL";
+    }
+
     furi_string_cat_printf(
         output,
-        "%s %dbit\r\n"
+        "%s %dbit%s\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"
@@ -638,6 +667,7 @@ void subghz_protocol_decoder_fiat_marelli_get_string(void* context, FuriString*
         "Tp:%s\r\n",
         instance->generic.protocol_name,
         (int)instance->bit_count,
+        crc_str,
         instance->raw_data[8], instance->raw_data[9],
         instance->raw_data[10], instance->raw_data[11],
         instance->raw_data[12],

lib/subghz/protocols/ford_v1.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <furi.h>
+#include <lib/subghz/protocols/base.h>
+#include <lib/subghz/types.h>
+#include <lib/subghz/blocks/const.h>
+#include <lib/subghz/blocks/decoder.h>
+#include <lib/subghz/blocks/encoder.h>
+#include <lib/subghz/blocks/generic.h>
+#include <lib/subghz/blocks/math.h>
+#include <lib/toolbox/manchester_decoder.h>
+#include <flipper_format/flipper_format.h>
+
+#define FORD_PROTOCOL_V1_NAME "Ford V1"
+
+typedef struct SubGhzProtocolDecoderFordV1 SubGhzProtocolDecoderFordV1;
+
+extern const SubGhzProtocol ford_protocol_v1;
+
+void* subghz_protocol_decoder_ford_v1_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_decoder_ford_v1_free(void* context);
+void subghz_protocol_decoder_ford_v1_reset(void* context);
+void subghz_protocol_decoder_ford_v1_feed(void* context, bool level, uint32_t duration);
+uint8_t subghz_protocol_decoder_ford_v1_get_hash_data(void* context);
+SubGhzProtocolStatus subghz_protocol_decoder_ford_v1_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_ford_v1_deserialize(void* context, FlipperFormat* flipper_format);
+void subghz_protocol_decoder_ford_v1_get_string(void* context, FuriString* output);
+
+void* subghz_protocol_encoder_ford_v1_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_encoder_ford_v1_free(void* context);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_ford_v1_deserialize(void* context, FlipperFormat* flipper_format);
+void subghz_protocol_encoder_ford_v1_stop(void* context);
+LevelDuration subghz_protocol_encoder_ford_v1_yield(void* context);
+extern const SubGhzProtocolEncoder subghz_protocol_ford_v1_encoder;

lib/subghz/protocols/honda_static.bak

@@ -0,0 +1,796 @@
+#include "honda_static.h"
+
+#define HONDA_STATIC_BIT_COUNT                  64
+#define HONDA_STATIC_MIN_SYMBOLS                36
+#define HONDA_STATIC_SHORT_BASE_US              28
+#define HONDA_STATIC_SHORT_SPAN_US              70
+#define HONDA_STATIC_LONG_BASE_US               61
+#define HONDA_STATIC_LONG_SPAN_US               130
+#define HONDA_STATIC_SYNC_TIME_US               700
+#define HONDA_STATIC_ELEMENT_TIME_US            63
+#define HONDA_STATIC_UPLOAD_CAPACITY            512
+#define HONDA_STATIC_SYMBOL_CAPACITY            512
+#define HONDA_STATIC_PREAMBLE_ALTERNATING_COUNT 160
+#define HONDA_STATIC_PREAMBLE_MAX_TRANSITIONS   19
+
+static const uint8_t honda_static_encoder_button_map[4] = {0x02, 0x04, 0x08, 0x05};
+static const char* const honda_static_button_names[9] = {
+    "LOCK",
+    "UNLOCK",
+    "UNKNOWN",
+    "TRUNK",
+    "REMOTE START",
+    "UNKNOWN",
+    "UNKNOWN",
+    "PANIC",
+    "LOCK x2",
+};
+
+typedef struct {
+    uint8_t button;
+    uint8_t _reserved_01[3];
+    uint32_t serial;
+    uint32_t counter;
+    uint8_t checksum;
+    uint8_t _reserved_0d[3];
+} HondaStaticFields;
+
+struct SubGhzProtocolDecoderHondaStatic {
+    SubGhzProtocolDecoderBase base;
+    uint32_t _reserved_0c;
+
+    SubGhzBlockDecoder decoder;
+    uint32_t _reserved_20;
+
+    SubGhzBlockGeneric generic;
+
+    uint16_t packet_bit_count;
+    uint8_t _reserved_5a;
+    uint8_t _reserved_5b;
+
+    uint8_t symbols[HONDA_STATIC_SYMBOL_CAPACITY];
+    uint16_t symbols_count;
+    HondaStaticFields decoded;
+    uint8_t decoded_valid;
+};
+
+struct SubGhzProtocolEncoderHondaStatic {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+
+    HondaStaticFields decoded;
+    uint8_t tx_button;
+    uint8_t _reserved_69[3];
+};
+
+static uint64_t honda_static_bytes_to_u64_be(const uint8_t bytes[8]) {
+    uint64_t value = 0;
+    for(size_t i = 0; i < 8; i++) {
+        value = (value << 8U) | bytes[i];
+    }
+    return value;
+}
+
+static void honda_static_u64_to_bytes_be(uint64_t value, uint8_t bytes[8]) {
+    for(size_t i = 0; i < 8; i++) {
+        bytes[7U - i] = (uint8_t)(value & 0xFFU);
+        value >>= 8U;
+    }
+}
+
+static uint8_t honda_static_get_bits(const uint8_t* data, uint8_t start, uint8_t count) {
+    uint32_t value = 0;
+
+    for(uint8_t i = 0; i < count; i++) {
+        const uint8_t bit_index = start + i;
+        const uint8_t byte = data[bit_index >> 3U];
+        const uint8_t shift = (uint8_t)(~bit_index) & 0x07U;
+        value = (value << 1U) | ((byte >> shift) & 1U);
+    }
+
+    return (uint8_t)value;
+}
+
+static uint32_t honda_static_get_bits_u32(const uint8_t* data, uint8_t start, uint8_t count) {
+    uint32_t value = 0;
+
+    for(uint8_t i = 0; i < count; i++) {
+        const uint8_t bit_index = start + i;
+        const uint8_t byte = data[bit_index >> 3U];
+        const uint8_t shift = (uint8_t)(~bit_index) & 0x07U;
+        value = (value << 1U) | ((byte >> shift) & 1U);
+    }
+
+    return value;
+}
+
+static void honda_static_set_bits(uint8_t* data, uint8_t start, uint8_t count, uint32_t value) {
+    for(uint8_t i = 0; i < count; i++) {
+        const uint8_t bit_index = start + i;
+        const uint8_t byte_index = bit_index >> 3U;
+        const uint8_t shift = ((uint8_t)~bit_index) & 0x07U;
+        const uint8_t mask = (uint8_t)(1U << shift);
+        const bool bit = ((value >> (count - 1U - i)) & 1U) != 0U;
+
+        if(bit) {
+            data[byte_index] |= mask;
+        } else {
+            data[byte_index] &= (uint8_t)~mask;
+        }
+    }
+}
+
+static uint8_t honda_static_level_u8(bool level) {
+    return level ? 1U : 0U;
+}
+
+static uint8_t honda_static_sym_u8(uint8_t stored) {
+    return stored ? 1U : 0U;
+}
+
+static uint8_t honda_static_reverse_bits8(uint8_t value) {
+    value = (uint8_t)(((value >> 4U) | (value << 4U)) & 0xFFU);
+    value = (uint8_t)(((value & 0x33U) << 2U) | ((value >> 2U) & 0x33U));
+    value = (uint8_t)(((value & 0x55U) << 1U) | ((value >> 1U) & 0x55U));
+    return value;
+}
+
+static bool honda_static_is_valid_button(uint8_t button) {
+    if(button > 9U) {
+        return false;
+    }
+
+    return ((0x336U >> button) & 1U) != 0U;
+}
+
+static bool honda_static_is_valid_serial(uint32_t serial) {
+    return (serial != 0U) && (serial != 0x0FFFFFFFU);
+}
+
+static uint8_t honda_static_encoder_remap_button(uint8_t button) {
+    if(button < 2U) {
+        return 1U;
+    }
+    button -= 2U;
+    if(button <= 3U) {
+        return honda_static_encoder_button_map[button];
+    }
+
+    return 1U;
+}
+
+static const char* honda_static_button_name(uint8_t button) {
+    if((button >= 1U) && (button <= COUNT_OF(honda_static_button_names))) {
+        return honda_static_button_names[button - 1U];
+    }
+
+    return "Unknown";
+}
+
+static uint8_t honda_static_compact_bytes_checksum(const uint8_t compact[8]) {
+    const uint8_t canonical[7] = {
+        (uint8_t)((compact[0] << 4U) | (compact[1] >> 4U)),
+        (uint8_t)((compact[1] << 4U) | (compact[2] >> 4U)),
+        (uint8_t)((compact[2] << 4U) | (compact[3] >> 4U)),
+        (uint8_t)((compact[3] << 4U) | (compact[4] >> 4U)),
+        compact[5],
+        compact[6],
+        compact[7],
+    };
+
+    uint8_t checksum = 0U;
+    for(size_t i = 0; i < COUNT_OF(canonical); i++) {
+        checksum ^= canonical[i];
+    }
+
+    return checksum;
+}
+
+static void honda_static_unpack_compact(uint64_t key, HondaStaticFields* fields) {
+    uint8_t compact[8];
+    honda_static_u64_to_bytes_be(key, compact);
+
+    memset(fields, 0, sizeof(*fields));
+    fields->button = compact[0] & 0x0FU;
+    fields->serial = ((uint32_t)compact[1] << 20U) | ((uint32_t)compact[2] << 12U) |
+                     ((uint32_t)compact[3] << 4U) | ((uint32_t)compact[4] >> 4U);
+    fields->counter = ((uint32_t)compact[5] << 16U) | ((uint32_t)compact[6] << 8U) |
+                      (uint32_t)compact[7];
+    fields->checksum = honda_static_compact_bytes_checksum(compact);
+}
+
+static uint64_t honda_static_pack_compact(const HondaStaticFields* fields) {
+    uint8_t compact[8];
+
+    compact[0] = fields->button & 0x0FU;
+    compact[1] = (uint8_t)(fields->serial >> 20U);
+    compact[2] = (uint8_t)(fields->serial >> 12U);
+    compact[3] = (uint8_t)(fields->serial >> 4U);
+    compact[4] = (uint8_t)(fields->serial << 4U);
+    compact[5] = (uint8_t)(fields->counter >> 16U);
+    compact[6] = (uint8_t)(fields->counter >> 8U);
+    compact[7] = (uint8_t)fields->counter;
+
+    return honda_static_bytes_to_u64_be(compact);
+}
+
+static void honda_static_build_packet_bytes(const HondaStaticFields* fields, uint8_t packet[8]) {
+    memset(packet, 0, 8);
+
+    honda_static_set_bits(packet, 0, 4, fields->button & 0x0FU);
+    honda_static_set_bits(packet, 4, 28, fields->serial);
+    honda_static_set_bits(packet, 32, 24, fields->counter);
+
+    uint8_t checksum = 0U;
+    for(size_t i = 0; i < 7; i++) {
+        checksum ^= packet[i];
+    }
+
+    honda_static_set_bits(packet, 56, 8, checksum);
+}
+
+static bool
+    honda_static_validate_forward_packet(const uint8_t packet[9], HondaStaticFields* fields) {
+    const uint8_t button = honda_static_get_bits(packet, 0, 4);
+    const uint32_t serial = honda_static_get_bits_u32(packet, 4, 28);
+    const uint32_t counter = honda_static_get_bits_u32(packet, 32, 24);
+    const uint8_t checksum = honda_static_get_bits(packet, 56, 8);
+
+    uint8_t checksum_calc = 0U;
+    for(size_t i = 0; i < 7; i++) {
+        checksum_calc ^= packet[i];
+    }
+
+    if(checksum != checksum_calc) {
+        return false;
+    }
+    if(!honda_static_is_valid_button(button)) {
+        return false;
+    }
+    if(!honda_static_is_valid_serial(serial)) {
+        return false;
+    }
+
+    fields->button = button;
+    fields->serial = serial;
+    fields->counter = counter;
+    fields->checksum = checksum;
+
+    return true;
+}
+
+static bool
+    honda_static_validate_reverse_packet(const uint8_t packet[9], HondaStaticFields* fields) {
+    uint8_t reversed[9];
+    for(size_t i = 0; i < COUNT_OF(reversed); i++) {
+        reversed[i] = honda_static_reverse_bits8(packet[i]);
+    }
+
+    const uint8_t button = honda_static_get_bits(reversed, 0, 4);
+    const uint32_t serial = honda_static_get_bits_u32(reversed, 4, 28);
+    const uint32_t counter = honda_static_get_bits_u32(reversed, 32, 24);
+
+    uint8_t checksum = 0U;
+    for(size_t i = 0; i < 7; i++) {
+        checksum ^= reversed[i];
+    }
+
+    if(!honda_static_is_valid_button(button)) {
+        return false;
+    }
+    if(!honda_static_is_valid_serial(serial)) {
+        return false;
+    }
+
+    fields->button = button;
+    fields->serial = serial;
+    fields->counter = counter;
+    fields->checksum = checksum;
+
+    return true;
+}
+
+static bool honda_static_manchester_pack_64(
+    const uint8_t* symbols,
+    uint16_t count,
+    uint16_t start_pos,
+    bool inverted,
+    uint8_t packet[9],
+    uint16_t* out_bit_count) {
+    memset(packet, 0, 9);
+
+    uint16_t pos = start_pos;
+    uint16_t bit_count = 0U;
+
+    while((uint16_t)(pos + 1U) < count) {
+        if(bit_count >= HONDA_STATIC_BIT_COUNT) {
+            break;
+        }
+
+        const uint8_t a = honda_static_sym_u8(symbols[pos]);
+        const uint8_t b = honda_static_sym_u8(symbols[pos + 1U]);
+
+        if(a == b) {
+            pos++;
+            continue;
+        }
+
+        bool bit = false;
+        if(inverted) {
+            bit = (a == 0U) && (b == 1U);
+        } else {
+            bit = (a == 1U) && (b == 0U);
+        }
+
+        if(bit) {
+            packet[bit_count >> 3U] |= (uint8_t)(1U << (((uint8_t)~bit_count) & 0x07U));
+        }
+
+        bit_count++;
+        pos += 2U;
+    }
+
+    if(out_bit_count) {
+        *out_bit_count = bit_count;
+    }
+
+    return bit_count >= HONDA_STATIC_BIT_COUNT;
+}
+
+static bool honda_static_parse_symbols(SubGhzProtocolDecoderHondaStatic* instance, bool inverted) {
+    const uint16_t count = instance->symbols_count;
+    const uint8_t* symbols = instance->symbols;
+
+    uint16_t index = 1U;
+    uint16_t transitions = 0U;
+
+    while(index < count) {
+        if(honda_static_sym_u8(symbols[index]) != honda_static_sym_u8(symbols[index - 1U])) {
+            transitions++;
+        } else {
+            if(transitions > HONDA_STATIC_PREAMBLE_MAX_TRANSITIONS) {
+                break;
+            }
+            transitions = 0U;
+        }
+        index++;
+    }
+
+    if(index >= count) {
+        return false;
+    }
+
+    while(((uint16_t)(index + 1U) < count) &&
+          (honda_static_sym_u8(symbols[index]) == honda_static_sym_u8(symbols[index + 1U]))) {
+        index++;
+    }
+
+    const uint16_t data_start = index;
+
+    uint8_t packet[9] = {0};
+    uint16_t bit_count = 0U;
+
+    if(!honda_static_manchester_pack_64(symbols, count, data_start, inverted, packet, &bit_count)) {
+        return false;
+    }
+
+    if(honda_static_validate_forward_packet(packet, &instance->decoded)) {
+        instance->decoded_valid = 1U;
+        return true;
+    }
+
+    if(inverted) {
+        return false;
+    }
+
+    if(honda_static_validate_reverse_packet(packet, &instance->decoded)) {
+        instance->decoded_valid = 1U;
+        return true;
+    }
+
+    return false;
+}
+
+static void honda_static_decoder_commit(SubGhzProtocolDecoderHondaStatic* instance) {
+    instance->packet_bit_count = HONDA_STATIC_BIT_COUNT;
+    instance->generic.data_count_bit = HONDA_STATIC_BIT_COUNT;
+    instance->generic.data = honda_static_pack_compact(&instance->decoded);
+    instance->generic.serial = instance->decoded.serial;
+    instance->generic.cnt = instance->decoded.counter;
+    instance->generic.btn = instance->decoded.button;
+
+    if(instance->base.callback) {
+        instance->base.callback(&instance->base, instance->base.context);
+    }
+}
+
+static void honda_static_build_upload(SubGhzProtocolEncoderHondaStatic* instance) {
+    uint8_t packet[8];
+    honda_static_build_packet_bytes(&instance->decoded, packet);
+
+    size_t index = 0U;
+    instance->encoder.upload[index++] = level_duration_make(true, HONDA_STATIC_SYNC_TIME_US);
+
+    for(size_t i = 0; i < HONDA_STATIC_PREAMBLE_ALTERNATING_COUNT; i++) {
+        instance->encoder.upload[index++] =
+            level_duration_make((i & 1U) != 0U, HONDA_STATIC_ELEMENT_TIME_US);
+    }
+
+    for(uint8_t bit = 0U; bit < HONDA_STATIC_BIT_COUNT; bit++) {
+        const bool value = ((packet[bit >> 3U] >> (((uint8_t)~bit) & 0x07U)) & 1U) != 0U;
+        instance->encoder.upload[index++] =
+            level_duration_make(!value, HONDA_STATIC_ELEMENT_TIME_US);
+        instance->encoder.upload[index++] =
+            level_duration_make(value, HONDA_STATIC_ELEMENT_TIME_US);
+    }
+
+    const bool last_bit = (packet[7] & 1U) != 0U;
+    instance->encoder.upload[index++] = level_duration_make(!last_bit, HONDA_STATIC_SYNC_TIME_US);
+
+    instance->encoder.front = 0U;
+    instance->encoder.size_upload = index;
+}
+
+static bool honda_static_read_hex_u64(FlipperFormat* ff, uint64_t* out_key) {
+    FuriString* tmp = furi_string_alloc();
+    if(!tmp) return false;
+    bool ok = false;
+    do {
+        if(!flipper_format_rewind(ff) || !flipper_format_read_string(ff, "Key", tmp)) break;
+
+        const char* key_str = furi_string_get_cstr(tmp);
+        uint64_t key = 0;
+        size_t hex_pos = 0;
+        for(size_t i = 0; key_str[i] && hex_pos < 16; i++) {
+            char c = key_str[i];
+            if(c == ' ') continue;
+            uint8_t nibble;
+            if(c >= '0' && c <= '9')
+                nibble = c - '0';
+            else if(c >= 'A' && c <= 'F')
+                nibble = c - 'A' + 10;
+            else if(c >= 'a' && c <= 'f')
+                nibble = c - 'a' + 10;
+            else
+                break;
+            key = (key << 4) | nibble;
+            hex_pos++;
+        }
+        if(hex_pos != 16) break;
+        *out_key = key;
+        ok = true;
+    } while(false);
+    furi_string_free(tmp);
+    return ok;
+}
+
+const SubGhzProtocolDecoder subghz_protocol_honda_static_decoder = {
+    .alloc = subghz_protocol_decoder_honda_static_alloc,
+    .free = subghz_protocol_decoder_honda_static_free,
+    .feed = subghz_protocol_decoder_honda_static_feed,
+    .reset = subghz_protocol_decoder_honda_static_reset,
+    .get_hash_data = subghz_protocol_decoder_honda_static_get_hash_data,
+    .serialize = subghz_protocol_decoder_honda_static_serialize,
+    .deserialize = subghz_protocol_decoder_honda_static_deserialize,
+    .get_string = subghz_protocol_decoder_honda_static_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_honda_static_encoder = {
+    .alloc = subghz_protocol_encoder_honda_static_alloc,
+    .free = subghz_protocol_encoder_honda_static_free,
+    .deserialize = subghz_protocol_encoder_honda_static_deserialize,
+    .stop = subghz_protocol_encoder_honda_static_stop,
+    .yield = subghz_protocol_encoder_honda_static_yield,
+};
+
+const SubGhzProtocol honda_static_protocol = {
+    .name = HONDA_STATIC_PROTOCOL_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_315 | SubGhzProtocolFlag_433 |
+            SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Load |
+            SubGhzProtocolFlag_Send,
+    .decoder = &subghz_protocol_honda_static_decoder,
+    .encoder = &subghz_protocol_honda_static_encoder,
+};
+
+void* subghz_protocol_encoder_honda_static_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+
+    SubGhzProtocolEncoderHondaStatic* instance = malloc(sizeof(SubGhzProtocolEncoderHondaStatic));
+    furi_check(instance);
+    memset(instance, 0, sizeof(*instance));
+
+    instance->base.protocol = &honda_static_protocol;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->encoder.repeat = 3U;
+    instance->encoder.upload = malloc(HONDA_STATIC_UPLOAD_CAPACITY * sizeof(LevelDuration));
+    furi_check(instance->encoder.upload);
+
+    return instance;
+}
+
+void subghz_protocol_encoder_honda_static_free(void* context) {
+    furi_check(context);
+
+    SubGhzProtocolEncoderHondaStatic* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_honda_static_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_check(context);
+
+    SubGhzProtocolEncoderHondaStatic* instance = context;
+    SubGhzProtocolStatus status = SubGhzProtocolStatusError;
+
+    instance->encoder.is_running = false;
+    instance->encoder.front = 0U;
+
+    do {
+        FuriString* pstr = furi_string_alloc();
+        if(!pstr) break;
+
+        flipper_format_rewind(flipper_format);
+        if(!flipper_format_read_string(flipper_format, "Protocol", pstr)) {
+            furi_string_free(pstr);
+            break;
+        }
+        if(!furi_string_equal(pstr, instance->base.protocol->name)) {
+            furi_string_free(pstr);
+            break;
+        }
+        furi_string_free(pstr);
+
+        uint64_t key = 0;
+        if(!honda_static_read_hex_u64(flipper_format, &key)) {
+            break;
+        }
+
+        honda_static_unpack_compact(key, &instance->decoded);
+
+        uint32_t serial = instance->decoded.serial;
+        flipper_format_rewind(flipper_format);
+        if(flipper_format_read_uint32(flipper_format, "Serial", &serial, 1)) {
+            instance->decoded.serial = serial;
+        }
+
+        uint32_t btn_u32 = 0;
+        flipper_format_rewind(flipper_format);
+        if(flipper_format_read_uint32(flipper_format, "Btn", &btn_u32, 1)) {
+            uint8_t b = (uint8_t)btn_u32;
+            if(honda_static_is_valid_button(b)) {
+                instance->decoded.button = b;
+            } else if(b >= 2U && b <= 5U) {
+                instance->decoded.button = honda_static_encoder_remap_button(b);
+            }
+        }
+
+        uint32_t cnt = instance->decoded.counter & 0x00FFFFFFU;
+        flipper_format_rewind(flipper_format);
+        if(flipper_format_read_uint32(flipper_format, "Cnt", &cnt, 1)) {
+            instance->decoded.counter = cnt & 0x00FFFFFFU;
+        }
+
+        instance->generic.serial = instance->decoded.serial;
+        instance->generic.cnt = instance->decoded.counter;
+        instance->generic.btn = instance->decoded.button;
+        instance->generic.data_count_bit = HONDA_STATIC_BIT_COUNT;
+        instance->generic.data = honda_static_pack_compact(&instance->decoded);
+
+        uint8_t key_data[8];
+        honda_static_u64_to_bytes_be(instance->generic.data, key_data);
+
+        flipper_format_rewind(flipper_format);
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(key_data))) {
+            status = SubGhzProtocolStatusErrorParserKey;
+            break;
+        }
+
+        flipper_format_rewind(flipper_format);
+        if(!flipper_format_read_uint32(
+               flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1)) {
+            instance->encoder.repeat = 3U;
+        }
+
+        honda_static_build_upload(instance);
+        instance->encoder.is_running = true;
+        status = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return status;
+}
+
+void subghz_protocol_encoder_honda_static_stop(void* context) {
+    furi_check(context);
+
+    SubGhzProtocolEncoderHondaStatic* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_honda_static_yield(void* context) {
+    furi_check(context);
+
+    SubGhzProtocolEncoderHondaStatic* instance = context;
+    if((instance->encoder.repeat == 0U) || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    const LevelDuration current = instance->encoder.upload[instance->encoder.front];
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        instance->encoder.repeat--;
+        instance->encoder.front = 0U;
+    }
+
+    return current;
+}
+
+void* subghz_protocol_decoder_honda_static_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+
+    SubGhzProtocolDecoderHondaStatic* instance = malloc(sizeof(SubGhzProtocolDecoderHondaStatic));
+    furi_check(instance);
+    memset(instance, 0, sizeof(*instance));
+
+    instance->base.protocol = &honda_static_protocol;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    return instance;
+}
+
+void subghz_protocol_decoder_honda_static_free(void* context) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderHondaStatic* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_honda_static_reset(void* context) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderHondaStatic* instance = context;
+    instance->symbols_count = 0U;
+    instance->decoded_valid = 0U;
+}
+
+void subghz_protocol_decoder_honda_static_feed(void* context, bool level, uint32_t duration) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderHondaStatic* instance = context;
+
+    const uint8_t sym = honda_static_level_u8(level);
+
+    if((duration >= HONDA_STATIC_SHORT_BASE_US) &&
+       ((duration - HONDA_STATIC_SHORT_BASE_US) <= HONDA_STATIC_SHORT_SPAN_US)) {
+        if(instance->symbols_count < HONDA_STATIC_SYMBOL_CAPACITY) {
+            instance->symbols[instance->symbols_count++] = sym;
+        }
+        return;
+    }
+
+    if((duration >= HONDA_STATIC_LONG_BASE_US) &&
+       ((duration - HONDA_STATIC_LONG_BASE_US) <= HONDA_STATIC_LONG_SPAN_US)) {
+        if((uint16_t)(instance->symbols_count + 2U) <= HONDA_STATIC_SYMBOL_CAPACITY) {
+            instance->symbols[instance->symbols_count++] = sym;
+            instance->symbols[instance->symbols_count++] = sym;
+        }
+        return;
+    }
+
+    const uint16_t sc = instance->symbols_count;
+
+    if(sc >= HONDA_STATIC_MIN_SYMBOLS) {
+        if(honda_static_parse_symbols(instance, true) ||
+           honda_static_parse_symbols(instance, false)) {
+            honda_static_decoder_commit(instance);
+        }
+    }
+
+    instance->symbols_count = 0U;
+}
+
+uint8_t subghz_protocol_decoder_honda_static_get_hash_data(void* context) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderHondaStatic* instance = context;
+    const uint64_t data = instance->generic.data;
+
+    return (uint8_t)(data ^ (data >> 8U) ^ (data >> 16U) ^ (data >> 24U) ^ (data >> 32U) ^
+                     (data >> 40U) ^ (data >> 48U) ^ (data >> 56U));
+}
+
+void subghz_protocol_decoder_honda_static_get_string(void* context, FuriString* output) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderHondaStatic* instance = context;
+    if(!instance->decoded_valid && (instance->generic.data != 0ULL)) {
+        honda_static_unpack_compact(instance->generic.data, &instance->decoded);
+        instance->decoded_valid = 1U;
+    }
+
+    furi_string_cat_printf(
+        output,
+        "%s %ubit\r\n"
+        "Key:%016llX\r\n",
+        instance->generic.protocol_name,
+        instance->packet_bit_count ? instance->packet_bit_count : HONDA_STATIC_BIT_COUNT,
+        (unsigned long long)instance->generic.data);
+
+    furi_string_cat_printf(
+        output,
+        "Btn:%s (0x%X)\r\n"
+        "Ser:%07lX\r\n"
+        "Cnt:%06lX Chk:%02X\r\n",
+        honda_static_button_name(instance->decoded.button),
+        instance->decoded.button,
+        (unsigned long)instance->decoded.serial,
+        (unsigned long)instance->decoded.counter,
+        instance->decoded.checksum);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_honda_static_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderHondaStatic* instance = context;
+    instance->generic.data_count_bit = HONDA_STATIC_BIT_COUNT;
+
+    SubGhzProtocolStatus ret =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+
+    if(ret == SubGhzProtocolStatusOk) {
+        flipper_format_write_uint32(flipper_format, "Serial", &instance->decoded.serial, 1);
+
+        uint32_t temp = instance->decoded.button;
+        flipper_format_write_uint32(flipper_format, "Btn", &temp, 1);
+
+        flipper_format_write_uint32(flipper_format, "Cnt", &instance->decoded.counter, 1);
+
+        temp = instance->decoded.checksum;
+        flipper_format_write_uint32(flipper_format, "Checksum", &temp, 1);
+    }
+
+    return ret;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_honda_static_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderHondaStatic* instance = context;
+    SubGhzProtocolStatus status = subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, HONDA_STATIC_BIT_COUNT);
+    if(status != SubGhzProtocolStatusOk) {
+        return status;
+    }
+
+    instance->packet_bit_count = HONDA_STATIC_BIT_COUNT;
+    honda_static_unpack_compact(instance->generic.data, &instance->decoded);
+    instance->decoded_valid = 1U;
+
+    flipper_format_rewind(flipper_format);
+    uint32_t s = 0, b = 0, c = 0, k = 0;
+    if(flipper_format_read_uint32(flipper_format, "Serial", &s, 1)) {
+        instance->decoded.serial = s;
+    }
+    if(flipper_format_read_uint32(flipper_format, "Btn", &b, 1)) {
+        instance->decoded.button = (uint8_t)b;
+    }
+    if(flipper_format_read_uint32(flipper_format, "Cnt", &c, 1)) {
+        instance->decoded.counter = c & 0x00FFFFFFU;
+    }
+    if(flipper_format_read_uint32(flipper_format, "Checksum", &k, 1)) {
+        instance->decoded.checksum = (uint8_t)k;
+    }
+
+    instance->generic.serial = instance->decoded.serial;
+    instance->generic.cnt = instance->decoded.counter;
+    instance->generic.btn = instance->decoded.button;
+
+    return status;
+}

lib/subghz/protocols/honda_static.c

@@ -0,0 +1,811 @@
+#include "honda_static.h"
+
+#define HONDA_STATIC_BIT_COUNT       64
+#define HONDA_STATIC_MIN_SYMBOLS     36
+#define HONDA_STATIC_SHORT_BASE_US   28
+#define HONDA_STATIC_SHORT_SPAN_US   70
+#define HONDA_STATIC_LONG_BASE_US    61
+#define HONDA_STATIC_LONG_SPAN_US    130
+#define HONDA_STATIC_SYNC_TIME_US    700
+#define HONDA_STATIC_ELEMENT_TIME_US 63
+#define HONDA_STATIC_UPLOAD_CAPACITY \
+    (1U + HONDA_STATIC_PREAMBLE_ALTERNATING_COUNT + (2U * HONDA_STATIC_BIT_COUNT) + 1U)
+#define HONDA_STATIC_SYMBOL_CAPACITY            512
+#define HONDA_STATIC_PREAMBLE_ALTERNATING_COUNT 160
+#define HONDA_STATIC_PREAMBLE_MAX_TRANSITIONS   19
+#define HONDA_STATIC_SYMBOL_BYTE_COUNT          ((HONDA_STATIC_SYMBOL_CAPACITY + 7U) / 8U)
+
+static const uint8_t honda_static_encoder_button_map[4] = {0x02, 0x04, 0x08, 0x05};
+static const char* const honda_static_button_names[9] = {
+    "Lock",
+    "Unlock",
+    "Unknown",
+    "Trunk",
+    "Remote Start",
+    "Unknown",
+    "Unknown",
+    "Panic",
+    "Lock x2",
+};
+
+typedef struct {
+    uint8_t button;
+    uint8_t _reserved_01[3];
+    uint32_t serial;
+    uint32_t counter;
+    uint8_t checksum;
+    uint8_t _reserved_0d[3];
+} HondaStaticFields;
+
+struct SubGhzProtocolDecoderHondaStatic {
+    SubGhzProtocolDecoderBase base;
+    SubGhzBlockGeneric generic;
+
+    uint8_t symbols[HONDA_STATIC_SYMBOL_BYTE_COUNT];
+    uint16_t symbols_count;
+};
+
+struct SubGhzProtocolEncoderHondaStatic {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+
+    HondaStaticFields decoded;
+    uint8_t tx_button;
+    uint8_t _reserved_69[3];
+};
+
+static void honda_static_decoder_commit(
+    SubGhzProtocolDecoderHondaStatic* instance,
+    const HondaStaticFields* decoded);
+
+static uint64_t honda_static_bytes_to_u64_be(const uint8_t bytes[8]) {
+    uint64_t value = 0;
+    for(size_t i = 0; i < 8; i++) {
+        value = (value << 8U) | bytes[i];
+    }
+    return value;
+}
+
+static void honda_static_u64_to_bytes_be(uint64_t value, uint8_t bytes[8]) {
+    for(size_t i = 0; i < 8; i++) {
+        bytes[7U - i] = (uint8_t)(value & 0xFFU);
+        value >>= 8U;
+    }
+}
+
+static uint8_t honda_static_get_bits(const uint8_t* data, uint8_t start, uint8_t count) {
+    uint32_t value = 0;
+
+    for(uint8_t i = 0; i < count; i++) {
+        const uint8_t bit_index = start + i;
+        const uint8_t byte = data[bit_index >> 3U];
+        const uint8_t shift = (uint8_t)(~bit_index) & 0x07U;
+        value = (value << 1U) | ((byte >> shift) & 1U);
+    }
+
+    return (uint8_t)value;
+}
+
+static uint32_t honda_static_get_bits_u32(const uint8_t* data, uint8_t start, uint8_t count) {
+    uint32_t value = 0;
+
+    for(uint8_t i = 0; i < count; i++) {
+        const uint8_t bit_index = start + i;
+        const uint8_t byte = data[bit_index >> 3U];
+        const uint8_t shift = (uint8_t)(~bit_index) & 0x07U;
+        value = (value << 1U) | ((byte >> shift) & 1U);
+    }
+
+    return value;
+}
+
+static void honda_static_set_bits(uint8_t* data, uint8_t start, uint8_t count, uint32_t value) {
+    for(uint8_t i = 0; i < count; i++) {
+        const uint8_t bit_index = start + i;
+        const uint8_t byte_index = bit_index >> 3U;
+        const uint8_t shift = ((uint8_t)~bit_index) & 0x07U;
+        const uint8_t mask = (uint8_t)(1U << shift);
+        const bool bit = ((value >> (count - 1U - i)) & 1U) != 0U;
+
+        if(bit) {
+            data[byte_index] |= mask;
+        } else {
+            data[byte_index] &= (uint8_t)~mask;
+        }
+    }
+}
+
+static uint8_t honda_static_level_u8(bool level) {
+    return level ? 1U : 0U;
+}
+
+static void honda_static_symbol_set(uint8_t* buf, uint16_t index, uint8_t v) {
+    const uint8_t byte_index = (uint8_t)(index >> 3U);
+    const uint8_t shift = (uint8_t)(~index) & 0x07U;
+    const uint8_t mask = (uint8_t)(1U << shift);
+    if(v) {
+        buf[byte_index] |= mask;
+    } else {
+        buf[byte_index] &= (uint8_t)~mask;
+    }
+}
+
+static uint8_t honda_static_symbol_get(const uint8_t* buf, uint16_t index) {
+    const uint8_t byte_index = (uint8_t)(index >> 3U);
+    const uint8_t shift = (uint8_t)(~index) & 0x07U;
+    return (uint8_t)((buf[byte_index] >> shift) & 1U);
+}
+
+static uint8_t honda_static_reverse_bits8(uint8_t value) {
+    value = (uint8_t)(((value >> 4U) | (value << 4U)) & 0xFFU);
+    value = (uint8_t)(((value & 0x33U) << 2U) | ((value >> 2U) & 0x33U));
+    value = (uint8_t)(((value & 0x55U) << 1U) | ((value >> 1U) & 0x55U));
+    return value;
+}
+
+static bool honda_static_is_valid_button(uint8_t button) {
+    if(button > 9U) {
+        return false;
+    }
+
+    return ((0x336U >> button) & 1U) != 0U;
+}
+
+static bool honda_static_is_valid_serial(uint32_t serial) {
+    return (serial != 0U) && (serial != 0x0FFFFFFFU);
+}
+
+static uint8_t honda_static_encoder_remap_button(uint8_t button) {
+    if(button < 2U) {
+        return 1U;
+    }
+    button -= 2U;
+    if(button <= 3U) {
+        return honda_static_encoder_button_map[button];
+    }
+
+    return 1U;
+}
+
+static const char* honda_static_button_name(uint8_t button) {
+    if((button >= 1U) && (button <= COUNT_OF(honda_static_button_names))) {
+        return honda_static_button_names[button - 1U];
+    }
+
+    return "Unknown";
+}
+
+static uint8_t honda_static_compact_bytes_checksum(const uint8_t compact[8]) {
+    const uint8_t canonical[7] = {
+        (uint8_t)((compact[0] << 4U) | (compact[1] >> 4U)),
+        (uint8_t)((compact[1] << 4U) | (compact[2] >> 4U)),
+        (uint8_t)((compact[2] << 4U) | (compact[3] >> 4U)),
+        (uint8_t)((compact[3] << 4U) | (compact[4] >> 4U)),
+        compact[5],
+        compact[6],
+        compact[7],
+    };
+
+    uint8_t checksum = 0U;
+    for(size_t i = 0; i < COUNT_OF(canonical); i++) {
+        checksum ^= canonical[i];
+    }
+
+    return checksum;
+}
+
+static void honda_static_unpack_compact(uint64_t key, HondaStaticFields* fields) {
+    uint8_t compact[8];
+    honda_static_u64_to_bytes_be(key, compact);
+
+    memset(fields, 0, sizeof(*fields));
+    fields->button = compact[0] & 0x0FU;
+    fields->serial = ((uint32_t)compact[1] << 20U) | ((uint32_t)compact[2] << 12U) |
+                     ((uint32_t)compact[3] << 4U) | ((uint32_t)compact[4] >> 4U);
+    fields->counter = ((uint32_t)compact[5] << 16U) | ((uint32_t)compact[6] << 8U) |
+                      (uint32_t)compact[7];
+    fields->checksum = honda_static_compact_bytes_checksum(compact);
+}
+
+static uint64_t honda_static_pack_compact(const HondaStaticFields* fields) {
+    uint8_t compact[8];
+
+    compact[0] = fields->button & 0x0FU;
+    compact[1] = (uint8_t)(fields->serial >> 20U);
+    compact[2] = (uint8_t)(fields->serial >> 12U);
+    compact[3] = (uint8_t)(fields->serial >> 4U);
+    compact[4] = (uint8_t)(fields->serial << 4U);
+    compact[5] = (uint8_t)(fields->counter >> 16U);
+    compact[6] = (uint8_t)(fields->counter >> 8U);
+    compact[7] = (uint8_t)fields->counter;
+
+    return honda_static_bytes_to_u64_be(compact);
+}
+
+static void honda_static_build_packet_bytes(const HondaStaticFields* fields, uint8_t packet[8]) {
+    memset(packet, 0, 8);
+
+    honda_static_set_bits(packet, 0, 4, fields->button & 0x0FU);
+    honda_static_set_bits(packet, 4, 28, fields->serial);
+    honda_static_set_bits(packet, 32, 24, fields->counter);
+
+    uint8_t checksum = 0U;
+    for(size_t i = 0; i < 7; i++) {
+        checksum ^= packet[i];
+    }
+
+    honda_static_set_bits(packet, 56, 8, checksum);
+}
+
+static bool
+    honda_static_validate_forward_packet(const uint8_t packet[9], HondaStaticFields* fields) {
+    const uint8_t button = honda_static_get_bits(packet, 0, 4);
+    const uint32_t serial = honda_static_get_bits_u32(packet, 4, 28);
+    const uint32_t counter = honda_static_get_bits_u32(packet, 32, 24);
+    const uint8_t checksum = honda_static_get_bits(packet, 56, 8);
+
+    uint8_t checksum_calc = 0U;
+    for(size_t i = 0; i < 7; i++) {
+        checksum_calc ^= packet[i];
+    }
+
+    if(checksum != checksum_calc) {
+        return false;
+    }
+    if(!honda_static_is_valid_button(button)) {
+        return false;
+    }
+    if(!honda_static_is_valid_serial(serial)) {
+        return false;
+    }
+
+    fields->button = button;
+    fields->serial = serial;
+    fields->counter = counter;
+    fields->checksum = checksum;
+
+    return true;
+}
+
+static bool
+    honda_static_validate_reverse_packet(const uint8_t packet[9], HondaStaticFields* fields) {
+    uint8_t reversed[9];
+    for(size_t i = 0; i < COUNT_OF(reversed); i++) {
+        reversed[i] = honda_static_reverse_bits8(packet[i]);
+    }
+
+    const uint8_t button = honda_static_get_bits(reversed, 0, 4);
+    const uint32_t serial = honda_static_get_bits_u32(reversed, 4, 28);
+    const uint32_t counter = honda_static_get_bits_u32(reversed, 32, 24);
+
+    uint8_t checksum = 0U;
+    for(size_t i = 0; i < 7; i++) {
+        checksum ^= reversed[i];
+    }
+
+    if(!honda_static_is_valid_button(button)) {
+        return false;
+    }
+    if(!honda_static_is_valid_serial(serial)) {
+        return false;
+    }
+
+    fields->button = button;
+    fields->serial = serial;
+    fields->counter = counter;
+    fields->checksum = checksum;
+
+    return true;
+}
+
+static bool honda_static_manchester_pack_64(
+    const uint8_t* symbol_bits,
+    uint16_t count,
+    uint16_t start_pos,
+    bool inverted,
+    uint8_t packet[9],
+    uint16_t* out_bit_count) {
+    memset(packet, 0, 9);
+
+    uint16_t pos = start_pos;
+    uint16_t bit_count = 0U;
+
+    while((uint16_t)(pos + 1U) < count) {
+        if(bit_count >= HONDA_STATIC_BIT_COUNT) {
+            break;
+        }
+
+        const uint8_t a = honda_static_symbol_get(symbol_bits, pos);
+        const uint8_t b = honda_static_symbol_get(symbol_bits, pos + 1U);
+
+        if(a == b) {
+            pos++;
+            continue;
+        }
+
+        bool bit = false;
+        if(inverted) {
+            bit = (a == 0U) && (b == 1U);
+        } else {
+            bit = (a == 1U) && (b == 0U);
+        }
+
+        if(bit) {
+            packet[bit_count >> 3U] |= (uint8_t)(1U << (((uint8_t)~bit_count) & 0x07U));
+        }
+
+        bit_count++;
+        pos += 2U;
+    }
+
+    if(out_bit_count) {
+        *out_bit_count = bit_count;
+    }
+
+    return bit_count >= HONDA_STATIC_BIT_COUNT;
+}
+
+static bool honda_static_parse_symbols(SubGhzProtocolDecoderHondaStatic* instance, bool inverted) {
+    const uint16_t count = instance->symbols_count;
+    const uint8_t* symbol_bits = instance->symbols;
+    HondaStaticFields decoded;
+
+    uint16_t index = 1U;
+    uint16_t transitions = 0U;
+
+    while(index < count) {
+        if(honda_static_symbol_get(symbol_bits, index) !=
+           honda_static_symbol_get(symbol_bits, index - 1U)) {
+            transitions++;
+        } else {
+            if(transitions > HONDA_STATIC_PREAMBLE_MAX_TRANSITIONS) {
+                break;
+            }
+            transitions = 0U;
+        }
+        index++;
+    }
+
+    if(index >= count) {
+        return false;
+    }
+
+    while(((uint16_t)(index + 1U) < count) && (honda_static_symbol_get(symbol_bits, index) ==
+                                               honda_static_symbol_get(symbol_bits, index + 1U))) {
+        index++;
+    }
+
+    const uint16_t data_start = index;
+
+    uint8_t packet[9] = {0};
+    uint16_t bit_count = 0U;
+
+    if(!honda_static_manchester_pack_64(
+           symbol_bits, count, data_start, inverted, packet, &bit_count)) {
+        return false;
+    }
+
+    if(honda_static_validate_forward_packet(packet, &decoded)) {
+        honda_static_decoder_commit(instance, &decoded);
+        return true;
+    }
+
+    if(inverted) {
+        return false;
+    }
+
+    if(honda_static_validate_reverse_packet(packet, &decoded)) {
+        honda_static_decoder_commit(instance, &decoded);
+        return true;
+    }
+
+    return false;
+}
+
+static void honda_static_decoder_commit(
+    SubGhzProtocolDecoderHondaStatic* instance,
+    const HondaStaticFields* decoded) {
+    instance->generic.data_count_bit = HONDA_STATIC_BIT_COUNT;
+    instance->generic.data = honda_static_pack_compact(decoded);
+    instance->generic.serial = decoded->serial;
+    instance->generic.cnt = decoded->counter;
+    instance->generic.btn = decoded->button;
+
+    if(instance->base.callback) {
+        instance->base.callback(&instance->base, instance->base.context);
+    }
+}
+
+static void honda_static_build_upload(SubGhzProtocolEncoderHondaStatic* instance) {
+    uint8_t packet[8];
+    honda_static_build_packet_bytes(&instance->decoded, packet);
+
+    size_t index = 0U;
+    instance->encoder.upload[index++] = level_duration_make(true, HONDA_STATIC_SYNC_TIME_US);
+
+    for(size_t i = 0; i < HONDA_STATIC_PREAMBLE_ALTERNATING_COUNT; i++) {
+        instance->encoder.upload[index++] =
+            level_duration_make((i & 1U) != 0U, HONDA_STATIC_ELEMENT_TIME_US);
+    }
+
+    for(uint8_t bit = 0U; bit < HONDA_STATIC_BIT_COUNT; bit++) {
+        const bool value = ((packet[bit >> 3U] >> (((uint8_t)~bit) & 0x07U)) & 1U) != 0U;
+        instance->encoder.upload[index++] =
+            level_duration_make(!value, HONDA_STATIC_ELEMENT_TIME_US);
+        instance->encoder.upload[index++] =
+            level_duration_make(value, HONDA_STATIC_ELEMENT_TIME_US);
+    }
+
+    const bool last_bit = (packet[7] & 1U) != 0U;
+    instance->encoder.upload[index++] = level_duration_make(!last_bit, HONDA_STATIC_SYNC_TIME_US);
+
+    instance->encoder.front = 0U;
+    instance->encoder.size_upload = index;
+}
+
+static bool honda_static_read_hex_u64(FlipperFormat* ff, uint64_t* out_key) {
+    FuriString* tmp = furi_string_alloc();
+    if(!tmp) return false;
+    bool ok = false;
+    do {
+        if(!flipper_format_rewind(ff) || !flipper_format_read_string(ff, "Key", tmp)) break;
+
+        const char* key_str = furi_string_get_cstr(tmp);
+        uint64_t key = 0;
+        size_t hex_pos = 0;
+        for(size_t i = 0; key_str[i] && hex_pos < 16; i++) {
+            char c = key_str[i];
+            if(c == ' ') continue;
+            uint8_t nibble;
+            if(c >= '0' && c <= '9')
+                nibble = c - '0';
+            else if(c >= 'A' && c <= 'F')
+                nibble = c - 'A' + 10;
+            else if(c >= 'a' && c <= 'f')
+                nibble = c - 'a' + 10;
+            else
+                break;
+            key = (key << 4) | nibble;
+            hex_pos++;
+        }
+        if(hex_pos != 16) break;
+        *out_key = key;
+        ok = true;
+    } while(false);
+    furi_string_free(tmp);
+    return ok;
+}
+
+const SubGhzProtocolDecoder subghz_protocol_honda_static_decoder = {
+    .alloc = subghz_protocol_decoder_honda_static_alloc,
+    .free = subghz_protocol_decoder_honda_static_free,
+    .feed = subghz_protocol_decoder_honda_static_feed,
+    .reset = subghz_protocol_decoder_honda_static_reset,
+    .get_hash_data = subghz_protocol_decoder_honda_static_get_hash_data,
+    .serialize = subghz_protocol_decoder_honda_static_serialize,
+    .deserialize = subghz_protocol_decoder_honda_static_deserialize,
+    .get_string = subghz_protocol_decoder_honda_static_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_honda_static_encoder = {
+    .alloc = subghz_protocol_encoder_honda_static_alloc,
+    .free = subghz_protocol_encoder_honda_static_free,
+    .deserialize = subghz_protocol_encoder_honda_static_deserialize,
+    .stop = subghz_protocol_encoder_honda_static_stop,
+    .yield = subghz_protocol_encoder_honda_static_yield,
+};
+
+const SubGhzProtocol honda_static_protocol = {
+    .name = HONDA_STATIC_PROTOCOL_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_315 | SubGhzProtocolFlag_433 |
+            SubGhzProtocolFlag_FM | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Load |
+            SubGhzProtocolFlag_Send,
+    .decoder = &subghz_protocol_honda_static_decoder,
+    .encoder = &subghz_protocol_honda_static_encoder,
+};
+
+void* subghz_protocol_encoder_honda_static_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+
+    SubGhzProtocolEncoderHondaStatic* instance = malloc(sizeof(SubGhzProtocolEncoderHondaStatic));
+    furi_check(instance);
+    memset(instance, 0, sizeof(*instance));
+
+    instance->base.protocol = &honda_static_protocol;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->encoder.repeat = 3U;
+    instance->encoder.upload = malloc(HONDA_STATIC_UPLOAD_CAPACITY * sizeof(LevelDuration));
+    furi_check(instance->encoder.upload);
+
+    return instance;
+}
+
+void subghz_protocol_encoder_honda_static_free(void* context) {
+    furi_check(context);
+
+    SubGhzProtocolEncoderHondaStatic* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_honda_static_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_check(context);
+
+    SubGhzProtocolEncoderHondaStatic* instance = context;
+    SubGhzProtocolStatus status = SubGhzProtocolStatusError;
+
+    instance->encoder.is_running = false;
+    instance->encoder.front = 0U;
+
+    do {
+        FuriString* pstr = furi_string_alloc();
+        if(!pstr) break;
+
+        flipper_format_rewind(flipper_format);
+        if(!flipper_format_read_string(flipper_format, "Protocol", pstr)) {
+            furi_string_free(pstr);
+            break;
+        }
+        if(!furi_string_equal(pstr, instance->base.protocol->name)) {
+            furi_string_free(pstr);
+            break;
+        }
+        furi_string_free(pstr);
+
+        uint64_t key = 0;
+        if(!honda_static_read_hex_u64(flipper_format, &key)) {
+            break;
+        }
+
+        honda_static_unpack_compact(key, &instance->decoded);
+
+        uint32_t serial = instance->decoded.serial;
+        flipper_format_rewind(flipper_format);
+        if(flipper_format_read_uint32(flipper_format, "Serial", &serial, 1)) {
+            instance->decoded.serial = serial;
+        }
+
+        uint32_t btn_u32 = 0;
+        flipper_format_rewind(flipper_format);
+        if(flipper_format_read_uint32(flipper_format, "Btn", &btn_u32, 1)) {
+            uint8_t b = (uint8_t)btn_u32;
+            if(honda_static_is_valid_button(b)) {
+                instance->decoded.button = b;
+            } else if(b >= 2U && b <= 5U) {
+                instance->decoded.button = honda_static_encoder_remap_button(b);
+            }
+        }
+
+        uint32_t cnt = instance->decoded.counter & 0x00FFFFFFU;
+        flipper_format_rewind(flipper_format);
+        if(flipper_format_read_uint32(flipper_format, "Cnt", &cnt, 1)) {
+            instance->decoded.counter = cnt & 0x00FFFFFFU;
+        }
+
+        instance->generic.serial = instance->decoded.serial;
+        instance->generic.cnt = instance->decoded.counter;
+        instance->generic.btn = instance->decoded.button;
+        instance->generic.data_count_bit = HONDA_STATIC_BIT_COUNT;
+        instance->generic.data = honda_static_pack_compact(&instance->decoded);
+
+        uint8_t key_data[8];
+        honda_static_u64_to_bytes_be(instance->generic.data, key_data);
+
+        flipper_format_rewind(flipper_format);
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(key_data))) {
+            status = SubGhzProtocolStatusErrorParserKey;
+            break;
+        }
+
+        flipper_format_rewind(flipper_format);
+        if(!flipper_format_read_uint32(
+               flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1)) {
+            instance->encoder.repeat = 3U;
+        }
+
+        honda_static_build_upload(instance);
+        instance->encoder.is_running = true;
+        status = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return status;
+}
+
+void subghz_protocol_encoder_honda_static_stop(void* context) {
+    furi_check(context);
+
+    SubGhzProtocolEncoderHondaStatic* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_honda_static_yield(void* context) {
+    furi_check(context);
+
+    SubGhzProtocolEncoderHondaStatic* instance = context;
+    if((instance->encoder.repeat == 0U) || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    const LevelDuration current = instance->encoder.upload[instance->encoder.front];
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        instance->encoder.repeat--;
+        instance->encoder.front = 0U;
+    }
+
+    return current;
+}
+
+void* subghz_protocol_decoder_honda_static_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+
+    SubGhzProtocolDecoderHondaStatic* instance = malloc(sizeof(SubGhzProtocolDecoderHondaStatic));
+    furi_check(instance);
+    memset(instance, 0, sizeof(*instance));
+
+    instance->base.protocol = &honda_static_protocol;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    return instance;
+}
+
+void subghz_protocol_decoder_honda_static_free(void* context) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderHondaStatic* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_honda_static_reset(void* context) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderHondaStatic* instance = context;
+    instance->symbols_count = 0U;
+}
+
+void subghz_protocol_decoder_honda_static_feed(void* context, bool level, uint32_t duration) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderHondaStatic* instance = context;
+
+    const uint8_t sym = honda_static_level_u8(level);
+
+    if((duration >= HONDA_STATIC_SHORT_BASE_US) &&
+       ((duration - HONDA_STATIC_SHORT_BASE_US) <= HONDA_STATIC_SHORT_SPAN_US)) {
+        if(instance->symbols_count < HONDA_STATIC_SYMBOL_CAPACITY) {
+            honda_static_symbol_set(instance->symbols, instance->symbols_count, sym);
+            instance->symbols_count++;
+        }
+        return;
+    }
+
+    if((duration >= HONDA_STATIC_LONG_BASE_US) &&
+       ((duration - HONDA_STATIC_LONG_BASE_US) <= HONDA_STATIC_LONG_SPAN_US)) {
+        if((uint16_t)(instance->symbols_count + 2U) <= HONDA_STATIC_SYMBOL_CAPACITY) {
+            honda_static_symbol_set(instance->symbols, instance->symbols_count, sym);
+            instance->symbols_count++;
+            honda_static_symbol_set(instance->symbols, instance->symbols_count, sym);
+            instance->symbols_count++;
+        }
+        return;
+    }
+
+    const uint16_t sc = instance->symbols_count;
+
+    if(sc >= HONDA_STATIC_MIN_SYMBOLS) {
+        if(!honda_static_parse_symbols(instance, true)) {
+            honda_static_parse_symbols(instance, false);
+        }
+    }
+
+    instance->symbols_count = 0U;
+}
+
+uint8_t subghz_protocol_decoder_honda_static_get_hash_data(void* context) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderHondaStatic* instance = context;
+    const uint64_t data = instance->generic.data;
+
+    return (uint8_t)(data ^ (data >> 8U) ^ (data >> 16U) ^ (data >> 24U) ^ (data >> 32U) ^
+                     (data >> 40U) ^ (data >> 48U) ^ (data >> 56U));
+}
+
+void subghz_protocol_decoder_honda_static_get_string(void* context, FuriString* output) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderHondaStatic* instance = context;
+    HondaStaticFields decoded;
+    honda_static_unpack_compact(instance->generic.data, &decoded);
+
+    furi_string_printf(
+        output,
+        "%s\r\n"
+        "Key:%016llX\r\n"
+        "Btn:%s\r\n"
+        "Ser:%07lX Cnt:%06lX",
+        instance->generic.protocol_name,
+        (unsigned long long)instance->generic.data,
+        honda_static_button_name(decoded.button),
+        (unsigned long)decoded.serial,
+        (unsigned long)decoded.counter);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_honda_static_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderHondaStatic* instance = context;
+    instance->generic.data_count_bit = HONDA_STATIC_BIT_COUNT;
+    HondaStaticFields decoded;
+    honda_static_unpack_compact(instance->generic.data, &decoded);
+
+    SubGhzProtocolStatus status =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    if(status != SubGhzProtocolStatusOk) {
+        return status;
+    }
+
+    uint32_t temp = decoded.serial;
+    if(!flipper_format_write_uint32(flipper_format, "Serial", &temp, 1)) {
+        return SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    temp = decoded.button;
+    if(!flipper_format_write_uint32(flipper_format, "Btn", &temp, 1)) {
+        return SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    temp = decoded.counter;
+    if(!flipper_format_write_uint32(flipper_format, "Cnt", &temp, 1)) {
+        return SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    temp = decoded.checksum;
+    if(!flipper_format_write_uint32(flipper_format, "Checksum", &temp, 1)) {
+        return SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    return status;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_honda_static_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderHondaStatic* instance = context;
+    SubGhzProtocolStatus status = subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, HONDA_STATIC_BIT_COUNT);
+    if(status != SubGhzProtocolStatusOk) {
+        return status;
+    }
+
+    flipper_format_rewind(flipper_format);
+    HondaStaticFields decoded;
+    honda_static_unpack_compact(instance->generic.data, &decoded);
+    uint32_t s = 0;
+    uint32_t b = 0;
+    uint32_t c = 0;
+    if(flipper_format_read_uint32(flipper_format, "Serial", &s, 1)) {
+        decoded.serial = s;
+    }
+    if(flipper_format_read_uint32(flipper_format, "Btn", &b, 1)) {
+        decoded.button = (uint8_t)b;
+    }
+    if(flipper_format_read_uint32(flipper_format, "Cnt", &c, 1)) {
+        decoded.counter = c & 0x00FFFFFFU;
+    }
+
+    instance->generic.data = honda_static_pack_compact(&decoded);
+    instance->generic.serial = decoded.serial;
+    instance->generic.cnt = decoded.counter;
+    instance->generic.btn = decoded.button;
+
+    return status;
+}

lib/subghz/protocols/honda_static.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <furi.h>
+#include <lib/subghz/protocols/base.h>
+#include <lib/subghz/types.h>
+#include <lib/subghz/blocks/decoder.h>
+#include <lib/subghz/blocks/encoder.h>
+#include <lib/subghz/blocks/generic.h>
+#include <flipper_format/flipper_format.h>
+
+#define HONDA_STATIC_PROTOCOL_NAME "Honda Static"
+
+typedef struct SubGhzProtocolDecoderHondaStatic SubGhzProtocolDecoderHondaStatic;
+typedef struct SubGhzProtocolEncoderHondaStatic SubGhzProtocolEncoderHondaStatic;
+
+extern const SubGhzProtocol honda_static_protocol;
+
+void* subghz_protocol_decoder_honda_static_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_decoder_honda_static_free(void* context);
+void subghz_protocol_decoder_honda_static_reset(void* context);
+void subghz_protocol_decoder_honda_static_feed(void* context, bool level, uint32_t duration);
+uint8_t subghz_protocol_decoder_honda_static_get_hash_data(void* context);
+SubGhzProtocolStatus subghz_protocol_decoder_honda_static_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_honda_static_deserialize(void* context, FlipperFormat* flipper_format);
+void subghz_protocol_decoder_honda_static_get_string(void* context, FuriString* output);
+
+void* subghz_protocol_encoder_honda_static_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_encoder_honda_static_free(void* context);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_honda_static_deserialize(void* context, FlipperFormat* flipper_format);
+void subghz_protocol_encoder_honda_static_stop(void* context);
+LevelDuration subghz_protocol_encoder_honda_static_yield(void* context);

lib/subghz/protocols/honda_static.h.bak

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <furi.h>
+#include <lib/subghz/protocols/base.h>
+#include <lib/subghz/types.h>
+#include <lib/subghz/blocks/decoder.h>
+#include <lib/subghz/blocks/encoder.h>
+#include <lib/subghz/blocks/generic.h>
+#include <flipper_format/flipper_format.h>
+
+#define HONDA_STATIC_PROTOCOL_NAME "Honda Static"
+
+typedef struct SubGhzProtocolDecoderHondaStatic SubGhzProtocolDecoderHondaStatic;
+typedef struct SubGhzProtocolEncoderHondaStatic SubGhzProtocolEncoderHondaStatic;
+
+extern const SubGhzProtocol honda_static_protocol;
+
+void* subghz_protocol_decoder_honda_static_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_decoder_honda_static_free(void* context);
+void subghz_protocol_decoder_honda_static_reset(void* context);
+void subghz_protocol_decoder_honda_static_feed(void* context, bool level, uint32_t duration);
+uint8_t subghz_protocol_decoder_honda_static_get_hash_data(void* context);
+SubGhzProtocolStatus subghz_protocol_decoder_honda_static_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+SubGhzProtocolStatus
+    subghz_protocol_decoder_honda_static_deserialize(void* context, FlipperFormat* flipper_format);
+void subghz_protocol_decoder_honda_static_get_string(void* context, FuriString* output);
+
+void* subghz_protocol_encoder_honda_static_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_encoder_honda_static_free(void* context);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_honda_static_deserialize(void* context, FlipperFormat* flipper_format);
+void subghz_protocol_encoder_honda_static_stop(void* context);
+LevelDuration subghz_protocol_encoder_honda_static_yield(void* context);
+

lib/subghz/protocols/kia_v7.c

@@ -0,0 +1,711 @@
+#include "kia_v7.h"
+#include <string.h>
+
+#define KIA_V7_UPLOAD_CAPACITY    0x3A4
+#define KIA_V7_PREAMBLE_PAIRS     0x13F
+#define KIA_V7_PREAMBLE_MIN_PAIRS 16
+#define KIA_V7_HEADER             0x4C
+#define KIA_V7_TAIL_GAP_US        0x7D0
+#define KIA_V7_KEY_BITS           64U
+#define KIA_V7_DEFAULT_TX_REPEAT  10U
+
+static const SubGhzBlockConst subghz_protocol_kia_v7_const = {
+    .te_short = 250,
+    .te_long = 500,
+    .te_delta = 100,
+    .min_count_bit_for_found = KIA_V7_KEY_BITS,
+};
+
+typedef enum {
+    KiaV7DecoderStepReset = 0,
+    KiaV7DecoderStepPreamble = 1,
+    KiaV7DecoderStepSyncLow = 2,
+    KiaV7DecoderStepData = 3,
+} KiaV7DecoderStep;
+
+struct SubGhzProtocolDecoderKiaV7 {
+    SubGhzProtocolDecoderBase base;
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    ManchesterState manchester_state;
+    uint16_t preamble_count;
+
+    uint8_t decoded_button;
+    uint8_t fixed_high_byte;
+    uint8_t crc_calculated;
+    uint8_t crc_raw;
+    bool crc_valid;
+};
+
+struct SubGhzProtocolEncoderKiaV7 {
+    SubGhzProtocolEncoderBase base;
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+
+    uint8_t tx_bit_count;
+    uint8_t decoded_button;
+    uint8_t fixed_high_byte;
+    uint8_t crc_calculated;
+    uint8_t crc_raw;
+    bool crc_valid;
+};
+
+static uint8_t kia_v7_crc8(const uint8_t* data, size_t len) {
+    uint8_t crc = 0x4CU;
+
+    for(size_t index = 0; index < len; index++) {
+        crc ^= data[index];
+        for(uint8_t bit = 0; bit < 8; bit++) {
+            const bool msb = (crc & 0x80U) != 0U;
+            crc <<= 1U;
+            if(msb) {
+                crc ^= 0x7FU;
+            }
+        }
+    }
+
+    return crc;
+}
+
+static void kia_v7_u64_to_bytes_be(uint64_t data, uint8_t bytes[8]) {
+    for(size_t index = 0; index < 8; index++) {
+        bytes[index] = (data >> ((7U - index) * 8U)) & 0xFFU;
+    }
+}
+
+static uint64_t kia_v7_bytes_to_u64_be(const uint8_t bytes[8]) {
+    uint64_t data = 0;
+
+    for(size_t index = 0; index < 8; index++) {
+        data = (data << 8U) | bytes[index];
+    }
+
+    return data;
+}
+
+static bool kia_v7_is_short(uint32_t duration) {
+    return DURATION_DIFF(duration, subghz_protocol_kia_v7_const.te_short) <
+           subghz_protocol_kia_v7_const.te_delta;
+}
+
+static bool kia_v7_is_long(uint32_t duration) {
+    return DURATION_DIFF(duration, subghz_protocol_kia_v7_const.te_long) <
+           subghz_protocol_kia_v7_const.te_delta;
+}
+
+static const char* kia_v7_get_button_name(uint8_t button) {
+    switch(button) {
+    case 0x01:
+        return "LOCK";
+    case 0x02:
+        return "UNLOCK";
+    case 0x03:
+    case 0x08:
+        return "BOOT";
+    default:
+        return "??";
+    }
+}
+
+static SubGhzProtocolStatus
+    kia_v7_write_display(FlipperFormat* flipper_format, const char* protocol_name, uint8_t button) {
+    SubGhzProtocolStatus status = SubGhzProtocolStatusOk;
+    FuriString* display = furi_string_alloc();
+
+    furi_string_printf(display, "%s - %s", protocol_name, kia_v7_get_button_name(button));
+
+    if(!flipper_format_write_string_cstr(flipper_format, "Disp", furi_string_get_cstr(display))) {
+        status = SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    furi_string_free(display);
+    return status;
+}
+
+static void kia_v7_decode_key_common(
+    SubGhzBlockGeneric* generic,
+    uint8_t* decoded_button,
+    uint8_t* fixed_high_byte,
+    uint8_t* crc_calculated,
+    uint8_t* crc_raw,
+    bool* crc_valid) {
+    uint8_t bytes[8];
+    kia_v7_u64_to_bytes_be(generic->data, bytes);
+
+    const uint32_t serial = (((uint32_t)bytes[3]) << 20U) | (((uint32_t)bytes[4]) << 12U) |
+                            (((uint32_t)bytes[5]) << 4U) | (((uint32_t)bytes[6]) >> 4U);
+    const uint16_t counter = ((uint16_t)bytes[1] << 8U) | (uint16_t)bytes[2];
+    const uint8_t button = bytes[6] & 0x0FU;
+    const uint8_t crc_calc = kia_v7_crc8(bytes, 7);
+    const uint8_t crc_pkt = bytes[7];
+
+    generic->serial = serial & 0x0FFFFFFFU;
+    generic->btn = button;
+    generic->cnt = counter;
+    generic->data_count_bit = KIA_V7_KEY_BITS;
+
+    if(decoded_button) {
+        *decoded_button = button;
+    }
+    if(fixed_high_byte) {
+        *fixed_high_byte = bytes[0];
+    }
+    if(crc_calculated) {
+        *crc_calculated = crc_calc;
+    }
+    if(crc_raw) {
+        *crc_raw = crc_pkt;
+    }
+    if(crc_valid) {
+        *crc_valid = (crc_calc == crc_pkt);
+    }
+}
+
+static void kia_v7_decode_key_decoder(SubGhzProtocolDecoderKiaV7* instance) {
+    kia_v7_decode_key_common(
+        &instance->generic,
+        &instance->decoded_button,
+        &instance->fixed_high_byte,
+        &instance->crc_calculated,
+        &instance->crc_raw,
+        &instance->crc_valid);
+}
+
+static uint64_t kia_v7_encode_key(
+    uint8_t fixed_high_byte,
+    uint32_t serial,
+    uint8_t button,
+    uint16_t counter,
+    uint8_t* crc_out) {
+    uint8_t bytes[8];
+
+    serial &= 0x0FFFFFFFU;
+    button &= 0x0FU;
+
+    bytes[0] = fixed_high_byte;
+    bytes[1] = (counter >> 8U) & 0xFFU;
+    bytes[2] = counter & 0xFFU;
+    bytes[3] = (serial >> 20U) & 0xFFU;
+    bytes[4] = (serial >> 12U) & 0xFFU;
+    bytes[5] = (serial >> 4U) & 0xFFU;
+    bytes[6] = ((serial & 0x0FU) << 4U) | button;
+    bytes[7] = kia_v7_crc8(bytes, 7);
+
+    if(crc_out) {
+        *crc_out = bytes[7];
+    }
+
+    return kia_v7_bytes_to_u64_be(bytes);
+}
+
+static void kia_v7_decode_key_encoder(SubGhzProtocolEncoderKiaV7* instance) {
+    kia_v7_decode_key_common(
+        &instance->generic,
+        &instance->decoded_button,
+        &instance->fixed_high_byte,
+        &instance->crc_calculated,
+        &instance->crc_raw,
+        &instance->crc_valid);
+}
+
+static bool kia_v7_encoder_get_upload(SubGhzProtocolEncoderKiaV7* instance) {
+    furi_check(instance);
+
+    const LevelDuration high_short =
+        level_duration_make(true, subghz_protocol_kia_v7_const.te_short);
+    const LevelDuration low_short =
+        level_duration_make(false, subghz_protocol_kia_v7_const.te_short);
+    const LevelDuration low_tail = level_duration_make(false, KIA_V7_TAIL_GAP_US);
+    const size_t max_size = KIA_V7_UPLOAD_CAPACITY;
+
+    const uint8_t bit_count = (instance->tx_bit_count > 0U && instance->tx_bit_count <= 64U) ?
+                                  instance->tx_bit_count :
+                                  64U;
+
+    size_t final_size = 0;
+
+    for(uint8_t pass = 0; pass < 2; pass++) {
+        size_t index = pass;
+
+        for(size_t i = 0; i < KIA_V7_PREAMBLE_PAIRS; i++) {
+            if((index + 2U) > max_size) {
+                return false;
+            }
+
+            instance->encoder.upload[index++] = high_short;
+            instance->encoder.upload[index++] = low_short;
+        }
+
+        if((index + 1U) > max_size) {
+            return false;
+        }
+        instance->encoder.upload[index++] = high_short;
+
+        for(int32_t bit = (int32_t)bit_count - 1; bit >= 0; bit--) {
+            if((index + 2U) > max_size) {
+                return false;
+            }
+
+            const bool value = ((instance->generic.data >> bit) & 1ULL) != 0ULL;
+            instance->encoder.upload[index++] = value ? high_short : low_short;
+            instance->encoder.upload[index++] = value ? low_short : high_short;
+        }
+
+        if((index + 2U) > max_size) {
+            return false;
+        }
+        instance->encoder.upload[index++] = high_short;
+        instance->encoder.upload[index++] = low_tail;
+
+        final_size = index;
+    }
+
+    instance->encoder.front = 0;
+    instance->encoder.size_upload = final_size;
+    return true;
+}
+
+const SubGhzProtocolDecoder subghz_protocol_kia_v7_decoder = {
+    .alloc = kia_protocol_decoder_v7_alloc,
+    .free = kia_protocol_decoder_v7_free,
+    .feed = kia_protocol_decoder_v7_feed,
+    .reset = kia_protocol_decoder_v7_reset,
+    .get_hash_data = kia_protocol_decoder_v7_get_hash_data,
+    .serialize = kia_protocol_decoder_v7_serialize,
+    .deserialize = kia_protocol_decoder_v7_deserialize,
+    .get_string = kia_protocol_decoder_v7_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_kia_v7_encoder = {
+    .alloc = kia_protocol_encoder_v7_alloc,
+    .free = kia_protocol_encoder_v7_free,
+    .deserialize = kia_protocol_encoder_v7_deserialize,
+    .stop = kia_protocol_encoder_v7_stop,
+    .yield = kia_protocol_encoder_v7_yield,
+};
+
+const SubGhzProtocol subghz_protocol_kia_v7 = {
+    .name = KIA_PROTOCOL_V7_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_FM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+    .decoder = &subghz_protocol_kia_v7_decoder,
+    .encoder = &subghz_protocol_kia_v7_encoder,
+};
+
+void* kia_protocol_encoder_v7_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+
+    SubGhzProtocolEncoderKiaV7* instance = calloc(1, sizeof(SubGhzProtocolEncoderKiaV7));
+    furi_check(instance);
+
+    instance->base.protocol = &subghz_protocol_kia_v7;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->encoder.repeat = 1;
+    instance->encoder.size_upload = KIA_V7_UPLOAD_CAPACITY;
+    instance->encoder.upload = malloc(KIA_V7_UPLOAD_CAPACITY * sizeof(LevelDuration));
+    furi_check(instance->encoder.upload);
+
+    return instance;
+}
+
+void kia_protocol_encoder_v7_free(void* context) {
+    furi_check(context);
+
+    SubGhzProtocolEncoderKiaV7* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+SubGhzProtocolStatus
+    kia_protocol_encoder_v7_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_check(context);
+
+    SubGhzProtocolEncoderKiaV7* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+
+    instance->encoder.is_running = false;
+    instance->encoder.front = 0;
+    instance->encoder.repeat = KIA_V7_DEFAULT_TX_REPEAT;
+
+    do {
+        FuriString* temp_str = furi_string_alloc();
+        if(!temp_str) {
+            break;
+        }
+
+        flipper_format_rewind(flipper_format);
+        if(!flipper_format_read_string(flipper_format, "Protocol", temp_str)) {
+            furi_string_free(temp_str);
+            break;
+        }
+
+        if(!furi_string_equal(temp_str, instance->base.protocol->name)) {
+            furi_string_free(temp_str);
+            break;
+        }
+        furi_string_free(temp_str);
+
+        flipper_format_rewind(flipper_format);
+        SubGhzProtocolStatus load_st = subghz_block_generic_deserialize_check_count_bit(
+            &instance->generic, flipper_format, KIA_V7_KEY_BITS);
+        if(load_st != SubGhzProtocolStatusOk) {
+            break;
+        }
+
+        instance->tx_bit_count =
+            (instance->generic.data_count_bit > 0U && instance->generic.data_count_bit <= 64U) ?
+                (uint8_t)instance->generic.data_count_bit :
+                64U;
+
+        kia_v7_decode_key_encoder(instance);
+
+        uint32_t u32 = 0;
+        flipper_format_rewind(flipper_format);
+        if(flipper_format_read_uint32(flipper_format, "Serial", &u32, 1)) {
+            instance->generic.serial = u32;
+        }
+        flipper_format_rewind(flipper_format);
+        if(flipper_format_read_uint32(flipper_format, "Btn", &u32, 1)) {
+            instance->generic.btn = (uint8_t)u32;
+        }
+        flipper_format_rewind(flipper_format);
+        if(flipper_format_read_uint32(flipper_format, "Cnt", &u32, 1)) {
+            instance->generic.cnt = (uint16_t)u32;
+        }
+
+        instance->generic.btn &= 0x0FU;
+        instance->generic.cnt &= 0xFFFFU;
+        instance->generic.serial &= 0x0FFFFFFFU;
+
+        instance->generic.data = kia_v7_encode_key(
+            instance->fixed_high_byte,
+            instance->generic.serial,
+            instance->generic.btn,
+            (uint16_t)instance->generic.cnt,
+            &instance->crc_calculated);
+        instance->generic.data_count_bit = KIA_V7_KEY_BITS;
+
+        flipper_format_rewind(flipper_format);
+        if(!flipper_format_read_uint32(flipper_format, "Repeat", &u32, 1)) {
+            u32 = KIA_V7_DEFAULT_TX_REPEAT;
+        }
+        instance->encoder.repeat = u32;
+
+        if(!kia_v7_encoder_get_upload(instance)) {
+            break;
+        }
+
+        if(instance->encoder.size_upload == 0) {
+            break;
+        }
+
+        flipper_format_rewind(flipper_format);
+        uint8_t key_data[sizeof(uint64_t)];
+        kia_v7_u64_to_bytes_be(instance->generic.data, key_data);
+        if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(key_data))) {
+            break;
+        }
+
+        instance->encoder.is_running = true;
+        ret = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return ret;
+}
+
+void kia_protocol_encoder_v7_stop(void* context) {
+    SubGhzProtocolEncoderKiaV7* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration kia_protocol_encoder_v7_yield(void* context) {
+    SubGhzProtocolEncoderKiaV7* instance = context;
+
+    if(instance->encoder.repeat == 0 || !instance->encoder.is_running) {
+        instance->encoder.is_running = false;
+        return level_duration_reset();
+    }
+
+    LevelDuration duration = instance->encoder.upload[instance->encoder.front];
+
+    if(++instance->encoder.front == instance->encoder.size_upload) {
+        instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return duration;
+}
+
+void* kia_protocol_decoder_v7_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+
+    SubGhzProtocolDecoderKiaV7* instance = calloc(1, sizeof(SubGhzProtocolDecoderKiaV7));
+    furi_check(instance);
+
+    instance->base.protocol = &subghz_protocol_kia_v7;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    return instance;
+}
+
+void kia_protocol_decoder_v7_free(void* context) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderKiaV7* instance = context;
+    free(instance);
+}
+
+void kia_protocol_decoder_v7_reset(void* context) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderKiaV7* instance = context;
+    instance->decoder.parser_step = KiaV7DecoderStepReset;
+    instance->decoder.te_last = 0;
+    instance->decoder.decode_data = 0;
+    instance->decoder.decode_count_bit = 0;
+    instance->preamble_count = 0;
+    manchester_advance(
+        instance->manchester_state, ManchesterEventReset, &instance->manchester_state, NULL);
+}
+
+void kia_protocol_decoder_v7_feed(void* context, bool level, uint32_t duration) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderKiaV7* instance = context;
+    ManchesterEvent event = ManchesterEventReset;
+    bool data = false;
+
+    switch(instance->decoder.parser_step) {
+    case KiaV7DecoderStepReset:
+        if(level && kia_v7_is_short(duration)) {
+            instance->decoder.parser_step = KiaV7DecoderStepPreamble;
+            instance->decoder.te_last = duration;
+            instance->preamble_count = 0;
+            manchester_advance(
+                instance->manchester_state,
+                ManchesterEventReset,
+                &instance->manchester_state,
+                NULL);
+        }
+        break;
+
+    case KiaV7DecoderStepPreamble:
+        if(level) {
+            if(kia_v7_is_long(duration) && kia_v7_is_short(instance->decoder.te_last)) {
+                if(instance->preamble_count > (KIA_V7_PREAMBLE_MIN_PAIRS - 1U)) {
+                    instance->decoder.decode_data = 0;
+                    instance->decoder.decode_count_bit = 0;
+                    instance->preamble_count = 0;
+
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1U);
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0U);
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1U);
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1U);
+
+                    instance->decoder.te_last = duration;
+                    instance->decoder.parser_step = KiaV7DecoderStepSyncLow;
+                } else {
+                    instance->decoder.parser_step = KiaV7DecoderStepReset;
+                }
+            } else if(kia_v7_is_short(duration)) {
+                instance->decoder.te_last = duration;
+            } else {
+                instance->decoder.parser_step = KiaV7DecoderStepReset;
+            }
+        } else {
+            if(kia_v7_is_short(duration) && kia_v7_is_short(instance->decoder.te_last)) {
+                instance->preamble_count++;
+            } else {
+                instance->decoder.parser_step = KiaV7DecoderStepReset;
+            }
+        }
+        break;
+
+    case KiaV7DecoderStepSyncLow:
+        if(!level && kia_v7_is_short(duration) && kia_v7_is_long(instance->decoder.te_last)) {
+            instance->decoder.te_last = duration;
+            instance->decoder.parser_step = KiaV7DecoderStepData;
+        }
+        break;
+
+    case KiaV7DecoderStepData: {
+        if(kia_v7_is_short(duration)) {
+            event = (ManchesterEvent)((uint8_t)(level & 1U) << 1U);
+        } else if(kia_v7_is_long(duration)) {
+            event = level ? ManchesterEventLongHigh : ManchesterEventLongLow;
+        } else {
+            event = ManchesterEventReset;
+        }
+
+        if(kia_v7_is_short(duration) || kia_v7_is_long(duration)) {
+            if(manchester_advance(
+                   instance->manchester_state, event, &instance->manchester_state, &data)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, data);
+            }
+        }
+
+        if(instance->decoder.decode_count_bit == KIA_V7_KEY_BITS) {
+            const uint64_t candidate = ~instance->decoder.decode_data;
+            const uint8_t hdr = (uint8_t)((candidate >> 56U) & 0xFFU);
+
+            if(hdr == KIA_V7_HEADER) {
+                instance->generic.data = candidate;
+                instance->generic.data_count_bit = KIA_V7_KEY_BITS;
+                kia_v7_decode_key_decoder(instance);
+
+                if(instance->crc_valid) {
+                    if(instance->base.callback) {
+                        instance->base.callback(&instance->base, instance->base.context);
+                    }
+                } else {
+                    instance->generic.data = 0;
+                    instance->generic.data_count_bit = 0;
+                }
+
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->decoder.parser_step = KiaV7DecoderStepReset;
+                manchester_advance(
+                    instance->manchester_state,
+                    ManchesterEventReset,
+                    &instance->manchester_state,
+                    NULL);
+            } else {
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->decoder.parser_step = KiaV7DecoderStepReset;
+                manchester_advance(
+                    instance->manchester_state,
+                    ManchesterEventReset,
+                    &instance->manchester_state,
+                    NULL);
+            }
+        }
+
+        break;
+    }
+    }
+}
+
+uint8_t kia_protocol_decoder_v7_get_hash_data(void* context) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderKiaV7* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit >> 3U) + 1U);
+}
+
+void kia_protocol_decoder_v7_get_string(void* context, FuriString* output) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderKiaV7* instance = context;
+    kia_v7_decode_key_decoder(instance);
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:%016llX\r\n"
+        "Sn:%07lX Cnt:%04lX\r\n"
+        "Btn:%01X [%s] CRC:%02X [%s]",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        instance->generic.data,
+        instance->generic.serial & 0x0FFFFFFFU,
+        instance->generic.cnt & 0xFFFFU,
+        instance->decoded_button & 0x0FU,
+        kia_v7_get_button_name(instance->decoded_button),
+        instance->crc_calculated,
+        instance->crc_valid ? "OK" : "ERR");
+}
+
+SubGhzProtocolStatus kia_protocol_decoder_v7_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderKiaV7* instance = context;
+    kia_v7_decode_key_decoder(instance);
+
+    SubGhzProtocolStatus status =
+        subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    if(status != SubGhzProtocolStatusOk) {
+        return status;
+    }
+
+    uint32_t serial = instance->generic.serial & 0x0FFFFFFFU;
+    if(!flipper_format_write_uint32(flipper_format, "Serial", &serial, 1)) {
+        return SubGhzProtocolStatusErrorParserOthers;
+    }
+    uint32_t btn_u32 = (uint32_t)(instance->decoded_button & 0x0FU);
+    if(!flipper_format_write_uint32(flipper_format, "Btn", &btn_u32, 1)) {
+        return SubGhzProtocolStatusErrorParserOthers;
+    }
+    uint32_t cnt_u32 = (uint32_t)(instance->generic.cnt & 0xFFFFU);
+    if(!flipper_format_write_uint32(flipper_format, "Cnt", &cnt_u32, 1)) {
+        return SubGhzProtocolStatusErrorParserOthers;
+    }
+    uint32_t repeat_u32 = KIA_V7_DEFAULT_TX_REPEAT;
+    if(!flipper_format_write_uint32(flipper_format, "Repeat", &repeat_u32, 1)) {
+        return SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    return kia_v7_write_display(
+        flipper_format, instance->generic.protocol_name, instance->decoded_button);
+}
+
+SubGhzProtocolStatus
+    kia_protocol_decoder_v7_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_check(context);
+
+    SubGhzProtocolDecoderKiaV7* instance = context;
+    SubGhzProtocolStatus status = subghz_block_generic_deserialize_check_count_bit(
+        &instance->generic, flipper_format, KIA_V7_KEY_BITS);
+
+    if(status != SubGhzProtocolStatusOk) {
+        return status;
+    }
+
+    if(!flipper_format_rewind(flipper_format)) {
+        return SubGhzProtocolStatusErrorParserOthers;
+    }
+
+    kia_v7_decode_key_decoder(instance);
+
+    uint32_t ser_u32 = 0;
+    uint32_t btn_u32 = 0;
+    uint32_t cnt_u32 = 0;
+    bool got_serial = false;
+    bool got_btn = false;
+    bool got_cnt = false;
+
+    flipper_format_rewind(flipper_format);
+    got_serial = flipper_format_read_uint32(flipper_format, "Serial", &ser_u32, 1);
+    flipper_format_rewind(flipper_format);
+    got_btn = flipper_format_read_uint32(flipper_format, "Btn", &btn_u32, 1);
+    flipper_format_rewind(flipper_format);
+    got_cnt = flipper_format_read_uint32(flipper_format, "Cnt", &cnt_u32, 1);
+
+    if(got_serial || got_btn || got_cnt) {
+        if(got_serial) {
+            instance->generic.serial = ser_u32 & 0x0FFFFFFFU;
+        }
+        if(got_btn) {
+            instance->generic.btn = (uint8_t)(btn_u32 & 0x0FU);
+        }
+        if(got_cnt) {
+            instance->generic.cnt = (uint16_t)(cnt_u32 & 0xFFFFU);
+        }
+        instance->generic.data = kia_v7_encode_key(
+            instance->fixed_high_byte,
+            instance->generic.serial,
+            instance->generic.btn & 0x0FU,
+            (uint16_t)(instance->generic.cnt & 0xFFFFU),
+            &instance->crc_calculated);
+        kia_v7_decode_key_decoder(instance);
+    }
+
+    return SubGhzProtocolStatusOk;
+}

lib/subghz/protocols/kia_v7.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <furi.h>
+#include <lib/subghz/protocols/base.h>
+#include <lib/subghz/types.h>
+#include <lib/subghz/blocks/const.h>
+#include <lib/subghz/blocks/decoder.h>
+#include <lib/subghz/blocks/encoder.h>
+#include <lib/subghz/blocks/generic.h>
+#include <lib/subghz/blocks/math.h>
+#include <flipper_format/flipper_format.h>
+#include <lib/toolbox/level_duration.h>
+#include <lib/toolbox/manchester_decoder.h>
+
+#define KIA_PROTOCOL_V7_NAME "Kia V7"
+
+typedef struct SubGhzProtocolDecoderKiaV7 SubGhzProtocolDecoderKiaV7;
+typedef struct SubGhzProtocolEncoderKiaV7 SubGhzProtocolEncoderKiaV7;
+
+extern const SubGhzProtocolDecoder subghz_protocol_kia_v7_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_kia_v7_encoder;
+extern const SubGhzProtocol subghz_protocol_kia_v7;
+
+void* kia_protocol_decoder_v7_alloc(SubGhzEnvironment* environment);
+void kia_protocol_decoder_v7_free(void* context);
+void kia_protocol_decoder_v7_reset(void* context);
+void kia_protocol_decoder_v7_feed(void* context, bool level, uint32_t duration);
+uint8_t kia_protocol_decoder_v7_get_hash_data(void* context);
+SubGhzProtocolStatus kia_protocol_decoder_v7_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+SubGhzProtocolStatus
+    kia_protocol_decoder_v7_deserialize(void* context, FlipperFormat* flipper_format);
+void kia_protocol_decoder_v7_get_string(void* context, FuriString* output);
+
+void* kia_protocol_encoder_v7_alloc(SubGhzEnvironment* environment);
+void kia_protocol_encoder_v7_free(void* context);
+SubGhzProtocolStatus
+    kia_protocol_encoder_v7_deserialize(void* context, FlipperFormat* flipper_format);
+void kia_protocol_encoder_v7_stop(void* context);
+LevelDuration kia_protocol_encoder_v7_yield(void* context);
+

lib/subghz/protocols/protocol_items.c

@@ -44,7 +44,7 @@ const SubGhzProtocol* const subghz_protocol_registry_items[] = {
     //&subghz_protocol_honeywell,     
     //&subghz_protocol_legrand,
     &subghz_protocol_dickert_mahs,  
-    //&subghz_protocol_gangqi,
+    &subghz_protocol_gangqi,
     &subghz_protocol_marantec24,    
     //&subghz_protocol_hollarm,
     &subghz_protocol_hay21,         
@@ -59,9 +59,11 @@ const SubGhzProtocol* const subghz_protocol_registry_items[] = {
     &subghz_protocol_vag,          
     &subghz_protocol_porsche_cayenne,  
     &subghz_protocol_ford_v0,
+    &ford_protocol_v1,
     &subghz_protocol_psa,
     &subghz_protocol_fiat_spa,       
     &subghz_protocol_fiat_marelli,
+ // &subghz_protocol_bmw_cas4,
     &subghz_protocol_subaru, 
     &subghz_protocol_mazda_siemens,
     &subghz_protocol_kia_v0,       
@@ -70,11 +72,15 @@ const SubGhzProtocol* const subghz_protocol_registry_items[] = {
     &subghz_protocol_kia_v3_v4,
     &subghz_protocol_kia_v5,       
     &subghz_protocol_kia_v6,
+    &subghz_protocol_kia_v7,
     &subghz_protocol_suzuki, 
     &subghz_protocol_mitsubishi_v0,
     &subghz_protocol_star_line,
     &subghz_protocol_scher_khan,
     &subghz_protocol_sheriff_cfm,
+    &subghz_protocol_chrysler,
+    &honda_static_protocol,
+    //&subghz_protocol_honda,
 };
 
 const SubGhzProtocolRegistry subghz_protocol_registry = {

lib/subghz/protocols/protocol_items.h

@@ -63,6 +63,7 @@
 #include "psa.h"
 #include "fiat_spa.h"
 #include "fiat_marelli.h"
+#include "bmw_cas4.h"
 #include "subaru.h"
 #include "kia_generic.h"
 #include "kia_v0.h"
@@ -71,9 +72,14 @@
 #include "kia_v3_v4.h"
 #include "kia_v5.h"
 #include "kia_v6.h"
+#include "kia_v7.h"
 #include "suzuki.h"
 #include "mitsubishi_v0.h"
 #include "mazda_siemens.h"
 #include "star_line.h"
 #include "scher_khan.h"
 #include "sheriff_cfm.h"
+#include "chrysler.h"
+#include "honda_static.h"
+#include "ford_v1.h"
+//#include "honda_pandora.h"

lib/subghz/protocols/psa.c

@@ -125,6 +125,10 @@ struct SubGhzProtocolDecoderPSA {
 
     uint32_t last_key1_low;
     uint32_t last_key1_high;
+
+    uint32_t te_sum;
+    uint16_t te_count;
+    uint32_t te_detected;
 };
 
 struct SubGhzProtocolEncoderPSA {
@@ -670,6 +674,9 @@ void subghz_protocol_decoder_psa_feed(void* context, bool level, uint32_t durati
         instance->pattern_counter = 0;
         instance->decode_count_bit = 0;
         instance->mode_serialize = 0;
+        instance->te_sum = duration;
+        instance->te_count = 1;
+        instance->te_detected = 0;
         instance->prev_duration = duration;
         manchester_advance(instance->manchester_state, ManchesterEventReset,
                          &instance->manchester_state, NULL);
@@ -758,6 +765,17 @@ void subghz_protocol_decoder_psa_feed(void* context, bool level, uint32_t durati
                         instance->mode_serialize = 0x36;
                     }
 
+                    // Only fire callback if decrypted or validation nibble matches
+                    if(instance->decrypted != 0x50 &&
+                       (instance->validation_field & 0xf) != 0xa) {
+                        instance->decode_data_low = 0;
+                        instance->decode_data_high = 0;
+                        instance->decode_count_bit = 0;
+                        new_state = PSADecoderState0;
+                        instance->state = new_state;
+                        return;
+                    }
+
                     instance->generic.data = ((uint64_t)instance->key1_high << 32) | instance->key1_low;
                     instance->generic.data_count_bit = 64;
                     instance->decoder.decode_data = instance->generic.data;
@@ -924,39 +942,35 @@ void subghz_protocol_decoder_psa_feed(void* context, bool level, uint32_t durati
             return;
         }
 
-        if(duration < PSA_TE_SHORT_125) {
-            tolerance = PSA_TE_SHORT_125 - duration;
-            if(tolerance < PSA_TOLERANCE_50) {
-                uint32_t prev_diff = psa_abs_diff(prev_dur, PSA_TE_SHORT_125);
-                if(prev_diff <= PSA_TOLERANCE_49) {
-                    instance->pattern_counter++;
-                } else {
-                    instance->pattern_counter = 0;
-                }
-                instance->prev_duration = duration;
-                return;
+        // Adaptive AM preamble: accept 76-174us, average to detect actual TE
+        if(duration >= 76 && duration <= 174) {
+            if(prev_dur >= 76 && prev_dur <= 174) {
+                instance->pattern_counter++;
+                instance->te_sum += duration;
+                instance->te_count++;
+            } else {
+                instance->pattern_counter = 0;
+                instance->te_sum = duration;
+                instance->te_count = 1;
             }
+            instance->prev_duration = duration;
+            return;
         } else {
-            tolerance = duration - PSA_TE_SHORT_125;
-            if(tolerance < PSA_TOLERANCE_50) {
-                uint32_t prev_diff = psa_abs_diff(prev_dur, PSA_TE_SHORT_125);
-                if(prev_diff <= PSA_TOLERANCE_49) {
-                    instance->pattern_counter++;
-                } else {
-                    instance->pattern_counter = 0;
-                }
-                instance->prev_duration = duration;
-                return;
-            } else if(duration >= PSA_TE_LONG_250 && duration < 0x12c) {
-                if(instance->pattern_counter > PSA_PATTERN_THRESHOLD_2) {
-                    new_state = PSADecoderState4;
-                    instance->decode_data_low = 0;
-                    instance->decode_data_high = 0;
-                    instance->decode_count_bit = 0;
-                    manchester_advance(instance->manchester_state, ManchesterEventReset,
-                                     &instance->manchester_state, NULL);
-                    instance->state = new_state;
-                }
+            // Check if this is the preamble-to-data transition (2x detected TE)
+            uint32_t te_avg = (instance->te_count > 0) ?
+                (instance->te_sum / instance->te_count) : PSA_TE_SHORT_125;
+            uint32_t te_long_expected = te_avg * 2;
+            uint32_t long_diff = psa_abs_diff(duration, te_long_expected);
+
+            if(long_diff <= te_avg && instance->pattern_counter > PSA_PATTERN_THRESHOLD_2) {
+                instance->te_detected = te_avg;
+                new_state = PSADecoderState4;
+                instance->decode_data_low = 0;
+                instance->decode_data_high = 0;
+                instance->decode_count_bit = 0;
+                manchester_advance(instance->manchester_state, ManchesterEventReset,
+                                 &instance->manchester_state, NULL);
+                instance->state = new_state;
                 instance->pattern_counter = 0;
                 instance->prev_duration = duration;
                 return;
@@ -964,67 +978,25 @@ void subghz_protocol_decoder_psa_feed(void* context, bool level, uint32_t durati
         }
 
         new_state = PSADecoderState0;
+        instance->pattern_counter = 0;
         break;
 
-    case PSADecoderState4:
+    case PSADecoderState4: {
         if(instance->decode_count_bit >= PSA_MAX_BITS) {
             new_state = PSADecoderState0;
             break;
         }
 
-        if(!level) {
-            uint8_t manchester_input;
-            bool decoded_bit = false;
-
-            if(duration < PSA_TE_SHORT_125) {
-                tolerance = PSA_TE_SHORT_125 - duration;
-                if(tolerance > PSA_TOLERANCE_49) {
-                    return;
-                }
-                manchester_input = ((level ^ 1) & 0x7f) << 1;
-            } else {
-                tolerance = duration - PSA_TE_SHORT_125;
-                if(tolerance < PSA_TOLERANCE_50) {
-                    manchester_input = ((level ^ 1) & 0x7f) << 1;
-                } else if(duration >= PSA_TE_LONG_250 && duration < 0x12c) {
-                    if(level == 0) {
-                        manchester_input = 6;
-                    } else {
-                        manchester_input = 4;
-                    }
-                } else {
-                    return;
-                }
-            }
-
-            if(manchester_advance(instance->manchester_state,
-                                 (ManchesterEvent)manchester_input,
-                                 &instance->manchester_state,
-                                 &decoded_bit)) {
-                uint32_t carry = (instance->decode_data_low >> 31) & 1;
-                instance->decode_data_low = (instance->decode_data_low << 1) | (decoded_bit ? 1 : 0);
-                instance->decode_data_high = (instance->decode_data_high << 1) | carry;
-                instance->decode_count_bit++;
-
-                if(instance->decode_count_bit == PSA_KEY1_BITS) {
-                    instance->key1_low = instance->decode_data_low;
-                    instance->key1_high = instance->decode_data_high;
-                    instance->decode_data_low = 0;
-                    instance->decode_data_high = 0;
-                }
-            }
-        } else if(level) {
-            uint32_t end_diff;
-            if(duration < PSA_TE_END_500) {
-                end_diff = PSA_TE_END_500 - duration;
-            } else {
-                end_diff = duration - PSA_TE_END_500;
-            }
-            if(end_diff <= 99) {
-                if(instance->decode_count_bit != PSA_KEY2_BITS) {
-                    return;
-                }
+        uint32_t te_s = instance->te_detected ? instance->te_detected : PSA_TE_SHORT_125;
+        uint32_t te_l = te_s * 2;
+        uint32_t te_tol = te_s / 2;
+        uint32_t midpoint = (te_s + te_l) / 2;
 
+        // End marker check: HIGH pulse beyond long range at 80 bits
+        if(level && instance->decode_count_bit == PSA_KEY2_BITS && duration > midpoint) {
+            uint32_t end_expected = te_s * 4;
+            uint32_t end_diff = psa_abs_diff(duration, end_expected);
+            if(end_diff <= te_s * 2) {
                 instance->validation_field = (uint16_t)(instance->decode_data_low & 0xFFFF);
                 instance->key2_low = instance->decode_data_low;
                 instance->key2_high = instance->decode_data_high;
@@ -1041,6 +1013,16 @@ void subghz_protocol_decoder_psa_feed(void* context, bool level, uint32_t durati
                     instance->mode_serialize = 0x36;
                 }
 
+                if(instance->decrypted != 0x50 &&
+                   (instance->validation_field & 0xf) != 0xa) {
+                    instance->decode_data_low = 0;
+                    instance->decode_data_high = 0;
+                    instance->decode_count_bit = 0;
+                    new_state = PSADecoderState0;
+                    instance->state = new_state;
+                    return;
+                }
+
                 instance->generic.data = ((uint64_t)instance->key1_high << 32) | instance->key1_low;
                 instance->generic.data_count_bit = 64;
                 instance->decoder.decode_data = instance->generic.data;
@@ -1054,12 +1036,56 @@ void subghz_protocol_decoder_psa_feed(void* context, bool level, uint32_t durati
                 new_state = PSADecoderState0;
                 instance->state = new_state;
                 return;
-            } else {
+            }
+        }
+
+        // Manchester decode: process BOTH high and low pulses (unlike original AM path)
+        if(duration > te_l + te_tol) {
+            if(duration > 10000) {
+                new_state = PSADecoderState0;
+                break;
+            }
+            return;
+        }
+
+        uint8_t manchester_input;
+        bool decoded_bit = false;
+
+        if(duration <= midpoint) {
+            if(psa_abs_diff(duration, te_s) > te_tol) {
                 return;
             }
+            manchester_input = level ? ManchesterEventShortLow : ManchesterEventShortHigh;
+        } else {
+            if(psa_abs_diff(duration, te_l) > te_tol) {
+                return;
+            }
+            manchester_input = level ? ManchesterEventLongLow : ManchesterEventLongHigh;
+        }
+
+        if(instance->decode_count_bit < PSA_KEY2_BITS) {
+            if(manchester_advance(instance->manchester_state,
+                                 (ManchesterEvent)manchester_input,
+                                 &instance->manchester_state,
+                                 &decoded_bit)) {
+                uint32_t carry = (instance->decode_data_low >> 31) & 1;
+                // PSA AM uses inverted Manchester convention
+                decoded_bit = !decoded_bit;
+                instance->decode_data_low = (instance->decode_data_low << 1) | (decoded_bit ? 1 : 0);
+                instance->decode_data_high = (instance->decode_data_high << 1) | carry;
+                instance->decode_count_bit++;
+
+                if(instance->decode_count_bit == PSA_KEY1_BITS) {
+                    instance->key1_low = instance->decode_data_low;
+                    instance->key1_high = instance->decode_data_high;
+                    instance->decode_data_low = 0;
+                    instance->decode_data_high = 0;
+                }
+            }
         }
         break;
     }
+    }
 
     instance->state = new_state;
     instance->prev_duration = duration;