[FL-1815, FL-1851, FL-1856] SubGhz: preparation for certification, add deleting stored signals and rename file in SubGHz app (#714)

* [FL-1811] FuriHal: move core2 startup to hal init stage, prevent working with flash controller till core2 startup finish. #704 * SubGhz: fix GO0 low on last hop transmission, decreased DutyCycle in tests * SubGhz: test_static fix max 5 sec in transmission mode, DutyCycle <23% * [FL-1815] SubGhz: prohibiting transmission if it is not within the permitted range for the given region * SubGhz: fix F7 furi-hal-subghz * SubGhz: fix logic working tests * SubGhz: fix princeton encoder for test * SubGhz: add log princeton encoder * [FL-1856] Subghz: fix output a double error if the file cannot be opened * [FL-1851] SubGhz: add deleting Stored Signals in SubGHz App * SubGhz: add rename file SubGhz app * SubGhz: update stats message in princeton * SubGhz: correct spelling * SubGhz: fix FM config, add hardware signal processing less than 16 μs, add added filter for processing short signals * SubGhz: add Scher-Khan MAGICAR Dinamic protocol * SubGhz: sync fury targets Co-authored-by: あく <alleteam@gmail.com>
2021-09-28 04:05:40 +04:00
parent 416e1bda35
commit a8981d317a
32 changed files with 1111 additions and 152 deletions
--- a/lib/subghz/protocols/subghz_protocol_princeton.c
+++ b/lib/subghz/protocols/subghz_protocol_princeton.c
@@ -8,12 +8,17 @@
 #define SUBGHZ_PT_SHORT 400
 #define SUBGHZ_PT_LONG (SUBGHZ_PT_SHORT * 3)
 #define SUBGHZ_PT_GUARD (SUBGHZ_PT_SHORT * 30)
+#define SUBGHZ_PT_COUNT_KEY 5
+#define SUBGHZ_PT_TIMEOUT 320

 struct SubGhzEncoderPrinceton {
    uint32_t key;
    uint16_t te;
    size_t repeat;
    size_t front;
+    size_t count_key;
+    uint32_t time_high;
+    uint32_t time_low;
 };

 typedef enum {
@@ -45,8 +50,11 @@ void subghz_encoder_princeton_set(SubGhzEncoderPrinceton* instance, uint32_t key
    furi_assert(instance);
    instance->te = SUBGHZ_PT_SHORT;
    instance->key = key;
-    instance->repeat = repeat;
+    instance->repeat = repeat + 1;
    instance->front = 48;
+    instance->count_key = SUBGHZ_PT_COUNT_KEY + 7;
+    instance->time_high = 0;
+    instance->time_low = 0;
 }

 size_t subghz_encoder_princeton_get_repeat_left(SubGhzEncoderPrinceton* instance) {
@@ -54,9 +62,25 @@ size_t subghz_encoder_princeton_get_repeat_left(SubGhzEncoderPrinceton* instance
    return instance->repeat;
 }

+void subghz_encoder_princeton_print_log(void* context) {
+    SubGhzEncoderPrinceton* instance = context;
+    float duty_cycle =
+        ((float)instance->time_high / (instance->time_high + instance->time_low)) * 100;
+    FURI_LOG_I(
+        "EncoderPrinceton",
+        "Radio ON=%dus, OFF=%dus, DutyCycle=%d,%d%%",
+        instance->time_high,
+        instance->time_low,
+        (uint32_t)duty_cycle,
+        (uint32_t)((duty_cycle - (uint32_t)duty_cycle) * 100));
+}
+
 LevelDuration subghz_encoder_princeton_yield(void* context) {
    SubGhzEncoderPrinceton* instance = context;
-    if(instance->repeat == 0) return level_duration_reset();
+    if(instance->repeat == 0) {
+        subghz_encoder_princeton_print_log(instance);
+        return level_duration_reset();
+    }

    size_t bit = instance->front / 2;
    bool level = !(instance->front % 2);
@@ -68,11 +92,33 @@ LevelDuration subghz_encoder_princeton_yield(void* context) {
        bool value = (((uint8_t*)&instance->key)[2 - byte] >> (7 - bit_in_byte)) & 1;
        if(value) {
            ret = level_duration_make(level, level ? instance->te * 3 : instance->te);
+            if(level)
+                instance->time_high += instance->te * 3;
+            else
+                instance->time_low += instance->te;
        } else {
            ret = level_duration_make(level, level ? instance->te : instance->te * 3);
+            if(level)
+                instance->time_high += instance->te;
+            else
+                instance->time_low += instance->te * 3;
        }
    } else {
-        ret = level_duration_make(level, level ? instance->te : instance->te * 30);
+        if(--instance->count_key != 0) {
+            ret = level_duration_make(level, level ? instance->te : instance->te * 30);
+            if(level)
+                instance->time_high += instance->te;
+            else
+                instance->time_low += instance->te * 30;
+        } else {
+            instance->count_key = SUBGHZ_PT_COUNT_KEY + 6;
+            instance->front = 48;
+            ret = level_duration_make(level, level ? instance->te : SUBGHZ_PT_TIMEOUT * 1000);
+            if(level)
+                instance->time_high += instance->te;
+            else
+                instance->time_low += SUBGHZ_PT_TIMEOUT * 1000;
+        }
    }

    instance->front++;
--- a/lib/subghz/protocols/subghz_protocol_princeton.h
+++ b/lib/subghz/protocols/subghz_protocol_princeton.h
@@ -33,6 +33,11 @@ void subghz_encoder_princeton_set(SubGhzEncoderPrinceton* instance, uint32_t key
 */
 size_t subghz_encoder_princeton_get_repeat_left(SubGhzEncoderPrinceton* instance);

+/** Print encoder log
+ * @param instance - SubGhzEncoderPrinceton instance
+ */
+void subghz_encoder_princeton_print_log(void* context);
+
 /** Get level duration
 * @param instance - SubGhzEncoderPrinceton instance
 * @return level duration
--- a/lib/subghz/protocols/subghz_protocol_scher_khan.c
+++ b/lib/subghz/protocols/subghz_protocol_scher_khan.c
@@ -0,0 +1,246 @@
+#include "subghz_protocol_scher_khan.h"
+
+//https://phreakerclub.com/72
+//https://phreakerclub.com/forum/showthread.php?t=7&page=2
+//https://phreakerclub.com/forum/showthread.php?t=274&highlight=magicar
+//!!!  https://phreakerclub.com/forum/showthread.php?t=489&highlight=magicar&page=5
+
+struct SubGhzProtocolScherKhan {
+    SubGhzProtocolCommon common;
+    const char* protocol_name;
+};
+
+typedef enum {
+    ScherKhanDecoderStepReset = 0,
+    ScherKhanDecoderStepCheckPreambula,
+    ScherKhanDecoderStepSaveDuration,
+    ScherKhanDecoderStepCheckDuration,
+} ScherKhanDecoderStep;
+
+SubGhzProtocolScherKhan* subghz_protocol_scher_khan_alloc(void) {
+    SubGhzProtocolScherKhan* instance = furi_alloc(sizeof(SubGhzProtocolScherKhan));
+
+    instance->common.name = "Scher-Khan";
+    instance->common.code_min_count_bit_for_found = 35;
+    instance->common.te_short = 750;
+    instance->common.te_long = 1100;
+    instance->common.te_delta = 150;
+    instance->common.type_protocol = SubGhzProtocolCommonTypeDynamic;
+    instance->common.to_string = (SubGhzProtocolCommonToStr)subghz_protocol_scher_khan_to_str;
+    instance->common.to_load_protocol =
+        (SubGhzProtocolCommonLoadFromRAW)subghz_decoder_scher_khan_to_load_protocol;
+
+    return instance;
+}
+
+void subghz_protocol_scher_khan_free(SubGhzProtocolScherKhan* instance) {
+    furi_assert(instance);
+    free(instance);
+}
+
+/** Send bit 
+ * 
+ * @param instance - SubGhzProtocolScherKhan instance
+ * @param bit - bit
+ */
+// void subghz_protocol_scher_khan_send_bit(SubGhzProtocolScherKhan* instance, uint8_t bit) {
+//     if(bit) {
+//         //send bit 1
+//         SUBGHZ_TX_PIN_HIGH();
+//         delay_us(instance->common.te_long);
+//         SUBGHZ_TX_PIN_LOW();
+//         delay_us(instance->common.te_short);
+//     } else {
+//         //send bit 0
+//         SUBGHZ_TX_PIN_HIGH();
+//         delay_us(instance->common.te_short);
+//         SUBGHZ_TX_PIN_LOW();
+//         delay_us(instance->common.te_long);
+//     }
+// }
+
+// void subghz_protocol_scher_khan_send_key(
+//     SubGhzProtocolScherKhan* instance,
+//     uint64_t key,
+//     uint8_t bit,
+//     uint8_t repeat) {
+//     while(repeat--) {
+//         SUBGHZ_TX_PIN_HIGH();
+//         //Send header
+//         delay_us(instance->common.te_long * 2);
+//         SUBGHZ_TX_PIN_LOW();
+//         delay_us(instance->common.te_long * 2);
+//         //Send key data
+//         for(uint8_t i = bit; i > 0; i--) {
+//             subghz_protocol_scher_khan_send_bit(instance, bit_read(key, i - 1));
+//         }
+//     }
+// }
+
+void subghz_protocol_scher_khan_reset(SubGhzProtocolScherKhan* instance) {
+    instance->common.parser_step = ScherKhanDecoderStepReset;
+}
+
+/** Analysis of received data
+ * 
+ * @param instance SubGhzProtocolScherKhan instance
+ */
+void subghz_protocol_scher_khan_check_remote_controller(SubGhzProtocolScherKhan* instance) {
+    /* 
+    * MAGICAR 51 bit 00000001A99121DE83C3 MAGIC CODE, Dinamic
+    * 0E8C1619E830C -> 000011101000110000010110 0001 1001 1110 1000001100001100
+    * 0E8C1629D830D -> 000011101000110000010110 0010 1001 1101 1000001100001101
+    * 0E8C1649B830E -> 000011101000110000010110 0100 1001 1011 1000001100001110
+    * 0E8C16897830F -> 000011101000110000010110 1000 1001 0111 1000001100001111
+    *                             Serial         Key  Ser ~Key   CNT
+    */
+
+    switch(instance->common.code_last_count_bit) {
+    // case 35: //MAGIC CODE, Static
+    //     instance->protocol_name = "MAGIC CODE, Static";
+    //     break;
+    case 51: //MAGIC CODE, Dinamic
+        instance->protocol_name = "MAGIC CODE, Dinamic";
+        instance->common.serial = ((instance->common.code_last_found >> 24) & 0xFFFFFF0) |
+                                  ((instance->common.code_last_found >> 20) & 0x0F);
+        instance->common.btn = (instance->common.code_last_found >> 24) & 0x0F;
+        instance->common.cnt = instance->common.code_last_found & 0xFFFF;
+        break;
+        // case 57: //MAGIC CODE PRO / PRO2
+        //     instance->protocol_name = "MAGIC CODE PRO / PRO2";
+        //     break;
+
+    default:
+        instance->protocol_name = "Unknown";
+        instance->common.serial = 0;
+        instance->common.btn = 0;
+        instance->common.cnt = 0;
+        break;
+    }
+}
+
+void subghz_protocol_scher_khan_parse(
+    SubGhzProtocolScherKhan* instance,
+    bool level,
+    uint32_t duration) {
+    switch(instance->common.parser_step) {
+    case ScherKhanDecoderStepReset:
+        if((level) &&
+           (DURATION_DIFF(duration, instance->common.te_short * 2) < instance->common.te_delta)) {
+            instance->common.parser_step = ScherKhanDecoderStepCheckPreambula;
+            instance->common.te_last = duration;
+            instance->common.header_count = 0;
+        } else {
+            instance->common.parser_step = ScherKhanDecoderStepReset;
+        }
+        break;
+    case ScherKhanDecoderStepCheckPreambula:
+        if(level) {
+            if((DURATION_DIFF(duration, instance->common.te_short * 2) <
+                instance->common.te_delta) ||
+               (DURATION_DIFF(duration, instance->common.te_short) < instance->common.te_delta)) {
+                instance->common.te_last = duration;
+            } else {
+                instance->common.parser_step = ScherKhanDecoderStepReset;
+            }
+        } else if(
+            (DURATION_DIFF(duration, instance->common.te_short * 2) < instance->common.te_delta) ||
+            (DURATION_DIFF(duration, instance->common.te_short) < instance->common.te_delta)) {
+            if(DURATION_DIFF(instance->common.te_last, instance->common.te_short * 2) <
+               instance->common.te_delta) {
+                // Found header
+                instance->common.header_count++;
+                break;
+            } else if(
+                DURATION_DIFF(instance->common.te_last, instance->common.te_short) <
+                instance->common.te_delta) {
+                // Found start bit
+                if(instance->common.header_count >= 2) {
+                    instance->common.parser_step = ScherKhanDecoderStepSaveDuration;
+                    instance->common.code_found = 0;
+                    instance->common.code_count_bit = 1;
+                } else {
+                    instance->common.parser_step = ScherKhanDecoderStepReset;
+                }
+            } else {
+                instance->common.parser_step = ScherKhanDecoderStepReset;
+            }
+        } else {
+            instance->common.parser_step = ScherKhanDecoderStepReset;
+        }
+        break;
+    case ScherKhanDecoderStepSaveDuration:
+        if(level) {
+            if(duration >= (instance->common.te_long + instance->common.te_delta * 2)) {
+                //Found stop bit
+                instance->common.parser_step = ScherKhanDecoderStepReset;
+                if(instance->common.code_count_bit >=
+                   instance->common.code_min_count_bit_for_found) {
+                    instance->common.code_last_found = instance->common.code_found;
+                    instance->common.code_last_count_bit = instance->common.code_count_bit;
+                    if(instance->common.callback)
+                        instance->common.callback(
+                            (SubGhzProtocolCommon*)instance, instance->common.context);
+                }
+                instance->common.code_found = 0;
+                instance->common.code_count_bit = 0;
+                break;
+            } else {
+                instance->common.te_last = duration;
+                instance->common.parser_step = ScherKhanDecoderStepCheckDuration;
+            }
+
+        } else {
+            instance->common.parser_step = ScherKhanDecoderStepReset;
+        }
+        break;
+    case ScherKhanDecoderStepCheckDuration:
+        if(!level) {
+            if((DURATION_DIFF(instance->common.te_last, instance->common.te_short) <
+                instance->common.te_delta) &&
+               (DURATION_DIFF(duration, instance->common.te_short) < instance->common.te_delta)) {
+                subghz_protocol_common_add_bit(&instance->common, 0);
+                instance->common.parser_step = ScherKhanDecoderStepSaveDuration;
+            } else if(
+                (DURATION_DIFF(instance->common.te_last, instance->common.te_long) <
+                 instance->common.te_delta) &&
+                (DURATION_DIFF(duration, instance->common.te_long) < instance->common.te_delta)) {
+                subghz_protocol_common_add_bit(&instance->common, 1);
+                instance->common.parser_step = ScherKhanDecoderStepSaveDuration;
+            } else {
+                instance->common.parser_step = ScherKhanDecoderStepReset;
+            }
+        } else {
+            instance->common.parser_step = ScherKhanDecoderStepReset;
+        }
+        break;
+    }
+}
+
+void subghz_protocol_scher_khan_to_str(SubGhzProtocolScherKhan* instance, string_t output) {
+    subghz_protocol_scher_khan_check_remote_controller(instance);
+
+    string_cat_printf(
+        output,
+        "%s %dbit\r\n"
+        "Key:0x%lX%08lX\r\n"
+        "Sn:%07lX Btn:%lX Cnt:%04X\r\n"
+        "Pt: %s\r\n",
+        instance->common.name,
+        instance->common.code_last_count_bit,
+        (uint32_t)(instance->common.code_last_found >> 32),
+        (uint32_t)instance->common.code_last_found,
+        instance->common.serial,
+        instance->common.btn,
+        instance->common.cnt,
+        instance->protocol_name);
+}
+
+void subghz_decoder_scher_khan_to_load_protocol(SubGhzProtocolScherKhan* instance, void* context) {
+    furi_assert(context);
+    furi_assert(instance);
+    SubGhzProtocolCommonLoad* data = context;
+    instance->common.code_last_found = data->code_found;
+    instance->common.code_last_count_bit = data->code_count_bit;
+    subghz_protocol_scher_khan_check_remote_controller(instance);
+}
--- a/lib/subghz/protocols/subghz_protocol_scher_khan.h
+++ b/lib/subghz/protocols/subghz_protocol_scher_khan.h
@@ -0,0 +1,58 @@
+#pragma once
+
+#include "subghz_protocol_common.h"
+
+typedef struct SubGhzProtocolScherKhan SubGhzProtocolScherKhan;
+
+/** Allocate SubGhzProtocolScherKhan
+ * 
+ * @return SubGhzProtocolScherKhan* 
+ */
+SubGhzProtocolScherKhan* subghz_protocol_scher_khan_alloc();
+
+/** Free SubGhzProtocolScherKhan
+ * 
+ * @param instance 
+ */
+void subghz_protocol_scher_khan_free(SubGhzProtocolScherKhan* instance);
+
+/** Sends the key on the air
+ * 
+ * @param instance - SubGhzProtocolScherKhan instance
+ * @param key - key send
+ * @param bit - count bit key
+ * @param repeat - repeat send key
+ */
+void subghz_protocol_scher_khan_send_key(SubGhzProtocolScherKhan* instance, uint64_t key, uint8_t bit, uint8_t repeat);
+
+/** Reset internal state
+ * @param instance - SubGhzProtocolScherKhan instance
+ */
+void subghz_protocol_scher_khan_reset(SubGhzProtocolScherKhan* instance);
+
+/** Analysis of received data
+ * 
+ * @param instance SubGhzProtocolScherKhan instance
+ */
+void subghz_protocol_scher_khan_check_remote_controller(SubGhzProtocolScherKhan* instance);
+
+/** Parse accepted duration
+ * 
+ * @param instance - SubGhzProtocolScherKhan instance
+ * @param data - LevelDuration level_duration
+ */
+void subghz_protocol_scher_khan_parse(SubGhzProtocolScherKhan* instance, bool level, uint32_t duration);
+
+/** Outputting information from the parser
+ * 
+ * @param instance - SubGhzProtocolScherKhan* instance
+ * @param output   - output string
+ */
+void subghz_protocol_scher_khan_to_str(SubGhzProtocolScherKhan* instance, string_t output);
+
+/** Loading protocol from bin data
+ * 
+ * @param instance - SubGhzProtocolScherKhan instance
+ * @param context - SubGhzProtocolCommonLoad context
+ */
+void subghz_decoder_scher_khan_to_load_protocol(SubGhzProtocolScherKhan* instance, void* context);