Mirrors/unleashed-firmware
2
0
Fork 0
mirror of https://github.com/DarkFlippers/unleashed-firmware synced 2024-12-18 00:33:09 +00:00
Code Issues Projects Releases Packages Wiki Activity

Merge pull request #321 from assasinfil/kinggates_stylo_4k

Browse source 
Kinggates stylo 4k
This commit is contained in:
MX 2023-02-10 16:52:36 +03:00 committed by GitHub
commit 66ab192cd7
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
3 changed files with 307 additions and 21 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
firmware/targets/f7/api_symbols.csv
View file

@ -3067,6 +3067,11 @@ Function,-,subghz_protocol_encoder_keeloq_deserialize,_Bool,"void*, FlipperForma
Function,-,subghz_protocol_encoder_keeloq_free,void,void*
Function,-,subghz_protocol_encoder_keeloq_stop,void,void*
Function,-,subghz_protocol_encoder_keeloq_yield,LevelDuration,void*
Function,-,subghz_protocol_encoder_kinggates_stylo_4k_alloc,void*,SubGhzEnvironment*
Function,-,subghz_protocol_encoder_kinggates_stylo_4k_deserialize,_Bool,"void*, FlipperFormat*"
Function,-,subghz_protocol_encoder_kinggates_stylo_4k_free,void,void*
Function,-,subghz_protocol_encoder_kinggates_stylo_4k_stop,void,void*
Function,-,subghz_protocol_encoder_kinggates_stylo_4k_yield,LevelDuration,void*
Function,-,subghz_protocol_encoder_linear_alloc,void*,SubGhzEnvironment*
Function,-,subghz_protocol_encoder_linear_delta3_alloc,void*,SubGhzEnvironment*
Function,-,subghz_protocol_encoder_linear_delta3_deserialize,_Bool,"void*, FlipperFormat*"

1 entry status name type params
3067 Function - subghz_protocol_encoder_keeloq_free void void*
3068 Function - subghz_protocol_encoder_keeloq_stop void void*
3069 Function - subghz_protocol_encoder_keeloq_yield LevelDuration void*
3070 Function - subghz_protocol_encoder_kinggates_stylo_4k_alloc void* SubGhzEnvironment*
3071 Function - subghz_protocol_encoder_kinggates_stylo_4k_deserialize _Bool void*, FlipperFormat*
3072 Function - subghz_protocol_encoder_kinggates_stylo_4k_free void void*
3073 Function - subghz_protocol_encoder_kinggates_stylo_4k_stop void void*
3074 Function - subghz_protocol_encoder_kinggates_stylo_4k_yield LevelDuration void*
3075 Function - subghz_protocol_encoder_linear_alloc void* SubGhzEnvironment*
3076 Function - subghz_protocol_encoder_linear_delta3_alloc void* SubGhzEnvironment*
3077 Function - subghz_protocol_encoder_linear_delta3_deserialize _Bool void*, FlipperFormat*

285
lib/subghz/protocols/kinggates_stylo_4k.c
View file

