Fix Starline d-pad mapping

This reverts commit a5cf675561.

README.md

@@ -60,6 +60,8 @@ This project may incorporate, adapt, or build upon **other open-source projects*
 | Subaru | Subaru | 433 MHz | AM | Yes | Yes | No |
 | Suzuki | Suzuki | 433 MHz | FM | Yes | Yes | Yes |
 | Mitsubishi | Mitsubishi V0 | 868 MHz | FM | Yes | Yes | No |
+| Starline | Star Line | 433 MHz | AM | Yes | Yes | No |
+| Scher-Khan | Scher-Khan | 433 MHz | FM | Yes | Yes | No |
 
 ### Gate / Access Protocols
 

applications/services/desktop/desktop.c

@@ -282,7 +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->tos_view = desktop_view_tos_alloc();
 
     desktop->main_view_stack = view_stack_alloc();
     desktop->main_view = desktop_main_alloc();
@@ -327,10 +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));
+    //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();
@@ -516,9 +516,9 @@ int32_t desktop_srv(void* p) {
 
     if(storage_file_exists(desktop->storage, SLIDESHOW_FS_PATH)) {
         scene_manager_next_scene(desktop->scene_manager, DesktopSceneSlideshow);
-    }
-
-    scene_manager_next_scene(desktop->scene_manager, DesktopSceneTos);
+    } //else {
+        //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,8 +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 "views/desktop_view_tos.h"
+
 
 #include <gui/gui.h>
 #include <gui/view_stack.h>
@@ -34,7 +34,6 @@ typedef enum {
     DesktopViewIdPinInput,
     DesktopViewIdPinTimeout,
     DesktopViewIdSlideshow,
-    DesktopViewIdTos,
     DesktopViewIdTotal,
 } DesktopViewId;
 
@@ -58,7 +57,6 @@ 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

@@ -1,98 +0,0 @@
-#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

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

applications/services/desktop/scenes/desktop_scene_config.h

@@ -8,4 +8,3 @@ 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,7 +4,6 @@
 #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) {
