SubGhz: add protocol BinRAW (binarization of data quantized by the minimum correlated duration) (#2322)

* SubGhz: add protocol DataRAW (binarization of data quantized by the minimum correlated duration)
* SubGhz: fix name history
* SubGhz: add encoder Data_RAW protocol
* SubGhz: decreasing the size of the LevelDuration structure
* SubGhz: history, added check that there is free RAM
* SubGhz: checking for free memory, support to pass without gap
* SubGhz: add running average to average the result, auto cut noise at the end of a burst
* SubGhz: support for repeating sequences
* SubGhz: fix secplus_v2 decoder
* SubGhz: bin_RAW fix add history
* SubGhz: add debug
* SubGhz: debug refactoring
* FURI_LOG: add FURI_LOG_RAW_x formatted string output like printf
* SubGhz: fix new FURI_LOG metod
* FURI_LOG: fix unit test
* SubGhz: add enable/disable BinRAW protocol decoding
* SubGhz: fix PVS
* SubGhz: forcibly turn off the speaker when exiting SubGhz
* SubGhz: adaptive adjustment to the noise level

Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>

lib/subghz/blocks/encoder.c

@@ -2,6 +2,8 @@
 #include "math.h"
 #include <core/check.h>
 
+#include "furi.h"
+
 #define TAG "SubGhzBlockEncoder"
 
 void subghz_protocol_blocks_set_bit_array(
@@ -17,21 +19,32 @@ bool subghz_protocol_blocks_get_bit_array(uint8_t data_array[], size_t read_inde
     return bit_read(data_array[read_index_bit >> 3], 7 - (read_index_bit & 0x7));
 }
 
-size_t subghz_protocol_blocks_get_upload(
+size_t subghz_protocol_blocks_get_upload_from_bit_array(
     uint8_t data_array[],
     size_t count_bit_data_array,
     LevelDuration* upload,
     size_t max_size_upload,
-    uint32_t duration_bit) {
-    size_t index_bit = 0;
+    uint32_t duration_bit,
+    SubGhzProtocolBlockAlignBit align_bit) {
+    size_t bias_bit = 0;
     size_t size_upload = 0;
     uint32_t duration = duration_bit;
+
+    if(align_bit == SubGhzProtocolBlockAlignBitRight) {
+        if(count_bit_data_array & 0x7) {
+            bias_bit = 8 - (count_bit_data_array & 0x7);
+        }
+    }
+    size_t index_bit = bias_bit;
+
     bool last_bit = subghz_protocol_blocks_get_bit_array(data_array, index_bit++);
-    for(size_t i = 1; i < count_bit_data_array; i++) {
+    for(size_t i = 1 + bias_bit; i < count_bit_data_array + bias_bit; i++) {
         if(last_bit == subghz_protocol_blocks_get_bit_array(data_array, index_bit)) {
             duration += duration_bit;
         } else {
-            furi_assert(max_size_upload > size_upload);
+            if(size_upload > max_size_upload) {
+                furi_crash("SubGhz: Encoder buffer overflow");
+            }
             upload[size_upload++] = level_duration_make(
                 subghz_protocol_blocks_get_bit_array(data_array, index_bit - 1), duration);
             last_bit = !last_bit;

lib/subghz/blocks/encoder.h

@@ -19,6 +19,11 @@ typedef struct {
 
 } SubGhzProtocolBlockEncoder;
 
+typedef enum {
+    SubGhzProtocolBlockAlignBitLeft,
+    SubGhzProtocolBlockAlignBitRight,
+} SubGhzProtocolBlockAlignBit;
+
 /**
  * Set data bit when encoding HEX array.
  * @param bit_value The value of the bit to be set
@@ -47,13 +52,15 @@ bool subghz_protocol_blocks_get_bit_array(uint8_t data_array[], size_t read_inde
  * @param upload Pointer to a LevelDuration
  * @param max_size_upload upload size, check not to overflow
  * @param duration_bit duration 1 bit
+ * @param align_bit alignment of useful bits in an array
  */
-size_t subghz_protocol_blocks_get_upload(
+size_t subghz_protocol_blocks_get_upload_from_bit_array(
     uint8_t data_array[],
     size_t count_bit_data_array,
     LevelDuration* upload,
     size_t max_size_upload,
-    uint32_t duration_bit);
+    uint32_t duration_bit,
+    SubGhzProtocolBlockAlignBit align_bit);
 
 #ifdef __cplusplus
 }

lib/subghz/blocks/generic.c

@@ -100,7 +100,7 @@ bool subghz_block_generic_deserialize(SubGhzBlockGeneric* instance, FlipperForma
             FURI_LOG_E(TAG, "Missing Bit");
             break;
         }
-        instance->data_count_bit = (uint8_t)temp_data;
+        instance->data_count_bit = (uint16_t)temp_data;
 
         uint8_t key_data[sizeof(uint64_t)] = {0};
         if(!flipper_format_read_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {

lib/subghz/blocks/generic.h

@@ -19,7 +19,7 @@ struct SubGhzBlockGeneric {
     const char* protocol_name;
     uint64_t data;
     uint32_t serial;
-    uint8_t data_count_bit;
+    uint16_t data_count_bit;
     uint8_t btn;
     uint32_t cnt;
 };

lib/subghz/protocols/bin_raw.h

@@ -0,0 +1,111 @@
+#pragma once
+
+#include "base.h"
+
+#define SUBGHZ_PROTOCOL_BIN_RAW_NAME "BinRAW"
+
+typedef struct SubGhzProtocolDecoderBinRAW SubGhzProtocolDecoderBinRAW;
+typedef struct SubGhzProtocolEncoderBinRAW SubGhzProtocolEncoderBinRAW;
+
+extern const SubGhzProtocolDecoder subghz_protocol_bin_raw_decoder;
+extern const SubGhzProtocolEncoder subghz_protocol_bin_raw_encoder;
+extern const SubGhzProtocol subghz_protocol_bin_raw;
+
+/**
+ * Allocate SubGhzProtocolEncoderBinRAW.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolEncoderBinRAW* pointer to a SubGhzProtocolEncoderBinRAW instance
+ */
+void* subghz_protocol_encoder_bin_raw_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolEncoderBinRAW.
+ * @param context Pointer to a SubGhzProtocolEncoderBinRAW instance
+ */
+void subghz_protocol_encoder_bin_raw_free(void* context);
+
+/**
+ * Deserialize and generating an upload to send.
+ * @param context Pointer to a SubGhzProtocolEncoderBinRAW instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return true On success
+ */
+bool subghz_protocol_encoder_bin_raw_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Forced transmission stop.
+ * @param context Pointer to a SubGhzProtocolEncoderBinRAW instance
+ */
+void subghz_protocol_encoder_bin_raw_stop(void* context);
+
+/**
+ * Getting the level and duration of the upload to be loaded into DMA.
+ * @param context Pointer to a SubGhzProtocolEncoderBinRAW instance
+ * @return LevelDuration 
+ */
+LevelDuration subghz_protocol_encoder_bin_raw_yield(void* context);
+
+/**
+ * Allocate SubGhzProtocolDecoderBinRAW.
+ * @param environment Pointer to a SubGhzEnvironment instance
+ * @return SubGhzProtocolDecoderBinRAW* pointer to a SubGhzProtocolDecoderBinRAW instance
+ */
+void* subghz_protocol_decoder_bin_raw_alloc(SubGhzEnvironment* environment);
+
+/**
+ * Free SubGhzProtocolDecoderBinRAW.
+ * @param context Pointer to a SubGhzProtocolDecoderBinRAW instance
+ */
+void subghz_protocol_decoder_bin_raw_free(void* context);
+
+/**
+ * Reset decoder SubGhzProtocolDecoderBinRAW.
+ * @param context Pointer to a SubGhzProtocolDecoderBinRAW instance
+ */
+void subghz_protocol_decoder_bin_raw_reset(void* context);
+
+/**
+ * Parse a raw sequence of levels and durations received from the air.
+ * @param context Pointer to a SubGhzProtocolDecoderBinRAW instance
+ * @param level Signal level true-high false-low
+ * @param duration Duration of this level in, us
+ */
+void subghz_protocol_decoder_bin_raw_feed(void* context, bool level, uint32_t duration);
+
+/**
+ * Getting the hash sum of the last randomly received parcel.
+ * @param context Pointer to a SubGhzProtocolDecoderBinRAW instance
+ * @return hash Hash sum
+ */
+uint8_t subghz_protocol_decoder_bin_raw_get_hash_data(void* context);
+
+void subghz_protocol_decoder_bin_raw_data_input_rssi(
+    SubGhzProtocolDecoderBinRAW* instance,
+    float rssi);
+
+/**
+ * Serialize data SubGhzProtocolDecoderBinRAW.
+ * @param context Pointer to a SubGhzProtocolDecoderBinRAW instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @param preset The modulation on which the signal was received, SubGhzRadioPreset
+ * @return true On success
+ */
+bool subghz_protocol_decoder_bin_raw_serialize(
+    void* context,
+    FlipperFormat* flipper_format,
+    SubGhzRadioPreset* preset);
+
+/**
+ * Deserialize data SubGhzProtocolDecoderBinRAW.
+ * @param context Pointer to a SubGhzProtocolDecoderBinRAW instance
+ * @param flipper_format Pointer to a FlipperFormat instance
+ * @return true On success
+ */
+bool subghz_protocol_decoder_bin_raw_deserialize(void* context, FlipperFormat* flipper_format);
+
+/**
+ * Getting a textual representation of the received data.
+ * @param context Pointer to a SubGhzProtocolDecoderBinRAW instance
+ * @param output Resulting text
+ */
+void subghz_protocol_decoder_bin_raw_get_string(void* context, FuriString* output);

lib/subghz/protocols/chamberlain_code.c

@@ -196,12 +196,13 @@ static bool
         break;
     }
 
-    instance->encoder.size_upload = subghz_protocol_blocks_get_upload(
+    instance->encoder.size_upload = subghz_protocol_blocks_get_upload_from_bit_array(
         upload_hex_data,
         upload_hex_count_bit,
         instance->encoder.upload,
         instance->encoder.size_upload,
-        subghz_protocol_chamb_code_const.te_short);
+        subghz_protocol_chamb_code_const.te_short,
+        SubGhzProtocolBlockAlignBitLeft);
 
     return true;
 }

lib/subghz/protocols/protocol_items.c

@@ -42,6 +42,7 @@ const SubGhzProtocol* subghz_protocol_registry_items[] = {
     &subghz_protocol_dooya,
     &subghz_protocol_alutech_at_4n,
     &subghz_protocol_kinggates_stylo_4k,
+    &subghz_protocol_bin_raw,
 };
 
 const SubGhzProtocolRegistry subghz_protocol_registry = {

lib/subghz/protocols/protocol_items.h

@@ -42,5 +42,6 @@
 #include "dooya.h"
 #include "alutech_at_4n.h"
 #include "kinggates_stylo_4k.h"
+#include "bin_raw.h"
 
 extern const SubGhzProtocolRegistry subghz_protocol_registry;

lib/subghz/protocols/secplus_v2.c

@@ -261,16 +261,16 @@ static bool
     data = order << 4 | invert;
     int k = 0;
     for(int i = 6; i >= 0; i -= 2) {
-        roll_array[k++] = (data >> i) & 0x03;
-        if(roll_array[k] == 3) {
+        roll_array[k] = (data >> i) & 0x03;
+        if(roll_array[k++] == 3) {
             FURI_LOG_E(TAG, "Roll_Array FAIL");
             return false;
         }
     }
 
     for(int i = 8; i >= 0; i -= 2) {
-        roll_array[k++] = (p[2] >> i) & 0x03;
-        if(roll_array[k] == 3) {
+        roll_array[k] = (p[2] >> i) & 0x03;
+        if(roll_array[k++] == 3) {
             FURI_LOG_E(TAG, "Roll_Array FAIL");
             return false;
         }

lib/subghz/receiver.c

@@ -64,7 +64,7 @@ void subghz_receiver_decode(SubGhzReceiver* instance, bool level, uint32_t durat
 
     for
         M_EACH(slot, instance->slots, SubGhzReceiverSlotArray_t) {
-            if((slot->base->protocol->flag & instance->filter) == instance->filter) {
+            if((slot->base->protocol->flag & instance->filter) != 0) {
                 slot->base->protocol->decoder->feed(slot->base, level, duration);
             }
         }

lib/subghz/types.h

@@ -90,6 +90,7 @@ typedef enum {
     SubGhzProtocolFlag_Save = (1 << 7),
     SubGhzProtocolFlag_Load = (1 << 8),
     SubGhzProtocolFlag_Send = (1 << 9),
+    SubGhzProtocolFlag_BinRAW = (1 << 10),
 } SubGhzProtocolFlag;
 
 typedef struct {

lib/toolbox/level_duration.h

@@ -13,8 +13,8 @@
 #define LEVEL_DURATION_RESERVED 0x800000U
 
 typedef struct {
-    uint32_t level;
-    uint32_t duration;
+    uint32_t duration : 30;
+    uint8_t level : 2;
 } LevelDuration;
 
 static inline LevelDuration level_duration_make(bool level, uint32_t duration) {