liz/flipperzero-firmware
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[FL-1913, FL-1963] SubGhz: save raw signal, add came atomo decoder (#783)

Browse Source 
* File_Worker: getting the name of a new file with an index
* SubGhz: add decoder RAW protocol
* SubGhz: add view Save RAW
* SubGhz: refactoring subghz custom event
* SubGhz: fix syntax
* SubGhz: fix error build
* SubGhz: test build
* SubGhz: refactoring subghz, add rename, delete, start and emulate RAW signal
* SubGhz: fix triangle glitch in save raw view
* SubGhz: fix receiver config scene
* SubGhz: fix transfer after returning from save scene
* Canvas: add font rotation
* SubGhz: raw protocol encoder
* SubGhz: fix error completion of transfer raw encoder
* SubGhz: increased the speed of reading RAW data from a flash drive, displaying the name of the saved file in the Save RAW scene
* Canvas: fix font rotation
* SubGhz: fix navigation save RAW  scene
* SubGhz: add decode came atomo
* Git: renormalize
* Cleanup sources and enums
* Gui: add font direction to canvas reset, canvas init sequence cleanup.
* SubGhz: reorder menu.
* Gui: correct canvas_set_font_direction signature

Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
This commit is contained in:
Skorpionm
2021-10-25 18:37:14 +04:00
committed by GitHub
parent 88cee4601a
commit 9d952ed855
59 changed files with 1693 additions and 199 deletions
Download Patch File Download Diff File Expand all files Collapse all files

75
lib/subghz/protocols/subghz_protocol_common.c
View File

@@ -2,7 +2,6 @@
#include <stdio.h>
#include <lib/toolbox/hex.h>
SubGhzProtocolCommonEncoder* subghz_protocol_encoder_common_alloc() {
SubGhzProtocolCommonEncoder* instance = furi_alloc(sizeof(SubGhzProtocolCommonEncoder));
instance->upload = furi_alloc(SUBGHZ_ENCODER_UPLOAD_MAX_SIZE * sizeof(LevelDuration));
@@ -13,6 +12,9 @@ SubGhzProtocolCommonEncoder* subghz_protocol_encoder_common_alloc() {
void subghz_protocol_encoder_common_free(SubGhzProtocolCommonEncoder* instance) {
furi_assert(instance);
if(instance->callback_end) {
instance->callback_end((SubGhzProtocolCommon*)instance->context_end);
}
free(instance->upload);
free(instance);
}
@@ -22,10 +24,34 @@ size_t subghz_encoder_common_get_repeat_left(SubGhzProtocolCommonEncoder* instan
return instance->repeat;
}
void subghz_protocol_encoder_common_set_callback(
SubGhzProtocolCommonEncoder* instance,
SubGhzProtocolCommonEncoderCallback callback,
void* context) {
furi_assert(instance);
furi_assert(callback);
instance->callback = callback;
instance->context = context;
}
void subghz_protocol_encoder_common_set_callback_end(
SubGhzProtocolCommonEncoder* instance,
SubGhzProtocolCommonEncoderCallbackEnd callback_end,
void* context_end) {
furi_assert(instance);
furi_assert(callback_end);
instance->callback_end = callback_end;
instance->context_end = context_end;
}
LevelDuration subghz_protocol_encoder_common_yield(void* context) {
SubGhzProtocolCommonEncoder* instance = context;
if(instance->repeat == 0){
if(instance->callback) {
return instance->callback((SubGhzProtocolCommon*)instance->context);
}
if(instance->repeat == 0) {
return level_duration_reset();
}
@@ -39,46 +65,53 @@ LevelDuration subghz_protocol_encoder_common_yield(void* context) {
return ret;
}
void subghz_protocol_common_add_bit(SubGhzProtocolCommon *common, uint8_t bit){
void subghz_protocol_common_add_bit(SubGhzProtocolCommon* common, uint8_t bit) {
common->code_found = common->code_found << 1 | bit;
common->code_count_bit++;
}
bool subghz_protocol_common_check_interval(SubGhzProtocolCommon *common, uint32_t duration, uint16_t duration_check) {
if ((duration_check >= (duration - common->te_delta))&&(duration_check <= (duration + common->te_delta))){
bool subghz_protocol_common_check_interval(
SubGhzProtocolCommon* common,
uint32_t duration,
uint16_t duration_check) {
if((duration_check >= (duration - common->te_delta)) &&
(duration_check <= (duration + common->te_delta))) {
return true;
} else {
return false;
}
}
uint64_t subghz_protocol_common_reverse_key(uint64_t key, uint8_t count_bit){
uint64_t key_reverse=0;
for(uint8_t i=0; i<count_bit; i++) {
key_reverse=key_reverse<<1|bit_read(key,i);
uint64_t subghz_protocol_common_reverse_key(uint64_t key, uint8_t count_bit) {
uint64_t key_reverse = 0;
for(uint8_t i = 0; i < count_bit; i++) {
key_reverse = key_reverse << 1 | bit_read(key, i);
}
return key_reverse;
}
void subghz_protocol_common_set_callback(SubGhzProtocolCommon* common, SubGhzProtocolCommonCallback callback, void* context) {
void subghz_protocol_common_set_callback(
SubGhzProtocolCommon* common,
SubGhzProtocolCommonCallback callback,
void* context) {
common->callback = callback;
common->context = context;
}
void subghz_protocol_common_to_str(SubGhzProtocolCommon* instance, string_t output) {
if (instance->to_string) {
if(instance->to_string) {
instance->to_string(instance, output);
} else {
uint32_t code_found_hi = instance->code_found >> 32;
uint32_t code_found_lo = instance->code_found & 0x00000000ffffffff;
uint64_t code_found_reverse = subghz_protocol_common_reverse_key(instance->code_found, instance->code_count_bit);
uint64_t code_found_reverse =
subghz_protocol_common_reverse_key(instance->code_found, instance->code_count_bit);
uint32_t code_found_reverse_hi = code_found_reverse>>32;
uint32_t code_found_reverse_lo = code_found_reverse&0x00000000ffffffff;
uint32_t code_found_reverse_hi = code_found_reverse >> 32;
uint32_t code_found_reverse_lo = code_found_reverse & 0x00000000ffffffff;
if (code_found_hi>0) {
if(code_found_hi > 0) {
string_cat_printf(
output,
"Protocol %s, %d Bit\r\n"
@@ -92,8 +125,7 @@ void subghz_protocol_common_to_str(SubGhzProtocolCommon* instance, string_t outp
code_found_reverse_hi,
code_found_reverse_lo,
instance->serial,
instance->btn
);
instance->btn);
} else {
string_cat_printf(
output,
@@ -108,8 +140,7 @@ void subghz_protocol_common_to_str(SubGhzProtocolCommon* instance, string_t outp
code_found_reverse_hi,
code_found_reverse_lo,
instance->serial,
instance->btn
);
instance->btn);
}
}
}
@@ -124,9 +155,9 @@ bool subghz_protocol_common_read_hex(string_t str, uint8_t* buff, uint16_t len)
if(hex_char_to_hex_nibble(string_get_char(str, 0), &nibble_high) &&
hex_char_to_hex_nibble(string_get_char(str, 1), &nibble_low)) {
buff[i] = (nibble_high << 4) | nibble_low;
if(string_size(str)>2){
if(string_size(str) > 2) {
string_right(str, 2);
}else if(i<len-1){
} else if(i < len - 1) {
parsed = false;
break;
};