@@ -31,6 +30,7 @@ bool desktop_scene_slideshow_on_event(void* context, SceneManagerEvent event) {
         switch(event.event) {
         case DesktopSlideshowCompleted:
             scene_manager_previous_scene(desktop->scene_manager);
+            //scene_manager_search_and_switch_to_another_scene(desktop->scene_manager, DesktopSceneTos);
             consumed = true;
             break;
         case DesktopSlideshowPoweroff:

applications/services/desktop/scenes/desktop_scene_tos.c

@@ -1,52 +0,0 @@
-#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,8 +39,6 @@ typedef enum {
 
     DesktopSlideshowCompleted,
     DesktopSlideshowPoweroff,
-    DesktopTosAccepted,
-    DesktopTosDeclined,
 
     DesktopHwMismatchExit,
 

applications/services/desktop/views/desktop_view_tos.c

@@ -1,79 +0,0 @@
-#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

@@ -1,14 +0,0 @@
-#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.h

@@ -1,23 +1,11 @@
 #pragma once
 
-#include <furi.h>
-#include <lib/subghz/protocols/base.h>
-#include <lib/subghz/types.h>
-#include <lib/subghz/blocks/const.h>
-#include <lib/subghz/blocks/decoder.h>
-#include <lib/subghz/blocks/encoder.h>
-#include <lib/subghz/blocks/generic.h>
-#include <lib/subghz/blocks/math.h>
-#include <flipper_format/flipper_format.h>
-#include <lib/toolbox/manchester_decoder.h>
+#include "base.h"
 
-#include <lib/subghz/blocks/custom_btn.h>
-
-#define FORD_PROTOCOL_V0_NAME "Ford V0"
+#define SUBGHZ_PROTOCOL_FORD_V0_NAME "FORD V0"
 
 extern const SubGhzProtocol subghz_protocol_ford_v0;
 
-// Decoder functions
 void* subghz_protocol_decoder_ford_v0_alloc(SubGhzEnvironment* environment);
 void subghz_protocol_decoder_ford_v0_free(void* context);
 void subghz_protocol_decoder_ford_v0_reset(void* context);
@@ -31,7 +19,6 @@ SubGhzProtocolStatus
     subghz_protocol_decoder_ford_v0_deserialize(void* context, FlipperFormat* flipper_format);
 void subghz_protocol_decoder_ford_v0_get_string(void* context, FuriString* output);
 
-// Encoder functions
 void* subghz_protocol_encoder_ford_v0_alloc(SubGhzEnvironment* environment);
 void subghz_protocol_encoder_ford_v0_free(void* context);
 SubGhzProtocolStatus

lib/subghz/protocols/scher_khan.c

@@ -59,6 +59,8 @@ struct SubGhzProtocolEncoderScherKhan {
 
     SubGhzProtocolBlockEncoder encoder;
     SubGhzBlockGeneric generic;
+
+    const char* protocol_name;
 };
 
 typedef enum {
@@ -68,6 +70,10 @@ typedef enum {
     ScherKhanDecoderStepCheckDuration,
 } ScherKhanDecoderStep;
 
+static void subghz_protocol_scher_khan_check_remote_controller(
+    SubGhzBlockGeneric* instance,
+    const char** protocol_name);
+
 const SubGhzProtocolDecoder subghz_protocol_scher_khan_decoder = {
     .alloc = subghz_protocol_decoder_scher_khan_alloc,
     .free = subghz_protocol_decoder_scher_khan_free,
@@ -82,23 +88,345 @@ const SubGhzProtocolDecoder subghz_protocol_scher_khan_decoder = {
 };
 
 const SubGhzProtocolEncoder subghz_protocol_scher_khan_encoder = {
-    .alloc = NULL,
-    .free = NULL,
+    .alloc = subghz_protocol_encoder_scher_khan_alloc,
+    .free = subghz_protocol_encoder_scher_khan_free,
 
-    .deserialize = NULL,
-    .stop = NULL,
-    .yield = NULL,
+    .deserialize = subghz_protocol_encoder_scher_khan_deserialize,
+    .stop = subghz_protocol_encoder_scher_khan_stop,
+    .yield = subghz_protocol_encoder_scher_khan_yield,
 };
 
 const SubGhzProtocol subghz_protocol_scher_khan = {
     .name = SUBGHZ_PROTOCOL_SCHER_KHAN_NAME,
     .type = SubGhzProtocolTypeDynamic,
-    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_FM | SubGhzProtocolFlag_Decodable,
+    .flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_FM | SubGhzProtocolFlag_AM |
+            SubGhzProtocolFlag_Decodable |
+            SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
 
     .decoder = &subghz_protocol_scher_khan_decoder,
     .encoder = &subghz_protocol_scher_khan_encoder,
 };
 
+// ======================== ENCODER ========================
+
+void* subghz_protocol_encoder_scher_khan_alloc(SubGhzEnvironment* environment) {
+    UNUSED(environment);
+    SubGhzProtocolEncoderScherKhan* instance = malloc(sizeof(SubGhzProtocolEncoderScherKhan));
+
+    instance->base.protocol = &subghz_protocol_scher_khan;
+    instance->generic.protocol_name = instance->base.protocol->name;
+
+    instance->encoder.repeat = 7;
+    instance->encoder.size_upload = 256;
+    instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
+    instance->encoder.is_running = false;
+    instance->encoder.front = 0;
+
+    return instance;
+}
+
+void subghz_protocol_encoder_scher_khan_free(void* context) {
+    furi_check(context);
+    SubGhzProtocolEncoderScherKhan* instance = context;
+    free(instance->encoder.upload);
+    free(instance);
+}
+
+/**
+ * Build the RF upload buffer matching the real Scher-Khan waveform.
+ *
+ * Real signal structure (from Boot_sh5.sub / Trunk_sh5.sub analysis):
+ *
+ *   Preamble:  6x pairs of ~750µs high / ~750µs low
+ *   Header:    3x pairs of ~1500µs high / ~1500µs low
+ *   Start bit: 1x pair  of ~750µs high / ~750µs low
+ *   Data:      bit 0 = ~750µs  high / ~750µs  low
+ *              bit 1 = ~1100µs high / ~1100µs low
+ *   End:       ~1500µs high (marks frame end for decoder)
+ */
+static bool subghz_protocol_encoder_scher_khan_get_upload(
+    SubGhzProtocolEncoderScherKhan* instance,
+    uint8_t btn) {
+    furi_check(instance);
+
+    // For 51-bit dynamic: rebuild data with new button and incremented counter
+    if(instance->generic.data_count_bit == 51) {
+        if((instance->generic.cnt + 1) > 0xFFFF) {
+            instance->generic.cnt = 0;
+        } else {
+            instance->generic.cnt += 1;
+        }
+
+        uint64_t upper = instance->generic.data & 0x7FFFFFFF0000ULL;
+        upper = (upper & ~(0x0FULL << 24)) | ((uint64_t)(btn & 0x0F) << 24);
+        instance->generic.data = upper | (instance->generic.cnt & 0xFFFF);
+        instance->generic.btn = btn;
+    }
+
+    size_t index = 0;
+    size_t needed = (6 * 2) + (3 * 2) + (1 * 2) + (instance->generic.data_count_bit * 2) + 1;
+    if(needed > instance->encoder.size_upload) {
+        FURI_LOG_E(TAG, "Upload buffer too small: need %zu, have %zu",
+            needed, instance->encoder.size_upload);
+        return false;
+    }
+
+    for(uint8_t i = 0; i < 6; i++) {
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_scher_khan_const.te_short);
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_scher_khan_const.te_short);
+    }
+
+    for(uint8_t i = 0; i < 3; i++) {
+        instance->encoder.upload[index++] =
+            level_duration_make(true, (uint32_t)subghz_protocol_scher_khan_const.te_short * 2);
+        instance->encoder.upload[index++] =
+            level_duration_make(false, (uint32_t)subghz_protocol_scher_khan_const.te_short * 2);
+    }
+
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_scher_khan_const.te_short);
+    instance->encoder.upload[index++] =
+        level_duration_make(false, (uint32_t)subghz_protocol_scher_khan_const.te_short);
+
+    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_scher_khan_const.te_long);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_scher_khan_const.te_long);
+        } else {
+            instance->encoder.upload[index++] =
+                level_duration_make(true, (uint32_t)subghz_protocol_scher_khan_const.te_short);
+            instance->encoder.upload[index++] =
+                level_duration_make(false, (uint32_t)subghz_protocol_scher_khan_const.te_short);
+        }
+    }
+
+    instance->encoder.upload[index++] =
+        level_duration_make(true, (uint32_t)subghz_protocol_scher_khan_const.te_short * 2);
+
+    instance->encoder.size_upload = index;
+
+    FURI_LOG_I(TAG, "Upload built: %zu entries, %d bits, btn=0x%02X, cnt=0x%04lX, data=0x%016llX",
+        index, instance->generic.data_count_bit, instance->generic.btn,
+        (unsigned long)instance->generic.cnt, instance->generic.data);
+
+    return true;
+}
+
+static SubGhzProtocolStatus subghz_protocol_encoder_scher_khan_serialize_internal(
+    SubGhzProtocolEncoderScherKhan* instance,
+    FlipperFormat* flipper_format) {
+
+    const char* pname = NULL;
+    subghz_protocol_scher_khan_check_remote_controller(&instance->generic, &pname);
+
+    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;
+        }
+
+        ret = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return ret;
+}
+
+SubGhzProtocolStatus
+    subghz_protocol_encoder_scher_khan_deserialize(void* context, FlipperFormat* flipper_format) {
+    furi_check(context);
+    SubGhzProtocolEncoderScherKhan* 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 = (uint8_t)bit_count_temp;
+
+        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 == 0) {
+            FURI_LOG_E(TAG, "Invalid key length");
+            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 = 0;
+            FURI_LOG_I(TAG, "Serial not found, defaulting to 0");
+        } 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 = 0;
+            FURI_LOG_I(TAG, "Button not found, defaulting to 0");
+        }
+
+        subghz_custom_btn_set_original(scher_khan_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%04lX", (unsigned long)instance->generic.cnt);
+        } else {
+            instance->generic.cnt = 0;
+        }
+
+        if(!flipper_format_read_uint32(
+               flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1)) {
+            instance->encoder.repeat = 7;
+            FURI_LOG_D(TAG, "Repeat not found, using default 7");
+        }
+
+        const char* pname = NULL;
+        subghz_protocol_scher_khan_check_remote_controller(&instance->generic, &pname);
+        instance->protocol_name = pname;
+
+        uint8_t selected_btn = scher_khan_get_btn_code(instance->generic.btn);
+
+        FURI_LOG_I(TAG,
+            "Building upload: original_btn=0x%02X, selected_btn=0x%02X, bits=%d",
+            instance->generic.btn, selected_btn, instance->generic.data_count_bit);
+
+        if(!subghz_protocol_encoder_scher_khan_get_upload(instance, selected_btn)) {
+            FURI_LOG_E(TAG, "Failed to generate upload");
+            break;
+        }
+
+        subghz_protocol_encoder_scher_khan_serialize_internal(instance, flipper_format);
+
+        instance->encoder.is_running = true;
+        instance->encoder.front = 0;
+
+        FURI_LOG_I(TAG, "Encoder ready: repeat=%u, size_upload=%zu",
+            instance->encoder.repeat, instance->encoder.size_upload);
+
+        ret = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return ret;
+}
+
+void subghz_protocol_encoder_scher_khan_stop(void* context) {
+    furi_check(context);
+    SubGhzProtocolEncoderScherKhan* instance = context;
+    instance->encoder.is_running = false;
+}
+
+LevelDuration subghz_protocol_encoder_scher_khan_yield(void* context) {
+    SubGhzProtocolEncoderScherKhan* 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;
+}
+
+// ======================== DECODER ========================
+
 void* subghz_protocol_decoder_scher_khan_alloc(SubGhzEnvironment* environment) {
     UNUSED(environment);
     SubGhzProtocolDecoderScherKhan* instance = malloc(sizeof(SubGhzProtocolDecoderScherKhan));
@@ -264,7 +592,6 @@ static void subghz_protocol_scher_khan_check_remote_controller(
         instance->btn = 0;
         instance->cnt = 0;
         break;
-
     default:
         *protocol_name = "Unknown";
         instance->serial = 0;
@@ -287,6 +614,10 @@ SubGhzProtocolStatus subghz_protocol_decoder_scher_khan_serialize(
     SubGhzRadioPreset* preset) {
     furi_check(context);
     SubGhzProtocolDecoderScherKhan* instance = context;
+
+    const char* pname = NULL;
+    subghz_protocol_scher_khan_check_remote_controller(&instance->generic, &pname);
+
     SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
 
     do {
@@ -351,7 +682,91 @@ 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);
+    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 = (uint8_t)bit_count_temp;
+
+        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 == 0) {
+            FURI_LOG_E(TAG, "Invalid key length");
+            break;
+        }
+
+        instance->generic.data = key;
+
+        if(!flipper_format_read_uint32(flipper_format, "Serial", &instance->generic.serial, 1)) {
+            instance->generic.serial = 0;
+        }
+
+        uint32_t btn_temp;
+        if(flipper_format_read_uint32(flipper_format, "Btn", &btn_temp, 1)) {
+            instance->generic.btn = (uint8_t)btn_temp;
+        } else {
+            instance->generic.btn = 0;
+        }
+
+        uint32_t cnt_temp;
+        if(flipper_format_read_uint32(flipper_format, "Cnt", &cnt_temp, 1)) {
+            instance->generic.cnt = (uint16_t)cnt_temp;
+        } else {
+            instance->generic.cnt = 0;
+        }
+
+        FURI_LOG_I(TAG, "Decoder deserialized");
+        ret = SubGhzProtocolStatusOk;
+    } while(false);
+
+    return ret;
 }
 
 void subghz_protocol_decoder_scher_khan_get_string(void* context, FuriString* output) {

lib/subghz/protocols/scher_khan.h

@@ -35,3 +35,10 @@ SubGhzProtocolStatus
     subghz_protocol_decoder_scher_khan_deserialize(void* context, FlipperFormat* flipper_format);
 
 void subghz_protocol_decoder_scher_khan_get_string(void* context, FuriString* output);
+
+void* subghz_protocol_encoder_scher_khan_alloc(SubGhzEnvironment* environment);
+void subghz_protocol_encoder_scher_khan_free(void* context);
+SubGhzProtocolStatus
+    subghz_protocol_encoder_scher_khan_deserialize(void* context, FlipperFormat* flipper_format);
+void subghz_protocol_encoder_scher_khan_stop(void* context);
+LevelDuration subghz_protocol_encoder_scher_khan_yield(void* context);

lib/subghz/protocols/star_line.c

@@ -10,33 +10,51 @@ 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";
+    case 0x03: return "Trunk";
+    case 0x04: return "Aux/Panic";
+    case 0x21: return "Lock";
+    case 0x22: return "Unlock";
+    case 0x23: return "Trunk";
+    case 0x24: return "Start";
+    case 0x25: return "Stop";
+    case 0x26: return "Extra";
     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;
+    case 0x01:
+    case 0x21: return 1;
+    case 0x02:
+    case 0x22: return 2;
+    case 0x03:
+    case 0x23: return 3;
+    case 0x04:
+    case 0x24: return 4;
+    case 0x25: return 5;
+    case 0x26: return 6;
+    default:   return 1;
     }
 }
 
 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;
