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,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();
@@ -511,7 +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);
-    }
+    } //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,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 <gui/gui.h>
 #include <gui/view_stack.h>

applications/services/desktop/scenes/desktop_scene_slideshow.c

@@ -30,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:

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)
+    );
 }