mirror of
https://github.com/Next-Flip/Momentum-Firmware.git
synced 2026-04-24 03:29:57 -07:00
subghz: add beninca arc protocol
This commit is contained in:
MX
679
lib/subghz/protocols/beninca_arc.c
Normal file
679
lib/subghz/protocols/beninca_arc.c
Normal file
@@ -0,0 +1,679 @@
|
||||
#include "beninca_arc.h"
|
||||
#include "../blocks/const.h"
|
||||
#include "../blocks/decoder.h"
|
||||
#include "../blocks/encoder.h"
|
||||
#include "../blocks/generic.h"
|
||||
#include "../blocks/math.h"
|
||||
#include "core/log.h"
|
||||
#include <stddef.h>
|
||||
#include <stdint.h>
|
||||
#include "aes_common.h"
|
||||
|
||||
#include "../blocks/custom_btn_i.h"
|
||||
|
||||
#define TAG "BenincaARC"
|
||||
|
||||
#define BENINCA_ARC_KEY_TYPE 9u
|
||||
|
||||
static const SubGhzBlockConst subghz_protocol_beninca_arc_const = {
|
||||
.te_short = 300,
|
||||
.te_long = 600,
|
||||
.te_delta = 155,
|
||||
.min_count_bit_for_found = 128,
|
||||
};
|
||||
|
||||
typedef enum {
|
||||
BenincaARCDecoderStart = 0,
|
||||
BenincaARCDecoderHighLevel,
|
||||
BenincaARCDecoderLowLevel,
|
||||
} BenincaARCDecoderState;
|
||||
|
||||
struct SubGhzProtocolDecoderBenincaARC {
|
||||
SubGhzProtocolDecoderBase base;
|
||||
SubGhzBlockDecoder decoder;
|
||||
|
||||
SubGhzBlockGeneric generic;
|
||||
|
||||
SubGhzKeystore* keystore;
|
||||
};
|
||||
|
||||
struct SubGhzProtocolEncoderBenincaARC {
|
||||
SubGhzProtocolEncoderBase base;
|
||||
SubGhzProtocolBlockEncoder encoder;
|
||||
|
||||
SubGhzBlockGeneric generic;
|
||||
|
||||
SubGhzKeystore* keystore;
|
||||
};
|
||||
|
||||
const SubGhzProtocolDecoder subghz_protocol_beninca_arc_decoder = {
|
||||
.alloc = subghz_protocol_decoder_beninca_arc_alloc,
|
||||
.free = subghz_protocol_decoder_beninca_arc_free,
|
||||
|
||||
.feed = subghz_protocol_decoder_beninca_arc_feed,
|
||||
.reset = subghz_protocol_decoder_beninca_arc_reset,
|
||||
|
||||
.get_hash_data = subghz_protocol_decoder_beninca_arc_get_hash_data,
|
||||
.serialize = subghz_protocol_decoder_beninca_arc_serialize,
|
||||
.deserialize = subghz_protocol_decoder_beninca_arc_deserialize,
|
||||
.get_string = subghz_protocol_decoder_beninca_arc_get_string,
|
||||
};
|
||||
|
||||
const SubGhzProtocolEncoder subghz_protocol_beninca_arc_encoder = {
|
||||
.alloc = subghz_protocol_encoder_beninca_arc_alloc,
|
||||
.free = subghz_protocol_encoder_beninca_arc_free,
|
||||
|
||||
.deserialize = subghz_protocol_encoder_beninca_arc_deserialize,
|
||||
.stop = subghz_protocol_encoder_beninca_arc_stop,
|
||||
.yield = subghz_protocol_encoder_beninca_arc_yield,
|
||||
};
|
||||
|
||||
const SubGhzProtocol subghz_protocol_beninca_arc = {
|
||||
.name = SUBGHZ_PROTOCOL_BENINCA_ARC_NAME,
|
||||
.type = SubGhzProtocolTypeDynamic,
|
||||
.flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
|
||||
SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
|
||||
|
||||
.decoder = &subghz_protocol_beninca_arc_decoder,
|
||||
.encoder = &subghz_protocol_beninca_arc_encoder,
|
||||
};
|
||||
|
||||
// Get custom button code
|
||||
static uint8_t subghz_protocol_beninca_arc_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 0x02:
|
||||
btn = 0x04;
|
||||
break;
|
||||
case 0x04:
|
||||
btn = 0x02;
|
||||
break;
|
||||
case 0xFF:
|
||||
btn = 0x04;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
} else if(custom_btn_id == SUBGHZ_CUSTOM_BTN_DOWN) {
|
||||
switch(original_btn_code) {
|
||||
case 0x02:
|
||||
btn = 0xFF;
|
||||
break;
|
||||
case 0x04:
|
||||
btn = 0xFF;
|
||||
break;
|
||||
case 0xFF:
|
||||
btn = 0x02;
|
||||
break;
|
||||
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
return btn;
|
||||
}
|
||||
|
||||
static void get_subghz_protocol_beninca_arc_aes_key(SubGhzKeystore* keystore, uint8_t* aes_key) {
|
||||
uint64_t mfkey = 0;
|
||||
for
|
||||
M_EACH(manufacture_code, *subghz_keystore_get_data(keystore), SubGhzKeyArray_t) {
|
||||
if(manufacture_code->type == BENINCA_ARC_KEY_TYPE) {
|
||||
mfkey = manufacture_code->key;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
uint32_t derived_lo = (uint32_t)(mfkey & 0xFFFFFFFF);
|
||||
uint32_t derived_hi = (uint32_t)((mfkey >> 32) & 0xFFFFFFFF);
|
||||
|
||||
uint64_t val64_a = ((uint64_t)derived_hi << 32) | derived_lo;
|
||||
for(uint8_t i = 0; i < 8; i++) {
|
||||
aes_key[i] = (val64_a >> (56 - i * 8)) & 0xFF;
|
||||
}
|
||||
|
||||
uint32_t new_lo = ((derived_hi >> 24) & 0xFF) | ((derived_hi >> 8) & 0xFF00) |
|
||||
((derived_hi << 8) & 0xFF0000) | ((derived_hi << 24) & 0xFF000000);
|
||||
uint32_t new_hi = ((derived_lo >> 24) & 0xFF) | ((derived_lo >> 8) & 0xFF00) |
|
||||
((derived_lo << 8) & 0xFF0000) | ((derived_lo << 24) & 0xFF000000);
|
||||
|
||||
uint64_t val64_b = ((uint64_t)new_hi << 32) | new_lo;
|
||||
for(uint8_t i = 0; i < 8; i++) {
|
||||
aes_key[i + 8] = (val64_b >> (56 - i * 8)) & 0xFF;
|
||||
}
|
||||
}
|
||||
|
||||
static uint64_t
|
||||
subghz_protocol_beninca_arc_decrypt(SubGhzBlockGeneric* generic, SubGhzKeystore* keystore) {
|
||||
// Beninca ARC Decoder
|
||||
// 01.2026 - @xMasterX (MMX) & @zero-mega
|
||||
|
||||
// Decrypt data
|
||||
uint8_t encrypted_data[16];
|
||||
|
||||
for(uint8_t i = 0; i < 8; i++) {
|
||||
encrypted_data[i] = (generic->data >> (56 - i * 8)) & 0xFF;
|
||||
encrypted_data[i + 8] = (generic->data_2 >> (56 - i * 8)) & 0xFF;
|
||||
}
|
||||
|
||||
reverse_bits_in_bytes(encrypted_data, 16);
|
||||
|
||||
uint8_t aes_key[16];
|
||||
get_subghz_protocol_beninca_arc_aes_key(keystore, aes_key);
|
||||
|
||||
uint8_t expanded_key[176];
|
||||
aes_key_expansion(aes_key, expanded_key);
|
||||
|
||||
aes128_decrypt(expanded_key, encrypted_data);
|
||||
|
||||
// Serial number of remote
|
||||
generic->serial = ((uint32_t)encrypted_data[0] << 24) | ((uint32_t)encrypted_data[1] << 16) |
|
||||
((uint32_t)encrypted_data[2] << 8) | encrypted_data[3];
|
||||
|
||||
// Button code
|
||||
generic->btn = encrypted_data[4];
|
||||
|
||||
// Middle bytes contains mini counter that is increased while button is held
|
||||
// its value mostly stored in encrypted_data[9] but might be in other bytes as well
|
||||
// In order to support all variants we read all middle bytes as uint64_t
|
||||
// In case you have the remote with ARC rolling code please share RAW recording where you hold button for 15+ sec with us to improve this part!
|
||||
uint64_t middle_bytes = 0;
|
||||
middle_bytes = ((uint64_t)encrypted_data[5] << 32) | ((uint64_t)encrypted_data[6] << 24) |
|
||||
((uint64_t)encrypted_data[7] << 16) | ((uint64_t)encrypted_data[8] << 8) |
|
||||
encrypted_data[9];
|
||||
|
||||
// 32-bit counter
|
||||
generic->cnt = ((uint32_t)encrypted_data[10] << 24) | ((uint32_t)encrypted_data[11] << 16) |
|
||||
((uint32_t)encrypted_data[12] << 8) | encrypted_data[13];
|
||||
// Fixed constant value AA 55
|
||||
generic->seed = ((uint16_t)encrypted_data[14] << 8) | encrypted_data[15];
|
||||
|
||||
// Save original button for later use
|
||||
if(subghz_custom_btn_get_original() == 0) {
|
||||
subghz_custom_btn_set_original(generic->btn);
|
||||
}
|
||||
subghz_custom_btn_set_max(2);
|
||||
|
||||
return middle_bytes;
|
||||
}
|
||||
|
||||
static void subghz_protocol_beninca_arc_encrypt(
|
||||
SubGhzBlockGeneric* generic,
|
||||
SubGhzKeystore* keystore,
|
||||
uint64_t middle_bytes) {
|
||||
// Beninca ARC Encoder
|
||||
// 01.2026 - @xMasterX (MMX) & @zero-mega
|
||||
// Encrypt data
|
||||
uint8_t plaintext[16];
|
||||
|
||||
plaintext[0] = (generic->serial >> 24) & 0xFF;
|
||||
plaintext[1] = (generic->serial >> 16) & 0xFF;
|
||||
plaintext[2] = (generic->serial >> 8) & 0xFF;
|
||||
plaintext[3] = generic->serial & 0xFF;
|
||||
plaintext[4] = generic->btn;
|
||||
plaintext[5] = (middle_bytes >> 32) & 0xFF;
|
||||
plaintext[6] = (middle_bytes >> 24) & 0xFF;
|
||||
plaintext[7] = (middle_bytes >> 16) & 0xFF;
|
||||
plaintext[8] = (middle_bytes >> 8) & 0xFF;
|
||||
plaintext[9] = middle_bytes & 0xFF;
|
||||
plaintext[10] = (generic->cnt >> 24) & 0xFF;
|
||||
plaintext[11] = (generic->cnt >> 16) & 0xFF;
|
||||
plaintext[12] = (generic->cnt >> 8) & 0xFF;
|
||||
plaintext[13] = generic->cnt & 0xFF;
|
||||
plaintext[14] = (generic->seed >> 8) & 0xFF;
|
||||
plaintext[15] = generic->seed & 0xFF;
|
||||
|
||||
uint8_t aes_key[16];
|
||||
get_subghz_protocol_beninca_arc_aes_key(keystore, aes_key);
|
||||
|
||||
uint8_t expanded_key[176];
|
||||
aes_key_expansion(aes_key, expanded_key);
|
||||
|
||||
aes128_encrypt(expanded_key, plaintext);
|
||||
|
||||
reverse_bits_in_bytes(plaintext, 16);
|
||||
|
||||
for(uint8_t i = 0; i < 8; i++) {
|
||||
generic->data = (generic->data << 8) | plaintext[i];
|
||||
generic->data_2 = (generic->data_2 << 8) | plaintext[i + 8];
|
||||
}
|
||||
return;
|
||||
}
|
||||
|
||||
void* subghz_protocol_encoder_beninca_arc_alloc(SubGhzEnvironment* environment) {
|
||||
SubGhzProtocolEncoderBenincaARC* instance = malloc(sizeof(SubGhzProtocolEncoderBenincaARC));
|
||||
|
||||
instance->base.protocol = &subghz_protocol_beninca_arc;
|
||||
instance->generic.protocol_name = instance->base.protocol->name;
|
||||
instance->keystore = subghz_environment_get_keystore(environment);
|
||||
|
||||
instance->encoder.repeat = 10;
|
||||
instance->encoder.size_upload = 800;
|
||||
instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
|
||||
instance->encoder.is_running = false;
|
||||
|
||||
return instance;
|
||||
}
|
||||
|
||||
void subghz_protocol_encoder_beninca_arc_free(void* context) {
|
||||
furi_assert(context);
|
||||
SubGhzProtocolEncoderBenincaARC* instance = context;
|
||||
free(instance->encoder.upload);
|
||||
free(instance);
|
||||
}
|
||||
|
||||
void subghz_protocol_encoder_beninca_arc_stop(void* context) {
|
||||
furi_assert(context);
|
||||
SubGhzProtocolEncoderBenincaARC* instance = context;
|
||||
instance->encoder.is_running = false;
|
||||
}
|
||||
|
||||
static void subghz_protocol_beninca_arc_encoder_get_upload(
|
||||
SubGhzProtocolEncoderBenincaARC* instance,
|
||||
size_t* index) {
|
||||
furi_assert(instance);
|
||||
size_t index_local = *index;
|
||||
|
||||
// First part of data 64 bits
|
||||
for(uint8_t i = 64; i > 0; i--) {
|
||||
if(bit_read(instance->generic.data, i - 1)) {
|
||||
// Send bit 1
|
||||
instance->encoder.upload[index_local++] =
|
||||
level_duration_make(true, (uint32_t)subghz_protocol_beninca_arc_const.te_short);
|
||||
instance->encoder.upload[index_local++] =
|
||||
level_duration_make(false, (uint32_t)subghz_protocol_beninca_arc_const.te_long);
|
||||
} else {
|
||||
// Send bit 0
|
||||
instance->encoder.upload[index_local++] =
|
||||
level_duration_make(true, (uint32_t)subghz_protocol_beninca_arc_const.te_long);
|
||||
instance->encoder.upload[index_local++] =
|
||||
level_duration_make(false, (uint32_t)subghz_protocol_beninca_arc_const.te_short);
|
||||
}
|
||||
}
|
||||
// Second part of data 64 bits - total 128bits data
|
||||
for(uint8_t i = 64; i > 0; i--) {
|
||||
if(bit_read(instance->generic.data_2, i - 1)) {
|
||||
// Send bit 1
|
||||
instance->encoder.upload[index_local++] =
|
||||
level_duration_make(true, (uint32_t)subghz_protocol_beninca_arc_const.te_short);
|
||||
instance->encoder.upload[index_local++] =
|
||||
level_duration_make(false, (uint32_t)subghz_protocol_beninca_arc_const.te_long);
|
||||
} else {
|
||||
// Send bit 0
|
||||
instance->encoder.upload[index_local++] =
|
||||
level_duration_make(true, (uint32_t)subghz_protocol_beninca_arc_const.te_long);
|
||||
instance->encoder.upload[index_local++] =
|
||||
level_duration_make(false, (uint32_t)subghz_protocol_beninca_arc_const.te_short);
|
||||
}
|
||||
}
|
||||
// Add stop bit
|
||||
instance->encoder.upload[index_local++] =
|
||||
level_duration_make(true, (uint32_t)subghz_protocol_beninca_arc_const.te_short);
|
||||
// Add gap between packets
|
||||
instance->encoder.upload[index_local++] =
|
||||
level_duration_make(false, (uint32_t)subghz_protocol_beninca_arc_const.te_long * 15);
|
||||
|
||||
*index = index_local;
|
||||
}
|
||||
|
||||
static void subghz_protocol_beninca_arc_encoder_prepare_packets(
|
||||
SubGhzProtocolEncoderBenincaARC* instance) {
|
||||
furi_assert(instance);
|
||||
|
||||
// Counter increment
|
||||
// check OFEX mode
|
||||
if(furi_hal_subghz_get_rolling_counter_mult() != -0x7FFFFFFF) {
|
||||
// standart counter mode. PULL data from subghz_block_generic_global variables
|
||||
if(!subghz_block_generic_global_counter_override_get(&instance->generic.cnt)) {
|
||||
// if counter_override_get return FALSE then counter was not changed and we increase counter by standart mult value
|
||||
if((instance->generic.cnt + furi_hal_subghz_get_rolling_counter_mult()) > 0xFFFFFFFF) {
|
||||
instance->generic.cnt = 0;
|
||||
} else {
|
||||
instance->generic.cnt += furi_hal_subghz_get_rolling_counter_mult();
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// TODO: OFEX mode
|
||||
instance->generic.cnt += 1;
|
||||
}
|
||||
// Index for upload array
|
||||
size_t index = 0;
|
||||
// Generate new key using custom or default button
|
||||
instance->generic.btn = subghz_protocol_beninca_arc_get_btn_code();
|
||||
|
||||
// Make 3 packets with different mini counter values - 2, 4, 6
|
||||
for(uint8_t i = 0; i < 3; i++) {
|
||||
subghz_protocol_beninca_arc_encrypt(
|
||||
&instance->generic, instance->keystore, (uint64_t)((i + 1) * 2));
|
||||
subghz_protocol_beninca_arc_encoder_get_upload(instance, &index);
|
||||
}
|
||||
// Set final size of upload array
|
||||
instance->encoder.size_upload = index;
|
||||
}
|
||||
|
||||
bool subghz_protocol_beninca_arc_create_data(
|
||||
void* context,
|
||||
FlipperFormat* flipper_format,
|
||||
uint32_t serial,
|
||||
uint8_t btn,
|
||||
uint32_t cnt,
|
||||
SubGhzRadioPreset* preset) {
|
||||
furi_assert(context);
|
||||
// UwU
|
||||
SubGhzProtocolEncoderBenincaARC* instance = context;
|
||||
instance->generic.serial = serial;
|
||||
instance->generic.btn = btn; // 02 / 04
|
||||
instance->generic.cnt = cnt;
|
||||
instance->generic.seed = 0xAA55; // Fixed value constant
|
||||
instance->generic.data_count_bit = 128;
|
||||
|
||||
subghz_protocol_beninca_arc_encrypt(&instance->generic, instance->keystore, 0x1);
|
||||
|
||||
SubGhzProtocolStatus res =
|
||||
subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
|
||||
|
||||
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_2 >> (i * 8)) & 0xFF;
|
||||
}
|
||||
|
||||
if(!flipper_format_rewind(flipper_format)) {
|
||||
FURI_LOG_E(TAG, "Rewind error");
|
||||
res = SubGhzProtocolStatusErrorParserOthers;
|
||||
}
|
||||
|
||||
if((res == SubGhzProtocolStatusOk) &&
|
||||
!flipper_format_insert_or_update_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
|
||||
FURI_LOG_E(TAG, "Unable to add Data2");
|
||||
res = SubGhzProtocolStatusErrorParserOthers;
|
||||
}
|
||||
|
||||
return res == SubGhzProtocolStatusOk;
|
||||
}
|
||||
|
||||
SubGhzProtocolStatus
|
||||
subghz_protocol_encoder_beninca_arc_deserialize(void* context, FlipperFormat* flipper_format) {
|
||||
furi_assert(context);
|
||||
SubGhzProtocolEncoderBenincaARC* instance = context;
|
||||
SubGhzProtocolStatus res = SubGhzProtocolStatusError;
|
||||
do {
|
||||
if(SubGhzProtocolStatusOk !=
|
||||
subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
|
||||
FURI_LOG_E(TAG, "Deserialize error");
|
||||
break;
|
||||
}
|
||||
|
||||
//optional parameter parameter
|
||||
flipper_format_read_uint32(
|
||||
flipper_format, "Repeat", (uint32_t*)&instance->encoder.repeat, 1);
|
||||
|
||||
if(!flipper_format_rewind(flipper_format)) {
|
||||
FURI_LOG_E(TAG, "Rewind error");
|
||||
break;
|
||||
}
|
||||
|
||||
uint8_t key_data[sizeof(uint64_t)] = {0};
|
||||
if(!flipper_format_read_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
|
||||
FURI_LOG_E(TAG, "Missing Data");
|
||||
break;
|
||||
}
|
||||
|
||||
for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
|
||||
instance->generic.data_2 = instance->generic.data_2 << 8 | key_data[i];
|
||||
}
|
||||
|
||||
// TODO: if minicounter having larger value use it instead of fixed values
|
||||
subghz_protocol_beninca_arc_decrypt(&instance->generic, instance->keystore);
|
||||
|
||||
subghz_protocol_beninca_arc_encoder_prepare_packets(instance);
|
||||
|
||||
if(!flipper_format_rewind(flipper_format)) {
|
||||
FURI_LOG_E(TAG, "Rewind error");
|
||||
break;
|
||||
}
|
||||
|
||||
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 update Key");
|
||||
break;
|
||||
}
|
||||
|
||||
for(size_t i = 0; i < sizeof(uint64_t); i++) {
|
||||
key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data_2 >> i * 8) & 0xFF;
|
||||
}
|
||||
if(!flipper_format_update_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
|
||||
FURI_LOG_E(TAG, "Unable to update Data");
|
||||
break;
|
||||
}
|
||||
|
||||
instance->encoder.is_running = true;
|
||||
|
||||
res = SubGhzProtocolStatusOk;
|
||||
} while(false);
|
||||
|
||||
return res;
|
||||
}
|
||||
|
||||
LevelDuration subghz_protocol_encoder_beninca_arc_yield(void* context) {
|
||||
furi_assert(context);
|
||||
SubGhzProtocolEncoderBenincaARC* 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_beninca_arc_alloc(SubGhzEnvironment* environment) {
|
||||
SubGhzProtocolDecoderBenincaARC* instance = malloc(sizeof(SubGhzProtocolDecoderBenincaARC));
|
||||
instance->base.protocol = &subghz_protocol_beninca_arc;
|
||||
instance->generic.protocol_name = instance->base.protocol->name;
|
||||
instance->keystore = subghz_environment_get_keystore(environment);
|
||||
instance->decoder.parser_step = BenincaARCDecoderStart;
|
||||
return instance;
|
||||
}
|
||||
|
||||
void subghz_protocol_decoder_beninca_arc_free(void* context) {
|
||||
furi_assert(context);
|
||||
SubGhzProtocolDecoderBenincaARC* instance = context;
|
||||
free(instance);
|
||||
}
|
||||
|
||||
void subghz_protocol_decoder_beninca_arc_reset(void* context) {
|
||||
furi_assert(context);
|
||||
SubGhzProtocolDecoderBenincaARC* instance = context;
|
||||
instance->decoder.parser_step = BenincaARCDecoderStart;
|
||||
}
|
||||
|
||||
void subghz_protocol_decoder_beninca_arc_feed(void* context, bool level, uint32_t duration) {
|
||||
furi_assert(context);
|
||||
SubGhzProtocolDecoderBenincaARC* instance = context;
|
||||
|
||||
switch(instance->decoder.parser_step) {
|
||||
case BenincaARCDecoderStart:
|
||||
if((!level) && (DURATION_DIFF(duration, subghz_protocol_beninca_arc_const.te_long * 16) <
|
||||
subghz_protocol_beninca_arc_const.te_delta * 15)) {
|
||||
// GAP (9300 +- 2325 us) found switch to next state
|
||||
instance->decoder.decode_data = 0;
|
||||
instance->decoder.decode_count_bit = 0;
|
||||
instance->decoder.parser_step = BenincaARCDecoderHighLevel;
|
||||
break;
|
||||
}
|
||||
// No GAP so stay in current state
|
||||
break;
|
||||
case BenincaARCDecoderHighLevel:
|
||||
if(level) {
|
||||
instance->decoder.te_last = duration;
|
||||
instance->decoder.parser_step = BenincaARCDecoderLowLevel;
|
||||
// Check if we have collected enough bits
|
||||
if((instance->decoder.decode_count_bit ==
|
||||
(subghz_protocol_beninca_arc_const.min_count_bit_for_found / 2)) &&
|
||||
(instance->decoder.decode_data != 0)) {
|
||||
// Half data captured 64 bits
|
||||
instance->generic.data = instance->decoder.decode_data;
|
||||
instance->decoder.decode_data = 0;
|
||||
} else if(
|
||||
instance->decoder.decode_count_bit ==
|
||||
subghz_protocol_beninca_arc_const.min_count_bit_for_found) {
|
||||
// Full data captured 128 bits
|
||||
instance->generic.data_2 = instance->decoder.decode_data;
|
||||
instance->generic.data_count_bit = instance->decoder.decode_count_bit;
|
||||
instance->decoder.parser_step = BenincaARCDecoderStart;
|
||||
|
||||
if(instance->base.callback) {
|
||||
instance->base.callback(&instance->base, instance->base.context);
|
||||
}
|
||||
|
||||
break;
|
||||
}
|
||||
} else {
|
||||
instance->decoder.parser_step = BenincaARCDecoderStart;
|
||||
}
|
||||
break;
|
||||
case BenincaARCDecoderLowLevel:
|
||||
if(!level) {
|
||||
// Bit 1 is short and long timing = 300us HIGH (te_last) and 600us LOW
|
||||
if((DURATION_DIFF(
|
||||
instance->decoder.te_last, subghz_protocol_beninca_arc_const.te_short) <
|
||||
subghz_protocol_beninca_arc_const.te_delta) &&
|
||||
(DURATION_DIFF(duration, subghz_protocol_beninca_arc_const.te_long) <
|
||||
subghz_protocol_beninca_arc_const.te_delta)) {
|
||||
subghz_protocol_blocks_add_bit(&instance->decoder, 1);
|
||||
instance->decoder.parser_step = BenincaARCDecoderHighLevel;
|
||||
// Bit 0 is long and short timing = 600us HIGH (te_last) and 300us LOW
|
||||
} else if(
|
||||
(DURATION_DIFF(
|
||||
instance->decoder.te_last, subghz_protocol_beninca_arc_const.te_long) <
|
||||
subghz_protocol_beninca_arc_const.te_delta) &&
|
||||
(DURATION_DIFF(duration, subghz_protocol_beninca_arc_const.te_short) <
|
||||
subghz_protocol_beninca_arc_const.te_delta)) {
|
||||
subghz_protocol_blocks_add_bit(&instance->decoder, 0);
|
||||
instance->decoder.parser_step = BenincaARCDecoderHighLevel;
|
||||
} else {
|
||||
instance->decoder.parser_step = BenincaARCDecoderStart;
|
||||
}
|
||||
break;
|
||||
} else {
|
||||
instance->decoder.parser_step = BenincaARCDecoderStart;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
uint8_t subghz_protocol_decoder_beninca_arc_get_hash_data(void* context) {
|
||||
furi_assert(context);
|
||||
SubGhzProtocolDecoderBenincaARC* instance = context;
|
||||
return subghz_protocol_blocks_get_hash_data(
|
||||
&instance->decoder, (instance->decoder.decode_count_bit / 8) + 1);
|
||||
}
|
||||
|
||||
SubGhzProtocolStatus subghz_protocol_decoder_beninca_arc_serialize(
|
||||
void* context,
|
||||
FlipperFormat* flipper_format,
|
||||
SubGhzRadioPreset* preset) {
|
||||
furi_assert(context);
|
||||
SubGhzProtocolDecoderBenincaARC* instance = context;
|
||||
SubGhzProtocolStatus ret =
|
||||
subghz_block_generic_serialize(&instance->generic, flipper_format, preset);
|
||||
|
||||
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_2 >> (i * 8)) & 0xFF;
|
||||
}
|
||||
|
||||
if(!flipper_format_rewind(flipper_format)) {
|
||||
FURI_LOG_E(TAG, "Rewind error");
|
||||
ret = SubGhzProtocolStatusErrorParserOthers;
|
||||
}
|
||||
|
||||
if((ret == SubGhzProtocolStatusOk) &&
|
||||
!flipper_format_insert_or_update_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
|
||||
FURI_LOG_E(TAG, "Unable to add Data");
|
||||
ret = SubGhzProtocolStatusErrorParserOthers;
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
SubGhzProtocolStatus
|
||||
subghz_protocol_decoder_beninca_arc_deserialize(void* context, FlipperFormat* flipper_format) {
|
||||
furi_assert(context);
|
||||
SubGhzProtocolDecoderBenincaARC* instance = context;
|
||||
|
||||
SubGhzProtocolStatus ret = SubGhzProtocolStatusError;
|
||||
do {
|
||||
ret = subghz_block_generic_deserialize_check_count_bit(
|
||||
&instance->generic,
|
||||
flipper_format,
|
||||
subghz_protocol_beninca_arc_const.min_count_bit_for_found);
|
||||
if(ret != SubGhzProtocolStatusOk) {
|
||||
break;
|
||||
}
|
||||
if(!flipper_format_rewind(flipper_format)) {
|
||||
FURI_LOG_E(TAG, "Rewind error");
|
||||
ret = SubGhzProtocolStatusErrorParserOthers;
|
||||
break;
|
||||
}
|
||||
uint8_t key_data[sizeof(uint64_t)] = {0};
|
||||
if(!flipper_format_read_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
|
||||
FURI_LOG_E(TAG, "Missing Data");
|
||||
ret = SubGhzProtocolStatusErrorParserOthers;
|
||||
break;
|
||||
}
|
||||
|
||||
for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
|
||||
instance->generic.data_2 = instance->generic.data_2 << 8 | key_data[i];
|
||||
}
|
||||
} while(false);
|
||||
return ret;
|
||||
}
|
||||
|
||||
void subghz_protocol_decoder_beninca_arc_get_string(void* context, FuriString* output) {
|
||||
furi_assert(context);
|
||||
SubGhzProtocolDecoderBenincaARC* instance = context;
|
||||
|
||||
uint64_t middle_bytes_dec =
|
||||
subghz_protocol_beninca_arc_decrypt(&instance->generic, instance->keystore);
|
||||
|
||||
// push protocol data to global variable
|
||||
subghz_block_generic_global.cnt_is_available = true;
|
||||
subghz_block_generic_global.cnt_length_bit = 32;
|
||||
subghz_block_generic_global.current_cnt = instance->generic.cnt;
|
||||
|
||||
furi_string_printf(
|
||||
output,
|
||||
"%s %db\r\n"
|
||||
"Key1:%08llX\r\n"
|
||||
"Key2:%08llX\r\n"
|
||||
"Sn:%08lX Btn:%02X\r\n"
|
||||
"Mc:%0lX Cnt:%0lX\r\n"
|
||||
"Fx:%04lX",
|
||||
instance->base.protocol->name,
|
||||
instance->generic.data_count_bit,
|
||||
instance->generic.data,
|
||||
instance->generic.data_2,
|
||||
instance->generic.serial,
|
||||
instance->generic.btn,
|
||||
(uint32_t)(middle_bytes_dec & 0xFFFFFFFF),
|
||||
instance->generic.cnt,
|
||||
instance->generic.seed & 0xFFFF);
|
||||
}
|
||||
Reference in New Issue
Block a user