+    bool is_twage = (original_btn & 0x20) != 0;
+
+    switch(custom) {
+    case 1: return is_twage ? 0x21 : 0x01;
+    case 2: return is_twage ? 0x22 : 0x02;
+    case 3: return is_twage ? 0x23 : 0x03;
+    case 4: return is_twage ? 0x24 : 0x04;
+    case 5: return 0x25;
+    case 6: return 0x26;
+    default: return original_btn;
+    }
 }
 
 static uint8_t star_line_get_btn_code(uint8_t original_btn) {
     uint8_t custom = subghz_custom_btn_get();
+    if(custom == SUBGHZ_CUSTOM_BTN_OK) return original_btn;
     return star_line_custom_to_btn(custom, original_btn);
 }
 
@@ -976,13 +994,39 @@ void subghz_protocol_decoder_star_line_get_string(void* context, FuriString* out
     uint32_t code_found_reverse_hi = code_found_reverse >> 32;
     uint32_t code_found_reverse_lo = code_found_reverse & 0x00000000ffffffff;
 
+    uint8_t display_btn;
+    uint8_t custom = subghz_custom_btn_get();
+    if(custom == SUBGHZ_CUSTOM_BTN_OK) {
+        display_btn = instance->generic.btn;
+    } else {
+        display_btn = star_line_custom_to_btn(custom, instance->generic.btn);
+    }
+
+    //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(display_btn),
+    //    instance->manufacture_name);
+//}
+
+
     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",
+        "Hop:0x%08lX    Btn:[%s]\r\n",
         instance->generic.protocol_name,
         instance->generic.data_count_bit,
         code_found_hi,
@@ -990,6 +1034,6 @@ void subghz_protocol_decoder_star_line_get_string(void* context, FuriString* out
         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);
+        star_line_btn_name(display_btn)
+    );
 }