FPS_CAME = 4,

FPS_PRASTEL = 5,
    FPS_AIRFORCE = 6,

firmware/application/apps/ui_subghzd.cpp

@@ -132,6 +132,12 @@ const char* SubGhzDView::getSensorTypeName(FPROTO_SUBGHZD_SENSOR type) {
             return "Princeton";
         case FPS_BETT:
             return "Bett";
+        case FPS_CAME:
+            return "Came";
+        case FPS_PRASTEL:
+            return "Prastel";
+        case FPS_AIRFORCE:
+            return "Airforce";
         case FPS_Invalid:
         default:
             return "Unknown";

firmware/application/ui_navigation.cpp

@@ -568,7 +568,7 @@ ReceiversMenuView::ReceiversMenuView(NavigationView& nav) {
         {"Search", Color::yellow(), &bitmap_icon_search, [&nav]() { nav.push<SearchView>(); }},
         {"TPMS Cars", Color::green(), &bitmap_icon_tpms, [&nav]() { nav.push<TPMSAppView>(); }},
         {"Weather", Color::yellow(), &bitmap_icon_lge, [&nav]() { nav.push<WeatherView>(); }},
-        {"SubGhzD", Color::yellow(), &bitmap_icon_lge, [&nav]() { nav.push<SubGhzDView>(); }},
+        {"SubGhzD", Color::yellow(), &bitmap_icon_remote, [&nav]() { nav.push<SubGhzDView>(); }},
         // {"FSK RX", Color::yellow(), &bitmap_icon_remote, [&nav]() { nav.push<FskxRxMainView>(); }},
         // {"DMR", Color::dark_grey(), &bitmap_icon_dmr, [&nav](){ nav.push<NotImplementedView>(); }},
         // {"SIGFOX", Color::dark_grey(), &bitmap_icon_fox, [&nav](){ nav.push<NotImplementedView>(); }},

firmware/baseband/fprotos/s-came.hpp

@@ -0,0 +1,102 @@
+
+#ifndef __FPROTO_CAME_H__
+#define __FPROTO_CAME_H__
+
+#include "subghzdbase.hpp"
+
+#define CAME_12_COUNT_BIT 12
+#define CAME_24_COUNT_BIT 24
+#define PRASTEL_COUNT_BIT 25
+#define AIRFORCE_COUNT_BIT 18
+
+typedef enum {
+    CameDecoderStepReset = 0,
+    CameDecoderStepFoundStartBit,
+    CameDecoderStepSaveDuration,
+    CameDecoderStepCheckDuration,
+} CameDecoderStep;
+
+class FProtoSubGhzDCame : public FProtoSubGhzDBase {
+   public:
+    FProtoSubGhzDCame() {
+        sensorType = FPS_CAME;
+    }
+
+    void feed(bool level, uint32_t duration) {
+        switch (parser_step) {
+            case CameDecoderStepReset:
+                if ((!level) && (DURATION_DIFF(duration, te_short * 56) < te_delta * 47)) {
+                    // Found header CAME
+                    parser_step = CameDecoderStepFoundStartBit;
+                }
+                break;
+            case CameDecoderStepFoundStartBit:
+                if (!level) {
+                    break;
+                } else if (
+                    DURATION_DIFF(duration, te_short) < te_delta) {
+                    // Found start bit CAME
+                    parser_step = CameDecoderStepSaveDuration;
+                    decode_data = 0;
+                    decode_count_bit = 0;
+                } else {
+                    parser_step = CameDecoderStepReset;
+                }
+                break;
+            case CameDecoderStepSaveDuration:
+                if (!level) {  // save interval
+                    if (duration >= (te_short * 4)) {
+                        parser_step = CameDecoderStepFoundStartBit;
+                        if ((decode_count_bit == min_count_bit_for_found) ||
+                            (decode_count_bit == AIRFORCE_COUNT_BIT) ||
+                            (decode_count_bit == PRASTEL_COUNT_BIT) ||
+                            (decode_count_bit == CAME_24_COUNT_BIT)) {
+                            serial = SD_NO_SERIAL;
+                            btn = SD_NO_BTN;
+                            data = decode_data;
+                            data_count_bit = decode_count_bit;
+                            // if flippa hacky, i hacky
+                            if (decode_count_bit == PRASTEL_COUNT_BIT) sensorType = FPS_PRASTEL;
+                            if (decode_count_bit == AIRFORCE_COUNT_BIT) sensorType = FPS_AIRFORCE;
+                            if (callback) callback(this);
+                        }
+                        break;
+                    }
+                    te_last = duration;
+                    parser_step = CameDecoderStepCheckDuration;
+                } else {
+                    parser_step = CameDecoderStepReset;
+                }
+                break;
+            case CameDecoderStepCheckDuration:
+                if (level) {
+                    if ((DURATION_DIFF(te_last, te_short) <
+                         te_delta) &&
+                        (DURATION_DIFF(duration, te_long) <
+                         te_delta)) {
+                        subghz_protocol_blocks_add_bit(0);
+                        parser_step = CameDecoderStepSaveDuration;
+                    } else if (
+                        (DURATION_DIFF(te_last, te_long) <
+                         te_delta) &&
+                        (DURATION_DIFF(duration, te_short) <
+                         te_delta)) {
+                        subghz_protocol_blocks_add_bit(1);
+                        parser_step = CameDecoderStepSaveDuration;
+                    } else
+                        parser_step = CameDecoderStepReset;
+                } else {
+                    parser_step = CameDecoderStepReset;
+                }
+                break;
+        }
+    }
+
+   protected:
+    uint32_t te_short = 320;
+    uint32_t te_long = 640;
+    uint32_t te_delta = 150;
+    uint32_t min_count_bit_for_found = 12;
+};
+
+#endif

firmware/baseband/fprotos/subghzdprotos.hpp

@@ -13,6 +13,7 @@ So include here the .hpp, and add a new element to the protos vector in the cons
 #include "s-ansonic.hpp"
 #include "s-princeton.hpp"
 #include "s-bett.hpp"
+#include "s-came.hpp"
 
 #ifndef __FPROTO_PROTOLISTSGZ_H__
 #define __FPROTO_PROTOLISTSGZ_H__
@@ -24,6 +25,7 @@ class SubGhzDProtos : public FProtoListGeneral {
         protos.push_back(std::make_unique<FProtoSubGhzDAnsonic>());    // 1
         protos.push_back(std::make_unique<FProtoSubGhzDPrinceton>());  // 2
         protos.push_back(std::make_unique<FProtoSubGhzDBett>());       // 3
+        protos.push_back(std::make_unique<FProtoSubGhzDCame>());       // 4, 5, 6
 
         // set callback for them
         for (const auto& obj : protos) {

firmware/baseband/fprotos/subghztypes.hpp

@@ -22,6 +22,9 @@ enum FPROTO_SUBGHZD_SENSOR {
     FPS_ANSONIC = 1,
     FPS_PRINCETON = 2,
     FPS_BETT = 3,
+    FPS_CAME = 4,
+    FPS_PRASTEL = 5,
+    FPS_AIRFORCE = 6,
 };
 
 #endif