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

[FL-1815, FL-1851, FL-1856] SubGhz: preparation for certification, add deleting stored signals and rename file in SubGHz app (#714)

Browse Source 
* [FL-1811] FuriHal: move core2 startup to hal init stage, prevent working with flash controller till core2 startup finish. #704
* SubGhz: fix GO0 low on last hop transmission,  decreased DutyCycle in tests
* SubGhz: test_static fix max 5 sec in transmission mode, DutyCycle <23%
* [FL-1815] SubGhz: prohibiting transmission if it is not within the permitted range for the given region
* SubGhz: fix F7 furi-hal-subghz
* SubGhz: fix logic working tests
* SubGhz: fix princeton encoder for test
* SubGhz: add log princeton encoder
* [FL-1856] Subghz: fix output a double error if the file cannot be opened
* [FL-1851] SubGhz: add deleting Stored Signals in SubGHz App
* SubGhz: add rename file SubGhz app
* SubGhz: update stats message in princeton
* SubGhz: correct spelling
* SubGhz: fix FM config,  add hardware signal processing less than 16 μs,  add added filter for processing short signals
* SubGhz: add Scher-Khan MAGICAR Dinamic protocol
* SubGhz: sync fury targets

Co-authored-by: あく <alleteam@gmail.com>
This commit is contained in:
Skorpionm
2021-09-28 04:05:40 +04:00
committed by GitHub
parent 416e1bda35
commit a8981d317a
32 changed files with 1111 additions and 152 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
lib/drivers/cc1101_regs.h
View File

@@ -48,9 +48,9 @@ extern "C" {
#define CC1101_MCSM0 0x18 /** Main Radio Control State Machine configuration */
#define CC1101_FOCCFG 0x19 /** Frequency Offset Compensation configuration */
#define CC1101_BSCFG 0x1A /** Bit Synchronization configuration */
#define CC1101_AGCTRL2 0x1B /** AGC control */
#define CC1101_AGCTRL1 0x1C /** AGC control */
#define CC1101_AGCTRL0 0x1D /** AGC control */
#define CC1101_AGCCTRL2 0x1B /** AGC control */
#define CC1101_AGCCTRL1 0x1C /** AGC control */
#define CC1101_AGCCTRL0 0x1D /** AGC control */
#define CC1101_WOREVT1 0x1E /** High byte Event 0 timeout */
#define CC1101_WOREVT0 0x1F /** Low byte Event 0 timeout */
#define CC1101_WORCTRL 0x20 /** Wake On Radio control */

52
lib/subghz/protocols/subghz_protocol_princeton.c
View File

@@ -8,12 +8,17 @@
#define SUBGHZ_PT_SHORT 400
#define SUBGHZ_PT_LONG (SUBGHZ_PT_SHORT * 3)
#define SUBGHZ_PT_GUARD (SUBGHZ_PT_SHORT * 30)
#define SUBGHZ_PT_COUNT_KEY 5
#define SUBGHZ_PT_TIMEOUT 320
struct SubGhzEncoderPrinceton {
uint32_t key;
uint16_t te;
size_t repeat;
size_t front;
size_t count_key;
uint32_t time_high;
uint32_t time_low;
};
typedef enum {
@@ -45,8 +50,11 @@ void subghz_encoder_princeton_set(SubGhzEncoderPrinceton* instance, uint32_t key
furi_assert(instance);
instance->te = SUBGHZ_PT_SHORT;
instance->key = key;
instance->repeat = repeat;
instance->repeat = repeat + 1;
instance->front = 48;
instance->count_key = SUBGHZ_PT_COUNT_KEY + 7;
instance->time_high = 0;
instance->time_low = 0;
}
size_t subghz_encoder_princeton_get_repeat_left(SubGhzEncoderPrinceton* instance) {
@@ -54,9 +62,25 @@ size_t subghz_encoder_princeton_get_repeat_left(SubGhzEncoderPrinceton* instance
return instance->repeat;
}
void subghz_encoder_princeton_print_log(void* context) {
SubGhzEncoderPrinceton* instance = context;
float duty_cycle =
((float)instance->time_high / (instance->time_high + instance->time_low)) * 100;
FURI_LOG_I(
"EncoderPrinceton",
"Radio ON=%dus, OFF=%dus, DutyCycle=%d,%d%%",
instance->time_high,
instance->time_low,
(uint32_t)duty_cycle,
(uint32_t)((duty_cycle - (uint32_t)duty_cycle) * 100));
}
LevelDuration subghz_encoder_princeton_yield(void* context) {
SubGhzEncoderPrinceton* instance = context;
if(instance->repeat == 0) return level_duration_reset();
if(instance->repeat == 0) {
subghz_encoder_princeton_print_log(instance);
return level_duration_reset();
}
size_t bit = instance->front / 2;
bool level = !(instance->front % 2);
@@ -68,11 +92,33 @@ LevelDuration subghz_encoder_princeton_yield(void* context) {
bool value = (((uint8_t*)&instance->key)[2 - byte] >> (7 - bit_in_byte)) & 1;
if(value) {
ret = level_duration_make(level, level ? instance->te * 3 : instance->te);
if(level)
instance->time_high += instance->te * 3;
else
instance->time_low += instance->te;
} else {
ret = level_duration_make(level, level ? instance->te : instance->te * 3);
if(level)
instance->time_high += instance->te;
else
instance->time_low += instance->te * 3;
}
} else {
ret = level_duration_make(level, level ? instance->te : instance->te * 30);
if(--instance->count_key != 0) {
ret = level_duration_make(level, level ? instance->te : instance->te * 30);
if(level)
instance->time_high += instance->te;
else
instance->time_low += instance->te * 30;
} else {
instance->count_key = SUBGHZ_PT_COUNT_KEY + 6;
instance->front = 48;
ret = level_duration_make(level, level ? instance->te : SUBGHZ_PT_TIMEOUT * 1000);
if(level)
instance->time_high += instance->te;
else
instance->time_low += SUBGHZ_PT_TIMEOUT * 1000;
}
}
instance->front++;

5
lib/subghz/protocols/subghz_protocol_princeton.h
View File

@@ -33,6 +33,11 @@ void subghz_encoder_princeton_set(SubGhzEncoderPrinceton* instance, uint32_t key
*/
size_t subghz_encoder_princeton_get_repeat_left(SubGhzEncoderPrinceton* instance);
/** Print encoder log
* @param instance - SubGhzEncoderPrinceton instance
*/
void subghz_encoder_princeton_print_log(void* context);
/** Get level duration
* @param instance - SubGhzEncoderPrinceton instance
* @return level duration

246
lib/subghz/protocols/subghz_protocol_scher_khan.c Normal file
View File

@@ -0,0 +1,246 @@
#include "subghz_protocol_scher_khan.h"
//https://phreakerclub.com/72
//https://phreakerclub.com/forum/showthread.php?t=7&page=2
//https://phreakerclub.com/forum/showthread.php?t=274&highlight=magicar
//!!! https://phreakerclub.com/forum/showthread.php?t=489&highlight=magicar&page=5
struct SubGhzProtocolScherKhan {
SubGhzProtocolCommon common;
const char* protocol_name;
};
typedef enum {
ScherKhanDecoderStepReset = 0,
ScherKhanDecoderStepCheckPreambula,
ScherKhanDecoderStepSaveDuration,
ScherKhanDecoderStepCheckDuration,
} ScherKhanDecoderStep;
SubGhzProtocolScherKhan* subghz_protocol_scher_khan_alloc(void) {
SubGhzProtocolScherKhan* instance = furi_alloc(sizeof(SubGhzProtocolScherKhan));
instance->common.name = "Scher-Khan";
instance->common.code_min_count_bit_for_found = 35;
instance->common.te_short = 750;
instance->common.te_long = 1100;
instance->common.te_delta = 150;
instance->common.type_protocol = SubGhzProtocolCommonTypeDynamic;
instance->common.to_string = (SubGhzProtocolCommonToStr)subghz_protocol_scher_khan_to_str;
instance->common.to_load_protocol =
(SubGhzProtocolCommonLoadFromRAW)subghz_decoder_scher_khan_to_load_protocol;
return instance;
}
void subghz_protocol_scher_khan_free(SubGhzProtocolScherKhan* instance) {
furi_assert(instance);
free(instance);
}
/** Send bit
*
* @param instance - SubGhzProtocolScherKhan instance
* @param bit - bit
*/
// void subghz_protocol_scher_khan_send_bit(SubGhzProtocolScherKhan* instance, uint8_t bit) {
// if(bit) {
// //send bit 1
// SUBGHZ_TX_PIN_HIGH();
// delay_us(instance->common.te_long);
// SUBGHZ_TX_PIN_LOW();
// delay_us(instance->common.te_short);
// } else {
// //send bit 0
// SUBGHZ_TX_PIN_HIGH();
// delay_us(instance->common.te_short);
// SUBGHZ_TX_PIN_LOW();
// delay_us(instance->common.te_long);
// }
// }
// void subghz_protocol_scher_khan_send_key(
// SubGhzProtocolScherKhan* instance,
// uint64_t key,
// uint8_t bit,
// uint8_t repeat) {
// while(repeat--) {
// SUBGHZ_TX_PIN_HIGH();
// //Send header
// delay_us(instance->common.te_long * 2);
// SUBGHZ_TX_PIN_LOW();
// delay_us(instance->common.te_long * 2);
// //Send key data
// for(uint8_t i = bit; i > 0; i--) {
// subghz_protocol_scher_khan_send_bit(instance, bit_read(key, i - 1));
// }
// }
// }
void subghz_protocol_scher_khan_reset(SubGhzProtocolScherKhan* instance) {
instance->common.parser_step = ScherKhanDecoderStepReset;
}
/** Analysis of received data
*
* @param instance SubGhzProtocolScherKhan instance
*/
void subghz_protocol_scher_khan_check_remote_controller(SubGhzProtocolScherKhan* instance) {
/*
* MAGICAR 51 bit 00000001A99121DE83C3 MAGIC CODE, Dinamic
* 0E8C1619E830C -> 000011101000110000010110 0001 1001 1110 1000001100001100
* 0E8C1629D830D -> 000011101000110000010110 0010 1001 1101 1000001100001101
* 0E8C1649B830E -> 000011101000110000010110 0100 1001 1011 1000001100001110
* 0E8C16897830F -> 000011101000110000010110 1000 1001 0111 1000001100001111
* Serial Key Ser ~Key CNT
*/
switch(instance->common.code_last_count_bit) {
// case 35: //MAGIC CODE, Static
// instance->protocol_name = "MAGIC CODE, Static";
// break;
case 51: //MAGIC CODE, Dinamic
instance->protocol_name = "MAGIC CODE, Dinamic";
instance->common.serial = ((instance->common.code_last_found >> 24) & 0xFFFFFF0) |
((instance->common.code_last_found >> 20) & 0x0F);
instance->common.btn = (instance->common.code_last_found >> 24) & 0x0F;
instance->common.cnt = instance->common.code_last_found & 0xFFFF;
break;
// case 57: //MAGIC CODE PRO / PRO2
// instance->protocol_name = "MAGIC CODE PRO / PRO2";
// break;
default:
instance->protocol_name = "Unknown";
instance->common.serial = 0;
instance->common.btn = 0;
instance->common.cnt = 0;
break;
}
}
void subghz_protocol_scher_khan_parse(
SubGhzProtocolScherKhan* instance,
bool level,
uint32_t duration) {
switch(instance->common.parser_step) {
case ScherKhanDecoderStepReset:
if((level) &&
(DURATION_DIFF(duration, instance->common.te_short * 2) < instance->common.te_delta)) {
instance->common.parser_step = ScherKhanDecoderStepCheckPreambula;
instance->common.te_last = duration;
instance->common.header_count = 0;
} else {
instance->common.parser_step = ScherKhanDecoderStepReset;
}
break;
case ScherKhanDecoderStepCheckPreambula:
if(level) {
if((DURATION_DIFF(duration, instance->common.te_short * 2) <
instance->common.te_delta) ||
(DURATION_DIFF(duration, instance->common.te_short) < instance->common.te_delta)) {
instance->common.te_last = duration;
} else {
instance->common.parser_step = ScherKhanDecoderStepReset;
}
} else if(
(DURATION_DIFF(duration, instance->common.te_short * 2) < instance->common.te_delta) ||
(DURATION_DIFF(duration, instance->common.te_short) < instance->common.te_delta)) {
if(DURATION_DIFF(instance->common.te_last, instance->common.te_short * 2) <
instance->common.te_delta) {
// Found header
instance->common.header_count++;
break;
} else if(
DURATION_DIFF(instance->common.te_last, instance->common.te_short) <
instance->common.te_delta) {
// Found start bit
if(instance->common.header_count >= 2) {
instance->common.parser_step = ScherKhanDecoderStepSaveDuration;
instance->common.code_found = 0;
instance->common.code_count_bit = 1;
} else {
instance->common.parser_step = ScherKhanDecoderStepReset;
}
} else {
instance->common.parser_step = ScherKhanDecoderStepReset;
}
} else {
instance->common.parser_step = ScherKhanDecoderStepReset;
}
break;
case ScherKhanDecoderStepSaveDuration:
if(level) {
if(duration >= (instance->common.te_long + instance->common.te_delta * 2)) {
//Found stop bit
instance->common.parser_step = ScherKhanDecoderStepReset;
if(instance->common.code_count_bit >=
instance->common.code_min_count_bit_for_found) {
instance->common.code_last_found = instance->common.code_found;
instance->common.code_last_count_bit = instance->common.code_count_bit;
if(instance->common.callback)
instance->common.callback(
(SubGhzProtocolCommon*)instance, instance->common.context);
}
instance->common.code_found = 0;
instance->common.code_count_bit = 0;
break;
} else {
instance->common.te_last = duration;
instance->common.parser_step = ScherKhanDecoderStepCheckDuration;
}
} else {
instance->common.parser_step = ScherKhanDecoderStepReset;
}
break;
case ScherKhanDecoderStepCheckDuration:
if(!level) {
if((DURATION_DIFF(instance->common.te_last, instance->common.te_short) <
instance->common.te_delta) &&
(DURATION_DIFF(duration, instance->common.te_short) < instance->common.te_delta)) {
subghz_protocol_common_add_bit(&instance->common, 0);
instance->common.parser_step = ScherKhanDecoderStepSaveDuration;
} else if(
(DURATION_DIFF(instance->common.te_last, instance->common.te_long) <
instance->common.te_delta) &&
(DURATION_DIFF(duration, instance->common.te_long) < instance->common.te_delta)) {
subghz_protocol_common_add_bit(&instance->common, 1);
instance->common.parser_step = ScherKhanDecoderStepSaveDuration;
} else {
instance->common.parser_step = ScherKhanDecoderStepReset;
}
} else {
instance->common.parser_step = ScherKhanDecoderStepReset;
}
break;
}
}
void subghz_protocol_scher_khan_to_str(SubGhzProtocolScherKhan* instance, string_t output) {
subghz_protocol_scher_khan_check_remote_controller(instance);
string_cat_printf(
output,
"%s %dbit\r\n"
"Key:0x%lX%08lX\r\n"
"Sn:%07lX Btn:%lX Cnt:%04X\r\n"
"Pt: %s\r\n",
instance->common.name,
instance->common.code_last_count_bit,
(uint32_t)(instance->common.code_last_found >> 32),
(uint32_t)instance->common.code_last_found,
instance->common.serial,
instance->common.btn,
instance->common.cnt,
instance->protocol_name);
}
void subghz_decoder_scher_khan_to_load_protocol(SubGhzProtocolScherKhan* instance, void* context) {
furi_assert(context);
furi_assert(instance);
SubGhzProtocolCommonLoad* data = context;
instance->common.code_last_found = data->code_found;
instance->common.code_last_count_bit = data->code_count_bit;
subghz_protocol_scher_khan_check_remote_controller(instance);
}

58
lib/subghz/protocols/subghz_protocol_scher_khan.h Normal file
View File

@@ -0,0 +1,58 @@
#pragma once
#include "subghz_protocol_common.h"
typedef struct SubGhzProtocolScherKhan SubGhzProtocolScherKhan;
/** Allocate SubGhzProtocolScherKhan
*
* @return SubGhzProtocolScherKhan*
*/
SubGhzProtocolScherKhan* subghz_protocol_scher_khan_alloc();
/** Free SubGhzProtocolScherKhan
*
* @param instance
*/
void subghz_protocol_scher_khan_free(SubGhzProtocolScherKhan* instance);
/** Sends the key on the air
*
* @param instance - SubGhzProtocolScherKhan instance
* @param key - key send
* @param bit - count bit key
* @param repeat - repeat send key
*/
void subghz_protocol_scher_khan_send_key(SubGhzProtocolScherKhan* instance, uint64_t key, uint8_t bit, uint8_t repeat);
/** Reset internal state
* @param instance - SubGhzProtocolScherKhan instance
*/
void subghz_protocol_scher_khan_reset(SubGhzProtocolScherKhan* instance);
/** Analysis of received data
*
* @param instance SubGhzProtocolScherKhan instance
*/
void subghz_protocol_scher_khan_check_remote_controller(SubGhzProtocolScherKhan* instance);
/** Parse accepted duration
*
* @param instance - SubGhzProtocolScherKhan instance
* @param data - LevelDuration level_duration
*/
void subghz_protocol_scher_khan_parse(SubGhzProtocolScherKhan* instance, bool level, uint32_t duration);
/** Outputting information from the parser
*
* @param instance - SubGhzProtocolScherKhan* instance
* @param output - output string
*/
void subghz_protocol_scher_khan_to_str(SubGhzProtocolScherKhan* instance, string_t output);
/** Loading protocol from bin data
*
* @param instance - SubGhzProtocolScherKhan instance
* @param context - SubGhzProtocolCommonLoad context
*/
void subghz_decoder_scher_khan_to_load_protocol(SubGhzProtocolScherKhan* instance, void* context);

12
lib/subghz/subghz_parser.c
View File

@@ -12,6 +12,7 @@
#include "protocols/subghz_protocol_nero_sketch.h"
#include "protocols/subghz_protocol_star_line.h"
#include "protocols/subghz_protocol_nero_radio.h"
#include "protocols/subghz_protocol_scher_khan.h"
#include "subghz_keystore.h"
@@ -30,6 +31,7 @@ typedef enum {
SubGhzProtocolTypeNeroSketch,
SubGhzProtocolTypeStarLine,
SubGhzProtocolTypeNeroRadio,
SubGhzProtocolTypeScherKhan,
SubGhzProtocolTypeMax,
} SubGhzProtocolType;
@@ -93,6 +95,8 @@ SubGhzParser* subghz_parser_alloc() {
(SubGhzProtocolCommon*)subghz_protocol_star_line_alloc(instance->keystore);
instance->protocols[SubGhzProtocolTypeNeroRadio] =
(SubGhzProtocolCommon*)subghz_protocol_nero_radio_alloc();
instance->protocols[SubGhzProtocolTypeScherKhan] =
(SubGhzProtocolCommon*)subghz_protocol_scher_khan_alloc();
return instance;
}
@@ -120,6 +124,8 @@ void subghz_parser_free(SubGhzParser* instance) {
(SubGhzProtocolStarLine*)instance->protocols[SubGhzProtocolTypeStarLine]);
subghz_protocol_nero_radio_free(
(SubGhzProtocolNeroRadio*)instance->protocols[SubGhzProtocolTypeNeroRadio]);
subghz_protocol_scher_khan_free(
(SubGhzProtocolScherKhan*)instance->protocols[SubGhzProtocolTypeScherKhan]);
subghz_keystore_free(instance->keystore);
@@ -199,6 +205,8 @@ void subghz_parser_reset(SubGhzParser* instance) {
(SubGhzProtocolStarLine*)instance->protocols[SubGhzProtocolTypeStarLine]);
subghz_protocol_nero_radio_reset(
(SubGhzProtocolNeroRadio*)instance->protocols[SubGhzProtocolTypeNeroRadio]);
subghz_protocol_scher_khan_reset(
(SubGhzProtocolScherKhan*)instance->protocols[SubGhzProtocolTypeScherKhan]);
}
void subghz_parser_parse(SubGhzParser* instance, bool level, uint32_t duration) {
@@ -232,4 +240,8 @@ void subghz_parser_parse(SubGhzParser* instance, bool level, uint32_t duration)
(SubGhzProtocolNeroRadio*)instance->protocols[SubGhzProtocolTypeNeroRadio],
level,
duration);
subghz_protocol_scher_khan_parse(
(SubGhzProtocolScherKhan*)instance->protocols[SubGhzProtocolTypeScherKhan],
level,
duration);
}

44
lib/subghz/subghz_worker.c
View File

@@ -10,6 +10,10 @@ struct SubGhzWorker {
volatile bool running;
volatile bool overrun;
LevelDuration filter_level_duration;
bool filter_running;
uint16_t filter_duration;
SubGhzWorkerOverrunCallback overrun_callback;
SubGhzWorkerPairCallback pair_callback;
void* context;
@@ -30,8 +34,8 @@ void subghz_worker_rx_callback(bool level, uint32_t duration, void* context) {
instance->overrun = false;
level_duration = level_duration_reset();
}
size_t ret =
xStreamBufferSendFromISR(instance->stream, &level_duration, sizeof(LevelDuration), &xHigherPriorityTaskWoken);
size_t ret = xStreamBufferSendFromISR(
instance->stream, &level_duration, sizeof(LevelDuration), &xHigherPriorityTaskWoken);
if(sizeof(LevelDuration) != ret) instance->overrun = true;
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
@@ -46,15 +50,35 @@ static int32_t subghz_worker_thread_callback(void* context) {
LevelDuration level_duration;
while(instance->running) {
int ret = xStreamBufferReceive(instance->stream, &level_duration, sizeof(LevelDuration), 10);
int ret =
xStreamBufferReceive(instance->stream, &level_duration, sizeof(LevelDuration), 10);
if(ret == sizeof(LevelDuration)) {
if(level_duration_is_reset(level_duration)) {
printf(".");
if (instance->overrun_callback) instance->overrun_callback(instance->context);
if(instance->overrun_callback) instance->overrun_callback(instance->context);
} else {
bool level = level_duration_get_level(level_duration);
uint32_t duration = level_duration_get_duration(level_duration);
if (instance->pair_callback) instance->pair_callback(instance->context, level, duration);
if(instance->filter_running) {
if((duration < instance->filter_duration) ||
(instance->filter_level_duration.level == level)) {
instance->filter_level_duration.duration += duration;
} else if(instance->filter_level_duration.level != level) {
if(instance->pair_callback)
instance->pair_callback(
instance->context,
instance->filter_level_duration.level,
instance->filter_level_duration.duration);
instance->filter_level_duration.duration = duration;
instance->filter_level_duration.level = level;
}
} else {
if(instance->pair_callback)
instance->pair_callback(instance->context, level, duration);
}
}
}
}
@@ -70,9 +94,13 @@ SubGhzWorker* subghz_worker_alloc() {
furi_thread_set_stack_size(instance->thread, 2048);
furi_thread_set_context(instance->thread, instance);
furi_thread_set_callback(instance->thread, subghz_worker_thread_callback);
instance->stream = xStreamBufferCreate(sizeof(LevelDuration) * 1024, sizeof(LevelDuration));
//setting filter
instance->filter_running = true;
instance->filter_duration = 20;
return instance;
}
@@ -85,7 +113,9 @@ void subghz_worker_free(SubGhzWorker* instance) {
free(instance);
}
void subghz_worker_set_overrun_callback(SubGhzWorker* instance, SubGhzWorkerOverrunCallback callback) {
void subghz_worker_set_overrun_callback(
SubGhzWorker* instance,
SubGhzWorkerOverrunCallback callback) {
furi_assert(instance);
instance->overrun_callback = callback;
}