Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-04-24 03:29:57 -07:00
Code Issues Packages Projects Releases Wiki Activity

Merge remote-tracking branch 'ul/dev' into mntm-dev --nobuild

Browse Source
This commit is contained in:
WillyJL
2025-07-19 16:58:37 +01:00
parent b423f90b5c ac6621cdcb
commit bd88e42622
21 changed files with 1214 additions and 100 deletions
Download Patch File Download Diff File Expand all files Collapse all files

13
lib/subghz/protocols/keeloq.c
View File

@@ -239,9 +239,15 @@ static bool subghz_protocol_keeloq_gen_data(
(strcmp(instance->manufacture_name, "Mutanco_Mutancode") == 0) ||
(strcmp(instance->manufacture_name, "Came_Space") == 0) ||
(strcmp(instance->manufacture_name, "Genius_Bravo") == 0) ||
(strcmp(instance->manufacture_name, "GSN") == 0)) {
(strcmp(instance->manufacture_name, "GSN") == 0) ||
(strcmp(instance->manufacture_name, "Rosh") == 0) ||
(strcmp(instance->manufacture_name, "Rossi") == 0) ||
(strcmp(instance->manufacture_name, "Pecinin") == 0) ||
(strcmp(instance->manufacture_name, "Steelmate") == 0)) {
// DTM Neo, Came_Space uses 12bit serial -> simple learning
// FAAC_RC,XT , Mutanco_Mutancode, Genius_Bravo, GSN 12bit serial -> normal learning
// Rosh, Rossi, Pecinin -> 12bit serial - simple learning
// Steelmate -> 12bit serial - normal learning
decrypt = btn << 28 | (instance->generic.serial & 0xFFF) << 16 |
instance->generic.cnt;
} else if(
@@ -251,9 +257,12 @@ static bool subghz_protocol_keeloq_gen_data(
// Nice Smilo, MHouse, JCM -> 8bit serial - simple learning
decrypt = btn << 28 | (instance->generic.serial & 0xFF) << 16 |
instance->generic.cnt;
} else if(strcmp(instance->manufacture_name, "Beninca") == 0) {
} else if(
(strcmp(instance->manufacture_name, "Beninca") == 0) ||
(strcmp(instance->manufacture_name, "Merlin") == 0)) {
decrypt = btn << 28 | (0x000) << 16 | instance->generic.cnt;
// Beninca / Allmatic -> no serial - simple XOR
// Merlin -> no serial - simple XOR
} else if(strcmp(instance->manufacture_name, "Centurion") == 0) {
decrypt = btn << 28 | (0x1CE) << 16 | instance->generic.cnt;
// Centurion -> no serial in hop, uses fixed value 0x1CE - normal learning

34
lib/subghz/protocols/marantec.c
View File

@@ -167,7 +167,7 @@ static void subghz_protocol_encoder_marantec_get_upload(SubGhzProtocolEncoderMar
}
uint8_t subghz_protocol_marantec_crc8(uint8_t* data, size_t len) {
uint8_t crc = 0x08;
uint8_t crc = 0x01;
size_t i, j;
for(i = 0; i < len; i++) {
crc ^= data[i];
@@ -186,6 +186,18 @@ uint8_t subghz_protocol_marantec_crc8(uint8_t* data, size_t len) {
* @param instance Pointer to a SubGhzBlockGeneric* instance
*/
static void subghz_protocol_marantec_remote_controller(SubGhzBlockGeneric* instance) {
// Key samples
// 1307EDF6486C5 = 000 100110000 01111110110111110110 0100 10000110 11000101
// 1303EFAFD8683 = 000 100110000 00111110111110101111 1101 10000110 10000011
// From unittests
// 1300710DF869F
// const serial button serial crc
// 130 7EDF6 4 86 C5
// 130 3EFAF D 86 83
// 130 0710D F 86 9F
instance->btn = (instance->data >> 16) & 0xF;
instance->serial = ((instance->data >> 12) & 0xFFFFFF00) | ((instance->data >> 8) & 0xFF);
}
@@ -369,16 +381,30 @@ void subghz_protocol_decoder_marantec_get_string(void* context, FuriString* outp
SubGhzProtocolDecoderMarantec* instance = context;
subghz_protocol_marantec_remote_controller(&instance->generic);
uint8_t tdata[6] = {
instance->generic.data >> 48,
instance->generic.data >> 40,
instance->generic.data >> 32,
instance->generic.data >> 24,
instance->generic.data >> 16,
instance->generic.data >> 8};
uint8_t crc = subghz_protocol_marantec_crc8(tdata, sizeof(tdata));
bool crc_ok = (crc == (instance->generic.data & 0xFF));
furi_string_cat_printf(
output,
"%s %db\r\n"
"Key:0x%lX%08lX\r\n"
"Sn:0x%07lX \r\n"
"Btn:%X\r\n",
"Key: 0x%lX%08lX\r\n"
"Sn: 0x%07lX \r\n"
"CRC: 0x%02X - %s\r\n"
"Btn: %X\r\n",
instance->generic.protocol_name,
instance->generic.data_count_bit,
(uint32_t)(instance->generic.data >> 32),
(uint32_t)(instance->generic.data & 0xFFFFFFFF),
instance->generic.serial,
crc,
crc_ok ? "Valid" : "Invalid",
instance->generic.btn);
}

8
lib/subghz/protocols/marantec.h
View File

@@ -107,3 +107,11 @@ SubGhzProtocolStatus
* @param output Resulting text
*/
void subghz_protocol_decoder_marantec_get_string(void* context, FuriString* output);
/**
* Calculate CRC8 for Marantec protocol.
* @param data Pointer to the data buffer
* @param len Length of the data buffer
* @return CRC8 value
*/
uint8_t subghz_protocol_marantec_crc8(uint8_t* data, size_t len);

13
lib/subghz/protocols/marantec24.c
View File

@@ -219,6 +219,11 @@ void subghz_protocol_decoder_marantec24_feed(void* context, bool level, volatile
// Marantec24 Decoder
// 2024 - @xMasterX (MMX)
// 2025 update - The protocol is not real marantec,
// it comes from chinese remote that pretends to be replica of original marantec, actually it was a cloner
// which had some thing written on it, which is uknown, but since its pretentding to be marantec,
// it was decided to keep the name of the protocol as marantec24 (24 bits)
// Key samples
// 101011000000010111001000 = AC05C8
// 101011000000010111000100 = AC05C4
@@ -268,16 +273,12 @@ void subghz_protocol_decoder_marantec24_feed(void* context, bool level, volatile
//Found next GAP and add bit 0 or 1 (only bit 0 was found on the remotes)
if((DURATION_DIFF(
instance->decoder.te_last, subghz_protocol_marantec24_const.te_long) <
subghz_protocol_marantec24_const.te_delta) &&
(DURATION_DIFF(duration, subghz_protocol_marantec24_const.te_long * 9) <
subghz_protocol_marantec24_const.te_delta * 4)) {
subghz_protocol_marantec24_const.te_delta)) {
subghz_protocol_blocks_add_bit(&instance->decoder, 0);
}
if((DURATION_DIFF(
instance->decoder.te_last, subghz_protocol_marantec24_const.te_short) <
subghz_protocol_marantec24_const.te_delta) &&
(DURATION_DIFF(duration, subghz_protocol_marantec24_const.te_long * 9) <
subghz_protocol_marantec24_const.te_delta * 4)) {
subghz_protocol_marantec24_const.te_delta)) {
subghz_protocol_blocks_add_bit(&instance->decoder, 1);
}
// If got 24 bits key reading is finished

42
lib/subghz/protocols/nero_radio.c
View File

@@ -387,6 +387,36 @@ SubGhzProtocolStatus
}
}
/**
* Analysis of received data
* @param instance Pointer to a SubGhzBlockGeneric* instance
*/
static void subghz_protocol_nero_radio_parse_data(SubGhzBlockGeneric* instance) {
// Key samples from unit tests
// 57250501049DD3
// 57250502049D13
//
// Samples from remote
// 36E4E80104A644
// 36E4E80204A684
// 36E4E80304A604
// 36E4E80404A6E4
// possible contents
// serial button serial/const crc??
// 5725050 1 049D D3
// 5725050 2 049D 13
// 36E4E80 1 04A6 44
// 36E4E80 2 04A6 84
// 36E4E80 3 04A6 04
// 36E4E80 4 04A6 E4
// serial is larger than uint32 can't fit into serial field
// using data2 var since its uint64_t
instance->btn = (instance->data >> 24) & 0xF;
instance->data_2 = ((instance->data >> 28) << 16) | ((instance->data >> 8) & 0xFFFF);
}
void subghz_protocol_decoder_nero_radio_get_string(void* context, FuriString* output) {
furi_assert(context);
SubGhzProtocolDecoderNeroRadio* instance = context;
@@ -400,15 +430,23 @@ void subghz_protocol_decoder_nero_radio_get_string(void* context, FuriString* ou
uint32_t code_found_reverse_hi = code_found_reverse >> 32;
uint32_t code_found_reverse_lo = code_found_reverse & 0x00000000ffffffff;
subghz_protocol_nero_radio_parse_data(&instance->generic);
furi_string_cat_printf(
output,
"%s %dbit\r\n"
"Key:0x%lX%08lX\r\n"
"Yek:0x%lX%08lX\r\n",
"Yek:0x%lX%08lX\r\n"
"Sn: 0x%llX \r\n"
"CRC?: 0x%02X\r\n"
"Btn: %X\r\n",
instance->generic.protocol_name,
instance->generic.data_count_bit,
code_found_hi,
code_found_lo,
code_found_reverse_hi,
code_found_reverse_lo);
code_found_reverse_lo,
instance->generic.data_2,
(uint8_t)(instance->generic.data & 0xFF),
instance->generic.btn);
}

283
lib/subghz/protocols/phoenix_v2.c
View File

@@ -6,9 +6,9 @@
#include "../blocks/generic.h"
#include "../blocks/math.h"
#define TAG "SubGhzProtocolPhoenixV2"
#include "../blocks/custom_btn_i.h"
//transmission only static mode
#define TAG "SubGhzProtocolPhoenixV2"
static const SubGhzBlockConst subghz_protocol_phoenix_v2_const = {
.te_short = 427,
@@ -64,7 +64,7 @@ const SubGhzProtocolEncoder subghz_protocol_phoenix_v2_encoder = {
const SubGhzProtocol subghz_protocol_phoenix_v2 = {
.name = SUBGHZ_PROTOCOL_PHOENIX_V2_NAME,
.type = SubGhzProtocolTypeStatic,
.type = SubGhzProtocolTypeDynamic,
.flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
@@ -93,6 +93,138 @@ void subghz_protocol_encoder_phoenix_v2_free(void* context) {
free(instance);
}
// Pre define functions
static uint16_t subghz_protocol_phoenix_v2_encrypt_counter(uint64_t full_key, uint16_t counter);
static void subghz_protocol_phoenix_v2_check_remote_controller(SubGhzBlockGeneric* instance);
bool subghz_protocol_phoenix_v2_create_data(
void* context,
FlipperFormat* flipper_format,
uint32_t serial,
uint16_t cnt,
SubGhzRadioPreset* preset) {
furi_assert(context);
SubGhzProtocolEncoderPhoenix_V2* instance = context;
instance->generic.btn = 0x1;
instance->generic.serial = serial;
instance->generic.cnt = cnt;
instance->generic.data_count_bit = 52;
uint64_t local_data_rev =
(uint64_t)(((uint64_t)instance->generic.cnt << 40) |
((uint64_t)instance->generic.btn << 32) | (uint64_t)instance->generic.serial);
uint16_t encrypted_counter = (uint16_t)subghz_protocol_phoenix_v2_encrypt_counter(
local_data_rev, instance->generic.cnt);
instance->generic.data = subghz_protocol_blocks_reverse_key(
(uint64_t)(((uint64_t)encrypted_counter << 40) | ((uint64_t)instance->generic.btn << 32) |
(uint64_t)instance->generic.serial),
instance->generic.data_count_bit + 4);
return SubGhzProtocolStatusOk ==
subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
}
// Get custom button code
static uint8_t subghz_protocol_phoenix_v2_get_btn_code(void) {
uint8_t custom_btn_id = subghz_custom_btn_get();
uint8_t original_btn_code = subghz_custom_btn_get_original();
uint8_t btn = original_btn_code;
// Set custom button
if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
// Restore original button code
btn = original_btn_code;
} else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
switch(original_btn_code) {
case 0x1:
btn = 0x2;
break;
case 0x2:
btn = 0x1;
break;
case 0x4:
btn = 0x1;
break;
case 0x8:
btn = 0x1;
break;
case 0x3:
btn = 0x1;
break;
default:
break;
}
} else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
switch(original_btn_code) {
case 0x1:
btn = 0x4;
break;
case 0x2:
btn = 0x4;
break;
case 0x4:
btn = 0x2;
break;
case 0x8:
btn = 0x4;
break;
case 0x3:
btn = 0x4;
break;
default:
break;
}
} else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_LEFT) {
switch(original_btn_code) {
case 0x1:
btn = 0x8;
break;
case 0x2:
btn = 0x8;
break;
case 0x4:
btn = 0x8;
break;
case 0x8:
btn = 0x2;
break;
case 0x3:
btn = 0x8;
break;
default:
break;
}
} else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_RIGHT) {
switch(original_btn_code) {
case 0x1:
btn = 0x3;
break;
case 0x2:
btn = 0x3;
break;
case 0x4:
btn = 0x3;
break;
case 0x8:
btn = 0x3;
break;
case 0x3:
btn = 0x2;
break;
default:
break;
}
}
return btn;
}
/**
* Generating an upload from data.
* @param instance Pointer to a SubGhzProtocolEncoderPhoenix_V2 instance
@@ -109,6 +241,40 @@ static bool
} else {
instance->encoder.size_upload = size_upload;
}
uint8_t btn = instance->generic.btn;
// Save original button for later use
if(subghz_custom_btn_get_original() == 0) {
subghz_custom_btn_set_original(btn);
}
// Get custom button code
// This will override the btn variable if a custom button is set
btn = subghz_protocol_phoenix_v2_get_btn_code();
// Reconstruction of the data
if(instance->generic.cnt < 0xFFFF) {
if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFF) {
instance->generic.cnt = 0;
} else {
instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
}
} else if((instance->generic.cnt >= 0xFFFF) && (furi_hal_subghz_get_rolling_counter_mult() != 0)) {
instance->generic.cnt = 0;
}
uint64_t local_data_rev = subghz_protocol_blocks_reverse_key(
instance->generic.data, instance->generic.data_count_bit + 4);
uint16_t encrypted_counter = (uint16_t)subghz_protocol_phoenix_v2_encrypt_counter(
local_data_rev, instance->generic.cnt);
instance->generic.data = subghz_protocol_blocks_reverse_key(
(uint64_t)(((uint64_t)encrypted_counter << 40) | ((uint64_t)btn << 32) |
(uint64_t)instance->generic.serial),
instance->generic.data_count_bit + 4);
//Send header
instance->encoder.upload[index++] =
level_duration_make(false, (uint32_t)subghz_protocol_phoenix_v2_const.te_short * 60);
@@ -151,10 +317,22 @@ SubGhzProtocolStatus
flipper_format_read_uint32(
flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
subghz_protocol_phoenix_v2_check_remote_controller(&instance->generic);
if(!subghz_protocol_encoder_phoenix_v2_get_upload(instance)) {
ret = SubGhzProtocolStatusErrorEncoderGetUpload;
break;
}
uint8_t key_data[sizeof(uint64_t)] = {0};
for(size_t i = 0; i < sizeof(uint64_t); i++) {
key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> i * 8) & 0xFF;
}
if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
FURI_LOG_E(TAG, "Unable to add Key");
break;
}
instance->encoder.is_running = true;
} while(false);
@@ -276,16 +454,103 @@ void subghz_protocol_decoder_phoenix_v2_feed(void* context, bool level, uint32_t
}
}
static uint16_t subghz_protocol_phoenix_v2_encrypt_counter(uint64_t full_key, uint16_t counter) {
uint8_t xor_key1 = (uint8_t)(full_key >> 24); // First byte of serial
uint8_t xor_key2 = (uint8_t)((full_key >> 16) & 0xFF); // Second byte of serial
uint8_t byte2 = (uint8_t)(counter >> 8); // First counter byte
uint8_t byte1 = (uint8_t)(counter & 0xFF); // Second counter byte
// See decrypt function before reading these comments
for(int i = 0; i < 16; i++) {
// The key to reversing the process is that the MSB of the *current* byte2
// tells us what the MSB of the *previous* byte1 was. This allows us to
// determine if the conditional XOR was applied before?.
uint8_t msb_of_prev_byte1 = byte2 & 0x80;
if(msb_of_prev_byte1 == 0) {
// reverse the XOR.
byte2 ^= xor_key2;
byte1 ^= xor_key1;
}
// Perform the bit shuffle in reverse
// Store the least significant bit (LSB) of the current byte1.
uint8_t lsb_of_current_byte1 = byte1 & 1;
byte2 = (byte2 << 1) | lsb_of_current_byte1;
byte1 = (byte1 >> 1) | msb_of_prev_byte1;
}
return (uint16_t)byte1 << 8 | byte2;
}
static uint16_t subghz_protocol_phoenix_v2_decrypt_counter(uint64_t full_key) {
uint16_t encrypted_value = (uint16_t)((full_key >> 40) & 0xFFFF);
uint8_t byte1 = (uint8_t)(encrypted_value >> 8); // First encrypted counter byte
uint8_t byte2 = (uint8_t)(encrypted_value & 0xFF); // Second encrypted counter byte
uint8_t xor_key1 = (uint8_t)(full_key >> 24); // First byte of serial
uint8_t xor_key2 = (uint8_t)((full_key >> 16) & 0xFF); // Second byte of serial
for(int i = 0; i < 16; i++) {
// Store the most significant bit (MSB) of byte1.
// The check `(msb_of_byte1 == 0)` will determine if we apply the XOR keys.
uint8_t msb_of_byte1 = byte1 & 0x80;
// Store the least significant bit (LSB) of byte2.
uint8_t lsb_of_byte2 = byte2 & 1;
// Perform a bit shuffle between the two bytes
byte2 = (byte2 >> 1) | msb_of_byte1;
byte1 = (byte1 << 1) | lsb_of_byte2;
// Conditionally apply the XOR keys based on the original MSB of byte1.
if(msb_of_byte1 == 0) {
byte1 ^= xor_key1;
// The mask `& 0x7F` clears the MSB of byte2 after the XOR.
byte2 = (byte2 ^ xor_key2) & 0x7F;
}
}
return (uint16_t)byte2 << 8 | byte1;
}
/**
* Analysis of received data
* @param instance Pointer to a SubGhzBlockGeneric* instance
*/
static void subghz_protocol_phoenix_v2_check_remote_controller(SubGhzBlockGeneric* instance) {
// 2022.08 - @Skorpionm
// 2025.07 - @xMasterX & @RocketGod-git
// Fully supported now, with button switch and add manually
//
// Key samples
// Full key example: 0xC63E01B9615720 - after subghz_protocol_blocks_reverse_key was applied
// Serial - B9615720
// Button - 01
// Encrypted -> Decrypted counters
// C63E - 025C
// BCC1 - 025D
// 3341 - 025E
// 49BE - 025F
// 99D3 - 0260
// E32C - 0261
uint64_t data_rev =
subghz_protocol_blocks_reverse_key(instance->data, instance->data_count_bit + 4);
instance->serial = data_rev & 0xFFFFFFFF;
instance->cnt = (data_rev >> 40) & 0xFFFF;
instance->cnt = subghz_protocol_phoenix_v2_decrypt_counter(data_rev);
instance->btn = (data_rev >> 32) & 0xF;
// encrypted cnt is (data_rev >> 40) & 0xFFFF
// Save original button for later use
if(subghz_custom_btn_get_original() == 0) {
subghz_custom_btn_set_original(instance->btn);
}
subghz_custom_btn_set_max(4);
}
uint32_t subghz_protocol_decoder_phoenix_v2_get_hash_data(void* context) {
@@ -320,15 +585,15 @@ void subghz_protocol_decoder_phoenix_v2_get_string(void* context, FuriString* ou
subghz_protocol_phoenix_v2_check_remote_controller(&instance->generic);
furi_string_cat_printf(
output,
"%s %dbit\r\n"
"V2 Phoenix %dbit\r\n"
"Key:%05lX%08lX\r\n"
"Sn:0x%07lX \r\n"
"Btn:%X Cnt: 0x%04lX\r\n",
instance->generic.protocol_name,
"Cnt: 0x%04lX\r\n"
"Btn: %X\r\n",
instance->generic.data_count_bit,
(uint32_t)(instance->generic.data >> 32) & 0xFFFFFFFF,
(uint32_t)(instance->generic.data & 0xFFFFFFFF),
instance->generic.serial,
instance->generic.btn,
instance->generic.cnt);
instance->generic.cnt,
instance->generic.btn);
}

1
lib/subghz/protocols/protocol_items.c
View File

@@ -82,6 +82,7 @@ const SubGhzProtocol* const subghz_protocol_registry_items[] = {
&subghz_protocol_hay21,
&subghz_protocol_revers_rb2,
&subghz_protocol_feron,
&subghz_protocol_roger,
};
const SubGhzProtocolRegistry subghz_protocol_registry = {

1
lib/subghz/protocols/protocol_items.h
View File

@@ -83,3 +83,4 @@
#include "hay21.h"
#include "revers_rb2.h"
#include "feron.h"
#include "roger.h"

16
lib/subghz/protocols/public_api.h
View File

@@ -123,6 +123,22 @@ bool subghz_protocol_came_atomo_create_data(
uint16_t cnt,
SubGhzRadioPreset* preset);
/**
* Key generation from simple data.
* @param context Pointer to a SubGhzProtocolEncoderPhoenix_V2 instance
* @param flipper_format Pointer to a FlipperFormat instance
* @param serial Serial number
* @param cnt Counter value, 16 bit
* @param preset Modulation, SubGhzRadioPreset
* @return true On success
*/
bool subghz_protocol_phoenix_v2_create_data(
void* context,
FlipperFormat* flipper_format,
uint32_t serial,
uint16_t cnt,
SubGhzRadioPreset* preset);
/**
* New remote generation.
* @param context Pointer to a SubGhzProtocolEncoderNiceFlorS instance

449
lib/subghz/protocols/roger.c Normal file
View File

@@ -0,0 +1,449 @@
#include "roger.h"
#include "../blocks/const.h"
#include "../blocks/decoder.h"
#include "../blocks/encoder.h"
#include "../blocks/generic.h"
#include "../blocks/math.h"
#include "../blocks/custom_btn_i.h"
#define TAG "SubGhzProtocolRoger"
static const SubGhzBlockConst subghz_protocol_roger_const = {
.te_short = 500,
.te_long = 1000,
.te_delta = 270,
.min_count_bit_for_found = 28,
};
struct SubGhzProtocolDecoderRoger {
SubGhzProtocolDecoderBase base;
SubGhzBlockDecoder decoder;
SubGhzBlockGeneric generic;
};
struct SubGhzProtocolEncoderRoger {
SubGhzProtocolEncoderBase base;
SubGhzProtocolBlockEncoder encoder;
SubGhzBlockGeneric generic;
};
typedef enum {
RogerDecoderStepReset = 0,
RogerDecoderStepSaveDuration,
RogerDecoderStepCheckDuration,
} RogerDecoderStep;
const SubGhzProtocolDecoder subghz_protocol_roger_decoder = {
.alloc = subghz_protocol_decoder_roger_alloc,
.free = subghz_protocol_decoder_roger_free,
.feed = subghz_protocol_decoder_roger_feed,
.reset = subghz_protocol_decoder_roger_reset,
.get_hash_data = subghz_protocol_decoder_roger_get_hash_data,
.serialize = subghz_protocol_decoder_roger_serialize,
.deserialize = subghz_protocol_decoder_roger_deserialize,
.get_string = subghz_protocol_decoder_roger_get_string,
};
const SubGhzProtocolEncoder subghz_protocol_roger_encoder = {
.alloc = subghz_protocol_encoder_roger_alloc,
.free = subghz_protocol_encoder_roger_free,
.deserialize = subghz_protocol_encoder_roger_deserialize,
.stop = subghz_protocol_encoder_roger_stop,
.yield = subghz_protocol_encoder_roger_yield,
};
const SubGhzProtocol subghz_protocol_roger = {
.name = SUBGHZ_PROTOCOL_ROGER_NAME,
.type = SubGhzProtocolTypeStatic,
.flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_868 | SubGhzProtocolFlag_AM |
SubGhzProtocolFlag_Decodable | SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save |
SubGhzProtocolFlag_Send,
.decoder = &subghz_protocol_roger_decoder,
.encoder = &subghz_protocol_roger_encoder,
};
void* subghz_protocol_encoder_roger_alloc(SubGhzEnvironment* environment) {
UNUSED(environment);
SubGhzProtocolEncoderRoger* instance = malloc(sizeof(SubGhzProtocolEncoderRoger));
instance->base.protocol = &subghz_protocol_roger;
instance->generic.protocol_name = instance->base.protocol->name;
instance->encoder.repeat = 10;
instance->encoder.size_upload = 256;
instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
instance->encoder.is_running = false;
return instance;
}
void subghz_protocol_encoder_roger_free(void* context) {
furi_assert(context);
SubGhzProtocolEncoderRoger* instance = context;
free(instance->encoder.upload);
free(instance);
}
// Get custom button code
static uint8_t subghz_protocol_roger_get_btn_code(void) {
uint8_t custom_btn_id = subghz_custom_btn_get();
uint8_t original_btn_code = subghz_custom_btn_get_original();
uint8_t btn = original_btn_code;
// Set custom button
if((custom_btn_id == SUBGHZ_CUSTOM_BTN_OK) && (original_btn_code != 0)) {
// Restore original button code
btn = original_btn_code;
} else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_UP) {
switch(original_btn_code) {
case 0x1:
btn = 0x2;
break;
case 0x2:
btn = 0x1;
break;
case 0x4:
btn = 0x1;
break;
case 0x8:
btn = 0x1;
break;
default:
break;
}
} else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
switch(original_btn_code) {
case 0x1:
btn = 0x4;
break;
case 0x2:
btn = 0x4;
break;
case 0x4:
btn = 0x2;
break;
case 0x8:
btn = 0x4;
break;
default:
break;
}
} else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_LEFT) {
switch(original_btn_code) {
case 0x1:
btn = 0x8;
break;
case 0x2:
btn = 0x8;
break;
case 0x4:
btn = 0x8;
break;
case 0x8:
btn = 0x2;
break;
default:
break;
}
}
return btn;
}
/**
* Generating an upload from data.
* @param instance Pointer to a SubGhzProtocolEncoderRoger instance
*/
static void subghz_protocol_encoder_roger_get_upload(SubGhzProtocolEncoderRoger* instance) {
furi_assert(instance);
size_t index = 0;
uint8_t btn = instance->generic.btn;
// Save original button for later use
if(subghz_custom_btn_get_original() == 0) {
subghz_custom_btn_set_original(btn);
}
// Get custom button code
// This will override the btn variable if a custom button is set
btn = subghz_protocol_roger_get_btn_code();
// If End is not == button - transmit as is, no custom button allowed
// For "End" values 23 and 20 - transmit correct ending used for their buttons
if((instance->generic.data & 0xFF) == instance->generic.btn) {
instance->generic.data = (uint64_t)instance->generic.serial << 12 | ((uint64_t)btn << 8) |
btn;
} else if(((instance->generic.data & 0xFF) == 0x23) && btn == 0x1) {
instance->generic.data = (uint64_t)instance->generic.serial << 12 | ((uint64_t)btn << 8) |
0x20;
} else if(((instance->generic.data & 0xFF) == 0x20) && btn == 0x2) {
instance->generic.data = (uint64_t)instance->generic.serial << 12 | ((uint64_t)btn << 8) |
0x23;
}
// Send key and GAP
for(uint8_t i = instance->generic.data_count_bit; i > 0; i--) {
if(bit_read(instance->generic.data, i - 1)) {
// Send bit 1
instance->encoder.upload[index++] =
level_duration_make(true, (uint32_t)subghz_protocol_roger_const.te_long);
if(i == 1) {
//Send gap if bit was last
instance->encoder.upload[index++] = level_duration_make(
false, (uint32_t)subghz_protocol_roger_const.te_short * 19);
} else {
instance->encoder.upload[index++] =
level_duration_make(false, (uint32_t)subghz_protocol_roger_const.te_short);
}
} else {
// Send bit 0
instance->encoder.upload[index++] =
level_duration_make(true, (uint32_t)subghz_protocol_roger_const.te_short);
if(i == 1) {
//Send gap if bit was last
instance->encoder.upload[index++] = level_duration_make(
false, (uint32_t)subghz_protocol_roger_const.te_short * 19);
} else {
instance->encoder.upload[index++] =
level_duration_make(false, (uint32_t)subghz_protocol_roger_const.te_long);
}
}
}
instance->encoder.size_upload = index;
return;
}
/**
* Analysis of received data
* @param instance Pointer to a SubGhzBlockGeneric* instance
*/
static void subghz_protocol_roger_check_remote_controller(SubGhzBlockGeneric* instance) {
// Roger Decoder
// 2025.07 - @xMasterX (MMX)
// Key samples
// 0010001111111001 0001 00100000 // S/N: 0x23F9 Btn: 0x1 End: 0x20
// 0010001111111001 0010 00100011 // S/N: 0x23F9 Btn: 0x2 End: 0x23
// 0101011001010110 0001 00000001 // S/N: 0x5656 Btn: 0x1 End: 0x01
// 0101011001010110 0010 00000010 // S/N: 0x5656 Btn: 0x2 End: 0x02
// 0000110111111110 0001 00000001 // S/N: 0x0DFE Btn: 0x1 End: 0x01
// 0000110111111110 0100 00000100 // S/N: 0x0DFE Btn: 0x4 End: 0x04
// 0000110111111110 0010 00000010 // S/N: 0x0DFE Btn: 0x2 End: 0x02
// 0000110111111110 1000 00001000 // S/N: 0x0DFE Btn: 0x8 End: 0x08
instance->serial = instance->data >> 12;
instance->btn = (instance->data >> 8) & 0xF;
// Save original button for later use
if(subghz_custom_btn_get_original() == 0) {
subghz_custom_btn_set_original(instance->btn);
}
subghz_custom_btn_set_max(3);
}
SubGhzProtocolStatus
subghz_protocol_encoder_roger_deserialize(void* context, FlipperFormat* flipper_format) {
furi_assert(context);
SubGhzProtocolEncoderRoger* instance = context;
SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
do {
ret = subghz_block_generic_deserialize_check_count_bit(
&instance->generic,
flipper_format,
subghz_protocol_roger_const.min_count_bit_for_found);
if(ret != SubGhzProtocolStatusOk) {
break;
}
//optional parameter parameter
flipper_format_read_uint32(
flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
subghz_protocol_roger_check_remote_controller(&instance->generic);
subghz_protocol_encoder_roger_get_upload(instance);
uint8_t key_data[sizeof(uint64_t)] = {0};
for(size_t i = 0; i < sizeof(uint64_t); i++) {
key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data >> i * 8) & 0xFF;
}
if(!flipper_format_update_hex(flipper_format, "Key", key_data, sizeof(uint64_t))) {
FURI_LOG_E(TAG, "Unable to add Key");
break;
}
instance->encoder.is_running = true;
} while(false);
return ret;
}
void subghz_protocol_encoder_roger_stop(void* context) {
SubGhzProtocolEncoderRoger* instance = context;
instance->encoder.is_running = false;
}
LevelDuration subghz_protocol_encoder_roger_yield(void* context) {
SubGhzProtocolEncoderRoger* 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;
}
void* subghz_protocol_decoder_roger_alloc(SubGhzEnvironment* environment) {
UNUSED(environment);
SubGhzProtocolDecoderRoger* instance = malloc(sizeof(SubGhzProtocolDecoderRoger));
instance->base.protocol = &subghz_protocol_roger;
instance->generic.protocol_name = instance->base.protocol->name;
return instance;
}
void subghz_protocol_decoder_roger_free(void* context) {
furi_assert(context);
SubGhzProtocolDecoderRoger* instance = context;
free(instance);
}
void subghz_protocol_decoder_roger_reset(void* context) {
furi_assert(context);
SubGhzProtocolDecoderRoger* instance = context;
instance->decoder.parser_step = RogerDecoderStepReset;
}
void subghz_protocol_decoder_roger_feed(void* context, bool level, volatile uint32_t duration) {
furi_assert(context);
SubGhzProtocolDecoderRoger* instance = context;
switch(instance->decoder.parser_step) {
case RogerDecoderStepReset:
if((!level) && (DURATION_DIFF(duration, subghz_protocol_roger_const.te_short * 19) <
subghz_protocol_roger_const.te_delta * 5)) {
//Found GAP
instance->decoder.decode_data = 0;
instance->decoder.decode_count_bit = 0;
instance->decoder.parser_step = RogerDecoderStepSaveDuration;
}
break;
case RogerDecoderStepSaveDuration:
if(level) {
instance->decoder.te_last = duration;
instance->decoder.parser_step = RogerDecoderStepCheckDuration;
} else {
instance->decoder.parser_step = RogerDecoderStepReset;
}
break;
case RogerDecoderStepCheckDuration:
if(!level) {
// Bit 1 is long and short timing = 1000us HIGH (te_last) and 500us LOW
if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_roger_const.te_long) <
subghz_protocol_roger_const.te_delta) &&
(DURATION_DIFF(duration, subghz_protocol_roger_const.te_short) <
subghz_protocol_roger_const.te_delta)) {
subghz_protocol_blocks_add_bit(&instance->decoder, 1);
instance->decoder.parser_step = RogerDecoderStepSaveDuration;
// Bit 0 is short and long timing = 500us HIGH (te_last) and 1000us LOW
} else if(
(DURATION_DIFF(instance->decoder.te_last, subghz_protocol_roger_const.te_short) <
subghz_protocol_roger_const.te_delta) &&
(DURATION_DIFF(duration, subghz_protocol_roger_const.te_long) <
subghz_protocol_roger_const.te_delta)) {
subghz_protocol_blocks_add_bit(&instance->decoder, 0);
instance->decoder.parser_step = RogerDecoderStepSaveDuration;
} else if(
// End of the key
DURATION_DIFF(duration, subghz_protocol_roger_const.te_short * 19) <
subghz_protocol_roger_const.te_delta * 5) {
//Found next GAP and add bit 1 or 0
if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_roger_const.te_long) <
subghz_protocol_roger_const.te_delta)) {
subghz_protocol_blocks_add_bit(&instance->decoder, 1);
}
if((DURATION_DIFF(instance->decoder.te_last, subghz_protocol_roger_const.te_short) <
subghz_protocol_roger_const.te_delta)) {
subghz_protocol_blocks_add_bit(&instance->decoder, 0);
}
// If got full 28 bits key reading is finished
if(instance->decoder.decode_count_bit ==
subghz_protocol_roger_const.min_count_bit_for_found) {
instance->generic.data = instance->decoder.decode_data;
instance->generic.data_count_bit = instance->decoder.decode_count_bit;
if(instance->base.callback)
instance->base.callback(&instance->base, instance->base.context);
}
instance->decoder.decode_data = 0;
instance->decoder.decode_count_bit = 0;
instance->decoder.parser_step = RogerDecoderStepReset;
} else {
instance->decoder.parser_step = RogerDecoderStepReset;
}
} else {
instance->decoder.parser_step = RogerDecoderStepReset;
}
break;
}
}
uint8_t subghz_protocol_decoder_roger_get_hash_data(void* context) {
furi_assert(context);
SubGhzProtocolDecoderRoger* instance = context;
return subghz_protocol_blocks_get_hash_data(
&instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
}
SubGhzProtocolStatus subghz_protocol_decoder_roger_serialize(
void* context,
FlipperFormat* flipper_format,
SubGhzRadioPreset* preset) {
furi_assert(context);
SubGhzProtocolDecoderRoger* instance = context;
return subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
}
SubGhzProtocolStatus
subghz_protocol_decoder_roger_deserialize(void* context, FlipperFormat* flipper_format) {
furi_assert(context);
SubGhzProtocolDecoderRoger* instance = context;
return subghz_block_generic_deserialize_check_count_bit(
&instance->generic, flipper_format, subghz_protocol_roger_const.min_count_bit_for_found);
}
void subghz_protocol_decoder_roger_get_string(void* context, FuriString* output) {
furi_assert(context);
SubGhzProtocolDecoderRoger* instance = context;
subghz_protocol_roger_check_remote_controller(&instance->generic);
furi_string_cat_printf(
output,
"%s %db\r\n"
"Key: 0x%07lX\r\n"
"Serial: 0x%04lX\r\n"
"End: 0x%02lX\r\n"
"Btn: %01X",
instance->generic.protocol_name,
instance->generic.data_count_bit,
(uint32_t)(instance->generic.data & 0xFFFFFFF),
instance->generic.serial,
(uint32_t)(instance->generic.data & 0xFF),
instance->generic.btn);
}

109
lib/subghz/protocols/roger.h Normal file
View File

@@ -0,0 +1,109 @@
#pragma once
#include "base.h"
#define SUBGHZ_PROTOCOL_ROGER_NAME "Roger"
typedef struct SubGhzProtocolDecoderRoger SubGhzProtocolDecoderRoger;
typedef struct SubGhzProtocolEncoderRoger SubGhzProtocolEncoderRoger;
extern const SubGhzProtocolDecoder subghz_protocol_roger_decoder;
extern const SubGhzProtocolEncoder subghz_protocol_roger_encoder;
extern const SubGhzProtocol subghz_protocol_roger;
/**
* Allocate SubGhzProtocolEncoderRoger.
* @param environment Pointer to a SubGhzEnvironment instance
* @return SubGhzProtocolEncoderRoger* pointer to a SubGhzProtocolEncoderRoger instance
*/
void* subghz_protocol_encoder_roger_alloc(SubGhzEnvironment* environment);
/**
* Free SubGhzProtocolEncoderRoger.
* @param context Pointer to a SubGhzProtocolEncoderRoger instance
*/
void subghz_protocol_encoder_roger_free(void* context);
/**
* Deserialize and generating an upload to send.
* @param context Pointer to a SubGhzProtocolEncoderRoger instance
* @param flipper_format Pointer to a FlipperFormat instance
* @return status
*/
SubGhzProtocolStatus
subghz_protocol_encoder_roger_deserialize(void* context, FlipperFormat* flipper_format);
/**
* Forced transmission stop.
* @param context Pointer to a SubGhzProtocolEncoderRoger instance
*/
void subghz_protocol_encoder_roger_stop(void* context);
/**
* Getting the level and duration of the upload to be loaded into DMA.
* @param context Pointer to a SubGhzProtocolEncoderRoger instance
* @return LevelDuration
*/
LevelDuration subghz_protocol_encoder_roger_yield(void* context);
/**
* Allocate SubGhzProtocolDecoderRoger.
* @param environment Pointer to a SubGhzEnvironment instance
* @return SubGhzProtocolDecoderRoger* pointer to a SubGhzProtocolDecoderRoger instance
*/
void* subghz_protocol_decoder_roger_alloc(SubGhzEnvironment* environment);
/**
* Free SubGhzProtocolDecoderRoger.
* @param context Pointer to a SubGhzProtocolDecoderRoger instance
*/
void subghz_protocol_decoder_roger_free(void* context);
/**
* Reset decoder SubGhzProtocolDecoderRoger.
* @param context Pointer to a SubGhzProtocolDecoderRoger instance
*/
void subghz_protocol_decoder_roger_reset(void* context);
/**
* Parse a raw sequence of levels and durations received from the air.
* @param context Pointer to a SubGhzProtocolDecoderRoger instance
* @param level Signal level true-high false-low
* @param duration Duration of this level in, us
*/
void subghz_protocol_decoder_roger_feed(void* context, bool level, uint32_t duration);
/**
* Getting the hash sum of the last randomly received parcel.
* @param context Pointer to a SubGhzProtocolDecoderRoger instance
* @return hash Hash sum
*/
uint8_t subghz_protocol_decoder_roger_get_hash_data(void* context);
/**
* Serialize data SubGhzProtocolDecoderRoger.
* @param context Pointer to a SubGhzProtocolDecoderRoger instance
* @param flipper_format Pointer to a FlipperFormat instance
* @param preset The modulation on which the signal was received, SubGhzRadioPreset
* @return status
*/
SubGhzProtocolStatus subghz_protocol_decoder_roger_serialize(
void* context,
FlipperFormat* flipper_format,
SubGhzRadioPreset* preset);
/**
* Deserialize data SubGhzProtocolDecoderRoger.
* @param context Pointer to a SubGhzProtocolDecoderRoger instance
* @param flipper_format Pointer to a FlipperFormat instance
* @return status
*/
SubGhzProtocolStatus
subghz_protocol_decoder_roger_deserialize(void* context, FlipperFormat* flipper_format);
/**
* Getting a textual representation of the received data.
* @param context Pointer to a SubGhzProtocolDecoderRoger instance
* @param output Resulting text
*/
void subghz_protocol_decoder_roger_get_string(void* context, FuriString* output);

6
lib/subghz/subghz_setting.c
View File

@@ -14,6 +14,7 @@ static const uint32_t subghz_frequency_list[] = {
/* 300 - 348 */
300000000,
302757000,
303000000,
303875000,
303900000,
304250000,
@@ -70,6 +71,7 @@ static const uint32_t subghz_frequency_list[] = {
779000000,
868350000,
868400000,
868460000,
868800000,
868950000,
906400000,
@@ -80,11 +82,9 @@ static const uint32_t subghz_frequency_list[] = {
};
static const uint32_t subghz_hopper_frequency_list[] = {
310000000,
315000000,
318000000,
418000000,
433920000,
434420000,
868350000,
0,
};