@ -23,7 +23,6 @@ struct SubGhzProtocolDecoderKingGates_stylo_4k {
SubGhzBlockDecoder decoder;
SubGhzBlockGeneric generic;
uint64_t data;
uint16_t header_count;
SubGhzKeystore* keystore;
};
@ -33,6 +32,7 @@ struct SubGhzProtocolEncoderKingGates_stylo_4k {
SubGhzProtocolBlockEncoder encoder;
SubGhzBlockGeneric generic;
SubGhzKeystore* keystore;
};
typedef enum {
@ -57,23 +57,268 @@ const SubGhzProtocolDecoder subghz_protocol_kinggates_stylo_4k_decoder = {
};
const SubGhzProtocolEncoder subghz_protocol_kinggates_stylo_4k_encoder = {
.alloc = NULL,
.free = NULL,
.alloc = subghz_protocol_encoder_kinggates_stylo_4k_alloc,
.free = subghz_protocol_encoder_kinggates_stylo_4k_free,
.deserialize = NULL,
.stop = NULL,
.yield = NULL,
.deserialize = subghz_protocol_encoder_kinggates_stylo_4k_deserialize,
.stop = subghz_protocol_encoder_kinggates_stylo_4k_stop,
.yield = subghz_protocol_encoder_kinggates_stylo_4k_yield,
};
const SubGhzProtocol subghz_protocol_kinggates_stylo_4k = {
.name = SUBGHZ_PROTOCOL_KINGGATES_STYLO_4K_NAME,
.type = SubGhzProtocolTypeDynamic,
.flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable,
.flag = SubGhzProtocolFlag_433 | SubGhzProtocolFlag_AM | SubGhzProtocolFlag_Decodable |
SubGhzProtocolFlag_Load | SubGhzProtocolFlag_Save | SubGhzProtocolFlag_Send,
.decoder = &subghz_protocol_kinggates_stylo_4k_decoder,
.encoder = &subghz_protocol_kinggates_stylo_4k_encoder,
};
//
// Encoder
//
// Pre define function
static void subghz_protocol_kinggates_stylo_4k_remote_controller(
SubGhzBlockGeneric* instance,
SubGhzKeystore* keystore);
void* subghz_protocol_encoder_kinggates_stylo_4k_alloc(SubGhzEnvironment* environment) {
SubGhzProtocolEncoderKingGates_stylo_4k* instance =
malloc(sizeof(SubGhzProtocolEncoderKingGates_stylo_4k));
instance->base.protocol = &subghz_protocol_kinggates_stylo_4k;
instance->generic.protocol_name = instance->base.protocol->name;
instance->keystore = subghz_environment_get_keystore(environment);
instance->encoder.repeat = 10;
instance->encoder.size_upload = 512;
instance->encoder.upload = malloc(instance->encoder.size_upload * sizeof(LevelDuration));
instance->encoder.is_running = false;
return instance;
}
void subghz_protocol_encoder_kinggates_stylo_4k_free(void* context) {
furi_assert(context);
SubGhzProtocolEncoderKingGates_stylo_4k* instance = context;
free(instance->encoder.upload);
free(instance);
}
void subghz_protocol_encoder_kinggates_stylo_4k_stop(void* context) {
SubGhzProtocolEncoderKingGates_stylo_4k* instance = context;
instance->encoder.is_running = false;
}
LevelDuration subghz_protocol_encoder_kinggates_stylo_4k_yield(void* context) {
SubGhzProtocolEncoderKingGates_stylo_4k* 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;
}
/**
* Key generation from simple data
* @param instance Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k* instance
* @param btn Button number, 4 bit
*/
static bool subghz_protocol_kinggates_stylo_4k_gen_data(
SubGhzProtocolEncoderKingGates_stylo_4k* instance,
uint8_t btn) {
UNUSED(btn);
uint32_t hop = subghz_protocol_blocks_reverse_key(instance->generic.data_2 >> 4, 32);
uint64_t fix = subghz_protocol_blocks_reverse_key(instance->generic.data, 53);
int res = 0;
uint32_t decrypt = 0;
for
M_EACH(manufacture_code, *subghz_keystore_get_data(instance->keystore), SubGhzKeyArray_t) {
res = strcmp(furi_string_get_cstr(manufacture_code->name), "Kingates_Stylo4k");
if(res == 0) {
//Simple Learning
decrypt = subghz_protocol_keeloq_common_decrypt(hop, manufacture_code->key);
break;
}
}
instance->generic.cnt = decrypt & 0xFFFF;
if(instance->generic.cnt < 0xFFFF) {
instance->generic.cnt++;
} else if(instance->generic.cnt >= 0xFFFF) {
instance->generic.cnt = 0;
}
instance->generic.btn = (fix >> 17) & 0x0F;
instance->generic.serial = ((fix >> 5) & 0xFFFF0000) | (fix & 0xFFFF);
uint32_t data = (decrypt & 0xFFFF0000) | instance->generic.cnt;
uint64_t encrypt = 0;
for
M_EACH(manufacture_code, *subghz_keystore_get_data(instance->keystore), SubGhzKeyArray_t) {
res = strcmp(furi_string_get_cstr(manufacture_code->name), "Kingates_Stylo4k");
if(res == 0) {
//Simple Learning
encrypt = subghz_protocol_keeloq_common_encrypt(data, manufacture_code->key);
encrypt = subghz_protocol_blocks_reverse_key(encrypt, 32);
instance->generic.data_2 = encrypt << 4;
return true;
}
}
return false;
}
/**
* Generating an upload from data.
* @param instance Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
* @return true On success
*/
static bool subghz_protocol_encoder_kinggates_stylo_4k_get_upload(
SubGhzProtocolEncoderKingGates_stylo_4k* instance,
uint8_t btn) {
furi_assert(instance);
// Gen new key
if(subghz_protocol_kinggates_stylo_4k_gen_data(instance, btn)) {
//ToDo if you need to add a callback to automatically update the data on the display
} else {
return false;
}
size_t index = 0;
// Start
instance->encoder.upload[index++] = level_duration_make(false, (uint32_t)9500);
// Send header
for(uint8_t i = 12; i > 0; i--) {
instance->encoder.upload[index++] =
level_duration_make(true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
instance->encoder.upload[index++] = level_duration_make(
false, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
}
// After header
instance->encoder.upload[index - 1].duration =
(uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long * 2;
instance->encoder.upload[index++] =
level_duration_make(true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short * 2);
// Send key fix
for(uint8_t i = 53; i > 0; i--) {
if(bit_read(instance->generic.data, i - 1)) {
//send bit 1
instance->encoder.upload[index++] = level_duration_make(
false, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
instance->encoder.upload[index++] = level_duration_make(
true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long);
} else {
//send bit 0
instance->encoder.upload[index++] = level_duration_make(
false, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long);
instance->encoder.upload[index++] = level_duration_make(
true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
}
}
// Send key hop
for(uint8_t i = 36; i > 0; i--) {
if(bit_read(instance->generic.data_2, i - 1)) {
//send bit 1
instance->encoder.upload[index++] = level_duration_make(
false, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
instance->encoder.upload[index++] = level_duration_make(
true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long);
} else {
//send bit 0
instance->encoder.upload[index++] = level_duration_make(
false, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long);
instance->encoder.upload[index++] = level_duration_make(
true, (uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_short);
}
}
// Set upload size after generating upload, fix it later
instance->encoder.size_upload = index;
return true;
}
bool subghz_protocol_encoder_kinggates_stylo_4k_deserialize(
void* context,
FlipperFormat* flipper_format) {
furi_assert(context);
SubGhzProtocolEncoderKingGates_stylo_4k* instance = context;
bool res = false;
do {
if(!subghz_block_generic_deserialize(&instance->generic, flipper_format)) {
FURI_LOG_E(TAG, "Deserialize error");
break;
}
subghz_protocol_kinggates_stylo_4k_remote_controller(
&instance->generic, instance->keystore);
//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];
}
subghz_protocol_encoder_kinggates_stylo_4k_get_upload(instance, instance->generic.btn);
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_2 >> i * 8) & 0xFF;
}
if(!flipper_format_update_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
FURI_LOG_E(TAG, "Unable to add Key");
break;
}
instance->encoder.is_running = true;
res = true;
} while(false);
return res;
}
//
// Decoder
//
void* subghz_protocol_decoder_kinggates_stylo_4k_alloc(SubGhzEnvironment* environment) {
SubGhzProtocolDecoderKingGates_stylo_4k* instance =
malloc(sizeof(SubGhzProtocolDecoderKingGates_stylo_4k));
@ -130,7 +375,7 @@ void subghz_protocol_decoder_kinggates_stylo_4k_feed(void* context, bool level,
subghz_protocol_kinggates_stylo_4k_const.te_delta * 2) {
instance->decoder.parser_step = KingGates_stylo_4kDecoderStepSaveDuration;
instance->decoder.decode_data = 0;
instance->data = 0;
instance->generic.data_2 = 0;
instance->decoder.decode_count_bit = 0;
instance->header_count = 0;
}
@ -140,8 +385,8 @@ void subghz_protocol_decoder_kinggates_stylo_4k_feed(void* context, bool level,
if(duration >= ((uint32_t)subghz_protocol_kinggates_stylo_4k_const.te_long * 3)) {
if(instance->decoder.decode_count_bit ==
subghz_protocol_kinggates_stylo_4k_const.min_count_bit_for_found) {
instance->generic.data = instance->data;
instance->data = instance->decoder.decode_data;
instance->generic.data = instance->generic.data_2;
instance->generic.data_2 = instance->decoder.decode_data;
instance->generic.data_count_bit = instance->decoder.decode_count_bit;
if(instance->base.callback)
@ -150,7 +395,7 @@ void subghz_protocol_decoder_kinggates_stylo_4k_feed(void* context, bool level,
instance->decoder.parser_step = KingGates_stylo_4kDecoderStepReset;
instance->decoder.decode_data = 0;
instance->data = 0;
instance->generic.data_2 = 0;
instance->decoder.decode_count_bit = 0;
instance->header_count = 0;
break;
@ -185,7 +430,7 @@ void subghz_protocol_decoder_kinggates_stylo_4k_feed(void* context, bool level,
instance->header_count = 0;
}
if(instance->decoder.decode_count_bit == 53) {
instance->data = instance->decoder.decode_data;
instance->generic.data_2 = instance->decoder.decode_data;
instance->decoder.decode_data = 0;
}
} else {
@ -199,11 +444,11 @@ void subghz_protocol_decoder_kinggates_stylo_4k_feed(void* context, bool level,
/**
* Analysis of received data
* @param instance Pointer to a SubGhzBlockGeneric* instance
* @param file_name Full path to rainbow table the file
* @param data Input encrypted data
* @param keystore Pointer to a SubGhzKeystore* instance
*/
static void subghz_protocol_kinggates_stylo_4k_remote_controller(
SubGhzBlockGeneric* instance,
uint64_t data,
SubGhzKeystore* keystore) {
/**
* 9500us 12*(400/400) 2200/800|1-bit|0-bit|
@ -226,7 +471,7 @@ static void subghz_protocol_kinggates_stylo_4k_remote_controller(
*
*/
uint32_t hop = subghz_protocol_blocks_reverse_key(data >> 4, 32);
uint32_t hop = subghz_protocol_blocks_reverse_key(instance->data_2 >> 4, 32);
uint64_t fix = subghz_protocol_blocks_reverse_key(instance->data, 53);
bool ret = false;
uint32_t decrypt = 0;
@ -270,7 +515,7 @@ bool subghz_protocol_decoder_kinggates_stylo_4k_serialize(
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->data >> (i * 8)) & 0xFF;
key_data[sizeof(uint64_t) - i - 1] = (instance->generic.data_2 >> (i * 8)) & 0xFF;
}
if(res && !flipper_format_write_hex(flipper_format, "Data", key_data, sizeof(uint64_t))) {
@ -306,8 +551,9 @@ bool subghz_protocol_decoder_kinggates_stylo_4k_deserialize(
FURI_LOG_E(TAG, "Missing Data");
break;
}
for(uint8_t i = 0; i < sizeof(uint64_t); i++) {
instance->data = instance->data << 8 | key_data[i];
instance->generic.data_2 = instance->generic.data_2 << 8 | key_data[i];
}
ret = true;
} while(false);
@ -317,8 +563,7 @@ bool subghz_protocol_decoder_kinggates_stylo_4k_deserialize(
void subghz_protocol_decoder_kinggates_stylo_4k_get_string(void* context, FuriString* output) {
furi_assert(context);
SubGhzProtocolDecoderKingGates_stylo_4k* instance = context;
subghz_protocol_kinggates_stylo_4k_remote_controller(
&instance->generic, instance->data, instance->keystore);
subghz_protocol_kinggates_stylo_4k_remote_controller(&instance->generic, instance->keystore);
furi_string_cat_printf(
output,
@ -328,7 +573,7 @@ void subghz_protocol_decoder_kinggates_stylo_4k_get_string(void* context, FuriSt
"Cnt:0x%04lX\r\n",
instance->generic.protocol_name,
instance->generic.data,
instance->data,
instance->generic.data_2,
instance->generic.data_count_bit,
instance->generic.serial,
instance->generic.btn,

36
lib/subghz/protocols/kinggates_stylo_4k.h
View file

@ -10,6 +10,42 @@ extern const SubGhzProtocolDecoder subghz_protocol_kinggates_stylo_4k_decoder;
extern const SubGhzProtocolEncoder subghz_protocol_kinggates_stylo_4k_encoder;
extern const SubGhzProtocol subghz_protocol_kinggates_stylo_4k;
/**
* Allocate SubGhzProtocolEncoderKingGates_stylo_4k.
* @param environment Pointer to a SubGhzEnvironment instance
* @return SubGhzProtocolEncoderKingGates_stylo_4k* pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
*/
void* subghz_protocol_encoder_kinggates_stylo_4k_alloc(SubGhzEnvironment* environment);
/**
* Free SubGhzProtocolEncoderKingGates_stylo_4k.
* @param context Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
*/
void subghz_protocol_encoder_kinggates_stylo_4k_free(void* context);
/**
* Deserialize and generating an upload to send.
* @param context Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
* @param flipper_format Pointer to a FlipperFormat instance
* @return true On success
*/
bool subghz_protocol_encoder_kinggates_stylo_4k_deserialize(
void* context,
FlipperFormat* flipper_format);
/**
* Forced transmission stop.
* @param context Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
*/
void subghz_protocol_encoder_kinggates_stylo_4k_stop(void* context);
/**
* Getting the level and duration of the upload to be loaded into DMA.
* @param context Pointer to a SubGhzProtocolEncoderKingGates_stylo_4k instance
* @return LevelDuration
*/
LevelDuration subghz_protocol_encoder_kinggates_stylo_4k_yield(void* context);
/**
* Allocate SubGhzProtocolDecoderKingGates_stylo_4k.
* @param environment Pointer to a SubGhzEnvironment instance