mirror of
https://github.com/DarkFlippers/unleashed-firmware
synced 2024-12-23 19:23:09 +00:00
1074 lines
36 KiB
C
1074 lines
36 KiB
C
#include <furi.h>
|
|
|
|
#include <gui/gui.h>
|
|
#include <input/input.h>
|
|
#include <dialogs/dialogs.h>
|
|
#include <storage/storage.h>
|
|
|
|
#include <notification/notification.h>
|
|
#include <notification/notification_messages.h>
|
|
|
|
#include <assets_icons.h>
|
|
|
|
#include <flipper_format/flipper_format_i.h>
|
|
#include <lib/toolbox/path.h>
|
|
#include <applications/main/subghz/subghz_i.h>
|
|
|
|
#include <lib/subghz/protocols/raw.h>
|
|
#include <lib/subghz/protocols/protocol_items.h>
|
|
#include <lib/subghz/types.h>
|
|
#include <lib/subghz/protocols/keeloq.h>
|
|
#include <lib/subghz/protocols/star_line.h>
|
|
#include <lib/subghz/protocols/alutech_at_4n.h>
|
|
#include <lib/subghz/protocols/nice_flor_s.h>
|
|
#include <lib/subghz/protocols/somfy_telis.h>
|
|
#include <lib/subghz/protocols/secplus_v2.h>
|
|
|
|
#define SUBREMOTEMAP_FOLDER "/ext/subghz_remote"
|
|
#define SUBREMOTEMAP_EXTENSION ".txt"
|
|
|
|
#define TAG "SubGHzRemote"
|
|
|
|
typedef struct {
|
|
uint32_t frequency;
|
|
FuriString* name;
|
|
|
|
FuriString* protocol;
|
|
uint32_t repeat;
|
|
|
|
uint8_t* data;
|
|
size_t data_size;
|
|
|
|
SubGhzProtocolDecoderBase* decoder;
|
|
} SubRemotePreset;
|
|
|
|
typedef struct {
|
|
FuriMutex* model_mutex;
|
|
|
|
FuriMessageQueue* input_queue;
|
|
|
|
ViewPort* view_port;
|
|
Gui* gui;
|
|
|
|
SubGhzSetting* setting;
|
|
SubGhzEnvironment* environment;
|
|
SubGhzReceiver* subghz_receiver;
|
|
NotificationApp* notification;
|
|
SubRemotePreset* txpreset;
|
|
|
|
FuriString* up_file;
|
|
FuriString* down_file;
|
|
FuriString* left_file;
|
|
FuriString* right_file;
|
|
FuriString* ok_file;
|
|
|
|
FuriString* file_path;
|
|
|
|
char* up_label;
|
|
char* down_label;
|
|
char* left_label;
|
|
char* right_label;
|
|
char* ok_label;
|
|
|
|
int up_enabled;
|
|
int down_enabled;
|
|
int left_enabled;
|
|
int right_enabled;
|
|
int ok_enabled;
|
|
|
|
char* send_status;
|
|
int send_status_c;
|
|
int processing;
|
|
|
|
SubGhzTransmitter* tx_transmitter;
|
|
FlipperFormat* tx_fff_data;
|
|
const char* tx_file_path;
|
|
int button;
|
|
|
|
int file_result;
|
|
bool tx_not_allowed;
|
|
|
|
FuriString* signal;
|
|
} SubGHzRemote;
|
|
|
|
SubRemotePreset* subghz_remote_preset_alloc(void) {
|
|
SubRemotePreset* preset = malloc(sizeof(SubRemotePreset));
|
|
preset->name = furi_string_alloc();
|
|
preset->protocol = furi_string_alloc();
|
|
preset->repeat = 200;
|
|
return preset;
|
|
}
|
|
|
|
void subghz_remote_preset_free(SubRemotePreset* preset) {
|
|
furi_string_free(preset->name);
|
|
furi_string_free(preset->protocol);
|
|
free(preset);
|
|
}
|
|
|
|
static char* char_to_str(char* str, int i) {
|
|
char* converted = malloc(sizeof(char) * i + 1);
|
|
memcpy(converted, str, i);
|
|
|
|
converted[i] = '\0';
|
|
|
|
return converted;
|
|
}
|
|
|
|
//get filename without path
|
|
static char* extract_filename(const char* name, int len) {
|
|
FuriString* tmp;
|
|
tmp = furi_string_alloc();
|
|
|
|
//remove path
|
|
path_extract_filename_no_ext(name, tmp);
|
|
|
|
return char_to_str((char*)furi_string_get_cstr(tmp), len);
|
|
}
|
|
|
|
static void cfg_read_file_path(
|
|
FlipperFormat* fff_file,
|
|
FuriString* text_file_path,
|
|
char** text_file_label,
|
|
const char* read_key,
|
|
int* is_enabled) {
|
|
if(!flipper_format_read_string(fff_file, read_key, text_file_path)) {
|
|
FURI_LOG_W(TAG, "Could not read %s string", read_key);
|
|
*text_file_label = "N/A";
|
|
*is_enabled = 0;
|
|
} else {
|
|
*text_file_label = extract_filename(furi_string_get_cstr(text_file_path), 16);
|
|
FURI_LOG_D(TAG, "%s file: %s", read_key, furi_string_get_cstr(text_file_path));
|
|
*is_enabled = 1;
|
|
}
|
|
flipper_format_rewind(fff_file);
|
|
}
|
|
|
|
static void cfg_read_file_label(
|
|
FlipperFormat* fff_file,
|
|
char** text_file_label,
|
|
const char* read_key,
|
|
bool is_enabled) {
|
|
FuriString* temp_label = furi_string_alloc();
|
|
|
|
if(!flipper_format_read_string(fff_file, read_key, temp_label)) {
|
|
FURI_LOG_W(TAG, "Could not read %s string", read_key);
|
|
} else {
|
|
if(is_enabled == 1) {
|
|
*text_file_label = char_to_str((char*)furi_string_get_cstr(temp_label), 16);
|
|
}
|
|
FURI_LOG_D(TAG, "%s label: %s", read_key, *text_file_label);
|
|
}
|
|
flipper_format_rewind(fff_file);
|
|
furi_string_free(temp_label);
|
|
}
|
|
|
|
/*
|
|
* check that map file exists
|
|
* assign variables to values within map file
|
|
* set missing filenames to N/A
|
|
* set filename as label if label definitions are missing
|
|
* set error flag if all buttons are N/A
|
|
* set error flag if missing map file
|
|
*/
|
|
|
|
void subghz_remote_cfg_set_check(SubGHzRemote* app, FuriString* file_name) {
|
|
Storage* storage = furi_record_open(RECORD_STORAGE);
|
|
FlipperFormat* fff_data_file = flipper_format_file_alloc(storage);
|
|
|
|
app->file_result = 1;
|
|
|
|
app->up_enabled = 0;
|
|
app->down_enabled = 0;
|
|
app->left_enabled = 0;
|
|
app->right_enabled = 0;
|
|
app->ok_enabled = 0;
|
|
|
|
//check that map file exists
|
|
if(!flipper_format_file_open_existing(fff_data_file, furi_string_get_cstr(file_name))) {
|
|
FURI_LOG_E(TAG, "Could not open MAP file %s", furi_string_get_cstr(file_name));
|
|
} else {
|
|
//Filename Assignment/Check Start
|
|
|
|
//assign variables to values within map file
|
|
//set missing filenames to N/A
|
|
cfg_read_file_path(fff_data_file, app->up_file, &app->up_label, "UP", &app->up_enabled);
|
|
|
|
cfg_read_file_path(
|
|
fff_data_file, app->down_file, &app->down_label, "DOWN", &app->down_enabled);
|
|
|
|
cfg_read_file_path(
|
|
fff_data_file, app->left_file, &app->left_label, "LEFT", &app->left_enabled);
|
|
|
|
cfg_read_file_path(
|
|
fff_data_file, app->right_file, &app->right_label, "RIGHT", &app->right_enabled);
|
|
|
|
cfg_read_file_path(fff_data_file, app->ok_file, &app->ok_label, "OK", &app->ok_enabled);
|
|
|
|
//File definitions are done.
|
|
//File checks will follow after label assignment in order to close the universal_rf_map file without the need to reopen it again.
|
|
|
|
//Label Assignment/Check Start
|
|
|
|
cfg_read_file_label(fff_data_file, &app->up_label, "ULABEL", app->up_enabled);
|
|
cfg_read_file_label(fff_data_file, &app->down_label, "DLABEL", app->down_enabled);
|
|
cfg_read_file_label(fff_data_file, &app->left_label, "LLABEL", app->left_enabled);
|
|
cfg_read_file_label(fff_data_file, &app->right_label, "RLABEL", app->right_enabled);
|
|
cfg_read_file_label(fff_data_file, &app->ok_label, "OKLABEL", app->ok_enabled);
|
|
}
|
|
|
|
flipper_format_file_close(fff_data_file);
|
|
flipper_format_free(fff_data_file);
|
|
|
|
//File Existence Check
|
|
//Check each file definition if not already set to "N/A"
|
|
|
|
//determine if files exist.
|
|
//determine whether or not to continue to launch app with missing variables
|
|
//if 5 files are missing, throw error
|
|
|
|
//if button is still enabled, check that file exists
|
|
if(app->up_enabled == 1) {
|
|
furi_string_set(file_name, app->up_file);
|
|
fff_data_file = flipper_format_file_alloc(storage);
|
|
|
|
if(!flipper_format_file_open_existing(fff_data_file, furi_string_get_cstr(file_name))) {
|
|
FURI_LOG_W(TAG, "Could not open UP file %s", furi_string_get_cstr(file_name));
|
|
|
|
//disable button, and set label to "N/A"
|
|
app->up_enabled = 0;
|
|
app->up_label = "N/A";
|
|
}
|
|
|
|
//close the file
|
|
flipper_format_file_close(fff_data_file);
|
|
flipper_format_free(fff_data_file);
|
|
}
|
|
|
|
if(app->down_enabled == 1) {
|
|
furi_string_set(file_name, app->down_file);
|
|
fff_data_file = flipper_format_file_alloc(storage);
|
|
|
|
if(!flipper_format_file_open_existing(fff_data_file, furi_string_get_cstr(file_name))) {
|
|
FURI_LOG_W(TAG, "Could not open DOWN file %s", furi_string_get_cstr(file_name));
|
|
|
|
app->down_enabled = 0;
|
|
app->down_label = "N/A";
|
|
}
|
|
|
|
flipper_format_file_close(fff_data_file);
|
|
flipper_format_free(fff_data_file);
|
|
}
|
|
|
|
if(app->left_enabled == 1) {
|
|
furi_string_set(file_name, app->left_file);
|
|
fff_data_file = flipper_format_file_alloc(storage);
|
|
|
|
if(!flipper_format_file_open_existing(fff_data_file, furi_string_get_cstr(file_name))) {
|
|
FURI_LOG_W(TAG, "Could not open LEFT file %s", furi_string_get_cstr(file_name));
|
|
|
|
app->left_enabled = 0;
|
|
app->left_label = "N/A";
|
|
}
|
|
|
|
flipper_format_file_close(fff_data_file);
|
|
flipper_format_free(fff_data_file);
|
|
}
|
|
|
|
if(app->right_enabled == 1) {
|
|
furi_string_set(file_name, app->right_file);
|
|
fff_data_file = flipper_format_file_alloc(storage);
|
|
|
|
if(!flipper_format_file_open_existing(fff_data_file, furi_string_get_cstr(file_name))) {
|
|
FURI_LOG_W(TAG, "Could not open RIGHT file %s", furi_string_get_cstr(file_name));
|
|
|
|
app->right_enabled = 0;
|
|
app->right_label = "N/A";
|
|
}
|
|
|
|
flipper_format_file_close(fff_data_file);
|
|
flipper_format_free(fff_data_file);
|
|
}
|
|
|
|
if(app->ok_enabled == 1) {
|
|
furi_string_set(file_name, app->ok_file);
|
|
fff_data_file = flipper_format_file_alloc(storage);
|
|
|
|
if(!flipper_format_file_open_existing(fff_data_file, furi_string_get_cstr(file_name))) {
|
|
FURI_LOG_W(TAG, "Could not open OK file %s", furi_string_get_cstr(file_name));
|
|
|
|
app->ok_enabled = 0;
|
|
app->ok_label = "N/A";
|
|
}
|
|
|
|
flipper_format_file_close(fff_data_file);
|
|
flipper_format_free(fff_data_file);
|
|
}
|
|
|
|
furi_record_close(RECORD_STORAGE);
|
|
|
|
if(app->up_enabled == 0 && app->down_enabled == 0 && app->left_enabled == 0 &&
|
|
app->right_enabled == 0 && app->ok_enabled == 0) {
|
|
app->file_result = 1;
|
|
} else {
|
|
app->file_result = 2;
|
|
}
|
|
}
|
|
|
|
static void subghz_remote_end_send(SubGHzRemote* app) {
|
|
app->processing = 0;
|
|
}
|
|
|
|
bool subghz_remote_set_preset(SubRemotePreset* p, const char* preset) {
|
|
if(!strcmp(preset, "FuriHalSubGhzPresetOok270Async")) {
|
|
furi_string_set(p->name, "AM270");
|
|
} else if(!strcmp(preset, "FuriHalSubGhzPresetOok650Async")) {
|
|
furi_string_set(p->name, "AM650");
|
|
} else if(!strcmp(preset, "FuriHalSubGhzPreset2FSKDev238Async")) {
|
|
furi_string_set(p->name, "FM238");
|
|
} else if(!strcmp(preset, "FuriHalSubGhzPreset2FSKDev476Async")) {
|
|
furi_string_set(p->name, "FM476");
|
|
} else if(!strcmp(preset, "FuriHalSubGhzPresetCustom")) {
|
|
FURI_LOG_E(TAG, "Custom preset unsupported now");
|
|
return false;
|
|
// furi_string_set(p->name, "CUSTOM");
|
|
} else {
|
|
FURI_LOG_E(TAG, "Unsupported preset");
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool subghz_remote_key_load(
|
|
SubRemotePreset* preset,
|
|
FlipperFormat* fff_file,
|
|
FlipperFormat* fff_data,
|
|
SubGhzSetting* setting,
|
|
SubGhzReceiver* receiver,
|
|
const char* path) {
|
|
//
|
|
if(!flipper_format_rewind(fff_file)) {
|
|
FURI_LOG_E(TAG, "Rewind error");
|
|
return false;
|
|
}
|
|
|
|
FuriString* temp_str;
|
|
temp_str = furi_string_alloc();
|
|
|
|
bool res = false;
|
|
|
|
do {
|
|
// load frequency from file
|
|
if(!flipper_format_read_uint32(fff_file, "Frequency", &preset->frequency, 1)) {
|
|
FURI_LOG_W(TAG, "Cannot read frequency. Defaulting to 433.92 MHz");
|
|
preset->frequency = 433920000;
|
|
}
|
|
|
|
// load preset from file
|
|
if(!flipper_format_read_string(fff_file, "Preset", temp_str)) {
|
|
FURI_LOG_W(TAG, "Could not read Preset. Defaulting to Ook650Async");
|
|
furi_string_set(temp_str, "FuriHalSubGhzPresetOok650Async");
|
|
}
|
|
if(!subghz_remote_set_preset(preset, furi_string_get_cstr(temp_str))) {
|
|
FURI_LOG_E(TAG, "Could not set preset");
|
|
break;
|
|
}
|
|
if(!strcmp(furi_string_get_cstr(temp_str), "FuriHalSubGhzPresetCustom")) {
|
|
// TODO: check if preset is custom
|
|
FURI_LOG_E(TAG, "Could not use custom preset");
|
|
break;
|
|
}
|
|
size_t preset_index =
|
|
subghz_setting_get_inx_preset_by_name(setting, furi_string_get_cstr(preset->name));
|
|
preset->data = subghz_setting_get_preset_data(setting, preset_index);
|
|
preset->data_size = subghz_setting_get_preset_data_size(setting, preset_index);
|
|
|
|
// load protocol from file
|
|
if(!flipper_format_read_string(fff_file, "Protocol", preset->protocol)) {
|
|
FURI_LOG_E(TAG, "Could not read Protocol.");
|
|
break;
|
|
}
|
|
if(!furi_string_cmp_str(preset->protocol, "RAW")) {
|
|
subghz_protocol_raw_gen_fff_data(fff_data, path);
|
|
} else {
|
|
stream_copy_full(
|
|
flipper_format_get_raw_stream(fff_file), flipper_format_get_raw_stream(fff_data));
|
|
}
|
|
|
|
// repeat
|
|
if(!flipper_format_insert_or_update_uint32(fff_file, "Repeat", &preset->repeat, 1)) {
|
|
FURI_LOG_E(TAG, "Unable to insert or update Repeat");
|
|
break;
|
|
}
|
|
|
|
preset->decoder = subghz_receiver_search_decoder_base_by_name(
|
|
receiver, furi_string_get_cstr(preset->protocol));
|
|
if(preset->decoder) {
|
|
SubGhzProtocolStatus status =
|
|
subghz_protocol_decoder_base_deserialize(preset->decoder, fff_data);
|
|
if(status != SubGhzProtocolStatusOk) {
|
|
FURI_LOG_E(TAG, "Protocol deserialize failed, status = %d", status);
|
|
break;
|
|
}
|
|
} else {
|
|
FURI_LOG_E(TAG, "Protocol %s not found", furi_string_get_cstr(temp_str));
|
|
}
|
|
|
|
res = true;
|
|
} while(0);
|
|
|
|
furi_string_free(temp_str);
|
|
|
|
return res;
|
|
}
|
|
|
|
// method modified from subghz_i.c
|
|
// https://github.com/flipperdevices/flipperzero-firmware/blob/b0daa601ad5b87427a45f9089c8b403a01f72c2a/applications/subghz/subghz_i.c#L417-L456
|
|
bool subghz_remote_save_protocol_to_file(FlipperFormat* fff_file, const char* dev_file_name) {
|
|
furi_assert(fff_file);
|
|
furi_assert(dev_file_name);
|
|
|
|
Storage* storage = furi_record_open(RECORD_STORAGE);
|
|
Stream* flipper_format_stream = flipper_format_get_raw_stream(fff_file);
|
|
|
|
bool saved = false;
|
|
FuriString* file_dir;
|
|
file_dir = furi_string_alloc();
|
|
|
|
path_extract_dirname(dev_file_name, file_dir);
|
|
do {
|
|
flipper_format_delete_key(fff_file, "Repeat");
|
|
//flipper_format_delete_key(fff_file, "Manufacture");
|
|
|
|
if(!storage_simply_mkdir(storage, furi_string_get_cstr(file_dir))) {
|
|
FURI_LOG_E(TAG, "(save) Cannot mkdir");
|
|
break;
|
|
}
|
|
|
|
if(!storage_simply_remove(storage, dev_file_name)) {
|
|
FURI_LOG_E(TAG, "(save) Cannot remove");
|
|
break;
|
|
}
|
|
|
|
stream_seek(flipper_format_stream, 0, StreamOffsetFromStart);
|
|
stream_save_to_file(flipper_format_stream, storage, dev_file_name, FSOM_CREATE_ALWAYS);
|
|
|
|
saved = true;
|
|
FURI_LOG_D(TAG, "(save) OK Save");
|
|
} while(0);
|
|
furi_string_free(file_dir);
|
|
furi_record_close(RECORD_STORAGE);
|
|
return saved;
|
|
}
|
|
|
|
void subghz_remote_tx_stop(SubGHzRemote* app) {
|
|
if(app->processing == 0) {
|
|
return;
|
|
}
|
|
|
|
if(!furi_string_cmp_str(app->txpreset->protocol, "RAW")) {
|
|
while(!furi_hal_subghz_is_async_tx_complete()) {
|
|
furi_delay_ms(15);
|
|
}
|
|
}
|
|
|
|
//Stop TX
|
|
furi_hal_subghz_stop_async_tx();
|
|
//FURI_LOG_I(TAG, "TX Done!");
|
|
subghz_transmitter_stop(app->tx_transmitter);
|
|
|
|
FURI_LOG_D(TAG, "Checking if protocol is dynamic");
|
|
const SubGhzProtocolRegistry* protocol_registry_items =
|
|
subghz_environment_get_protocol_registry(app->environment);
|
|
const SubGhzProtocol* proto = subghz_protocol_registry_get_by_name(
|
|
protocol_registry_items, furi_string_get_cstr(app->txpreset->protocol));
|
|
FURI_LOG_D(TAG, "Protocol-TYPE %d", proto->type);
|
|
if(proto && proto->type == SubGhzProtocolTypeDynamic) {
|
|
FURI_LOG_D(TAG, "Protocol is dynamic. Saving key");
|
|
subghz_remote_save_protocol_to_file(app->tx_fff_data, app->tx_file_path);
|
|
|
|
keeloq_reset_mfname();
|
|
keeloq_reset_kl_type();
|
|
keeloq_reset_original_btn();
|
|
alutech_reset_original_btn();
|
|
nice_flors_reset_original_btn();
|
|
somfy_telis_reset_original_btn();
|
|
secplus2_reset_original_btn();
|
|
star_line_reset_mfname();
|
|
star_line_reset_kl_type();
|
|
}
|
|
|
|
subghz_transmitter_free(app->tx_transmitter);
|
|
furi_hal_subghz_idle();
|
|
|
|
notification_message(app->notification, &sequence_blink_stop);
|
|
|
|
subghz_remote_preset_free(app->txpreset);
|
|
flipper_format_free(app->tx_fff_data);
|
|
subghz_remote_end_send(app);
|
|
}
|
|
|
|
static bool subghz_remote_send_sub(SubGHzRemote* app, FlipperFormat* fff_data) {
|
|
//
|
|
bool res = false;
|
|
do {
|
|
if(!furi_hal_subghz_is_tx_allowed(app->txpreset->frequency)) {
|
|
printf(
|
|
"In your settings, only reception on this frequency (%lu) is allowed,\r\n"
|
|
"the actual operation of the subghz remote app is not possible\r\n ",
|
|
app->txpreset->frequency);
|
|
app->tx_not_allowed = true;
|
|
subghz_remote_end_send(app);
|
|
break;
|
|
} else {
|
|
app->tx_not_allowed = false;
|
|
}
|
|
|
|
app->tx_transmitter = subghz_transmitter_alloc_init(
|
|
app->environment, furi_string_get_cstr(app->txpreset->protocol));
|
|
if(!app->tx_transmitter) {
|
|
break;
|
|
}
|
|
|
|
subghz_transmitter_deserialize(app->tx_transmitter, fff_data);
|
|
|
|
furi_hal_subghz_reset();
|
|
furi_hal_subghz_idle();
|
|
furi_hal_subghz_load_custom_preset(app->txpreset->data);
|
|
furi_hal_gpio_init(furi_hal_subghz.cc1101_g0_pin, GpioModeInput, GpioPullNo, GpioSpeedLow);
|
|
|
|
furi_hal_subghz_idle();
|
|
|
|
furi_hal_subghz_set_frequency_and_path(app->txpreset->frequency);
|
|
furi_hal_gpio_write(furi_hal_subghz.cc1101_g0_pin, false);
|
|
furi_hal_gpio_init(
|
|
furi_hal_subghz.cc1101_g0_pin, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
|
|
|
|
if(!furi_hal_subghz_tx()) {
|
|
FURI_LOG_E(TAG, "Sending not allowed");
|
|
break;
|
|
}
|
|
|
|
//FURI_LOG_I(TAG, "Sending...");
|
|
notification_message(app->notification, &sequence_blink_start_magenta);
|
|
|
|
furi_hal_subghz_start_async_tx(subghz_transmitter_yield, app->tx_transmitter);
|
|
|
|
res = true;
|
|
} while(0);
|
|
|
|
return res;
|
|
}
|
|
|
|
static void subghz_remote_send_signal(SubGHzRemote* app, Storage* storage, const char* path) {
|
|
FURI_LOG_D(TAG, "Sending: %s", path);
|
|
|
|
app->tx_file_path = path;
|
|
|
|
app->tx_fff_data = flipper_format_string_alloc();
|
|
|
|
app->txpreset = subghz_remote_preset_alloc();
|
|
|
|
// load settings/stream from .sub file
|
|
FlipperFormat* fff_file = flipper_format_file_alloc(storage);
|
|
bool open_ok = false;
|
|
do {
|
|
if(!flipper_format_file_open_existing(fff_file, path)) {
|
|
FURI_LOG_E(TAG, "Could not open file %s", path);
|
|
break;
|
|
}
|
|
if(!subghz_remote_key_load(
|
|
app->txpreset,
|
|
fff_file,
|
|
app->tx_fff_data,
|
|
app->setting,
|
|
app->subghz_receiver,
|
|
path)) {
|
|
FURI_LOG_E(TAG, "Could not load key");
|
|
break;
|
|
}
|
|
open_ok = true;
|
|
} while(0);
|
|
flipper_format_free(fff_file);
|
|
if(!open_ok) {
|
|
FURI_LOG_E(TAG, "Could not load file!");
|
|
return;
|
|
}
|
|
|
|
subghz_remote_send_sub(app, app->tx_fff_data);
|
|
}
|
|
|
|
static void subghz_remote_process_signal(SubGHzRemote* app, FuriString* signal) {
|
|
view_port_update(app->view_port);
|
|
|
|
FURI_LOG_D(TAG, "signal = %s", furi_string_get_cstr(signal));
|
|
|
|
if(strlen(furi_string_get_cstr(signal)) > 12) {
|
|
Storage* storage = furi_record_open(RECORD_STORAGE);
|
|
subghz_remote_send_signal(app, storage, furi_string_get_cstr(signal));
|
|
furi_record_close(RECORD_STORAGE);
|
|
} else if(strlen(furi_string_get_cstr(signal)) < 10) {
|
|
subghz_remote_end_send(app);
|
|
}
|
|
}
|
|
|
|
static void render_callback(Canvas* canvas, void* ctx) {
|
|
SubGHzRemote* app = ctx;
|
|
furi_check(furi_mutex_acquire(app->model_mutex, FuriWaitForever) == FuriStatusOk);
|
|
|
|
//setup different canvas settings
|
|
if(app->file_result == 1) {
|
|
//if map has no valid filenames defined
|
|
canvas_clear(canvas);
|
|
canvas_set_font(canvas, FontPrimary);
|
|
canvas_draw_str_aligned(canvas, 62, 5, AlignCenter, AlignTop, "Config is incorrect.");
|
|
canvas_set_font(canvas, FontSecondary);
|
|
canvas_draw_str_aligned(canvas, 62, 30, AlignCenter, AlignTop, "Please configure map.");
|
|
canvas_draw_str_aligned(canvas, 62, 60, AlignCenter, AlignBottom, "Press Back to Exit.");
|
|
} else if(app->file_result == 3) {
|
|
//if map has no valid filenames defined
|
|
canvas_clear(canvas);
|
|
canvas_set_font(canvas, FontPrimary);
|
|
canvas_draw_str_aligned(canvas, 62, 5, AlignCenter, AlignTop, "Checking config.");
|
|
canvas_set_font(canvas, FontSecondary);
|
|
canvas_draw_str_aligned(canvas, 62, 30, AlignCenter, AlignTop, "If app is stuck...");
|
|
canvas_draw_str_aligned(canvas, 62, 60, AlignCenter, AlignBottom, "Press Back to Exit.");
|
|
} else if(app->tx_not_allowed) {
|
|
canvas_clear(canvas);
|
|
canvas_set_font(canvas, FontPrimary);
|
|
canvas_draw_str_aligned(canvas, 62, 5, AlignCenter, AlignTop, "Transmission is blocked.");
|
|
canvas_set_font(canvas, FontSecondary);
|
|
canvas_draw_str_aligned(canvas, 62, 15, AlignCenter, AlignTop, "Frequency is outside of");
|
|
canvas_draw_str_aligned(canvas, 62, 25, AlignCenter, AlignTop, "default range.");
|
|
canvas_draw_str_aligned(canvas, 62, 35, AlignCenter, AlignTop, "Check docs.");
|
|
canvas_draw_str_aligned(canvas, 62, 60, AlignCenter, AlignBottom, "Press Back to Exit.");
|
|
} else {
|
|
//map found, draw all the things
|
|
canvas_clear(canvas);
|
|
|
|
//canvas_set_font(canvas, FontPrimary);
|
|
//canvas_draw_str(canvas, 0, 10, "U: ");
|
|
//canvas_draw_str(canvas, 0, 20, "L: ");
|
|
//canvas_draw_str(canvas, 0, 30, "R: ");
|
|
//canvas_draw_str(canvas, 0, 40, "D: ");
|
|
//canvas_draw_str(canvas, 0, 50, "Ok: ");
|
|
|
|
//PNGs are located in assets/icons/SubGHzRemote before compilation
|
|
|
|
//Icons for Labels
|
|
//canvas_draw_icon(canvas, 0, 0, &I_SubGHzRemote_LeftAlignedButtons_9x64);
|
|
canvas_draw_icon(canvas, 1, 5, &I_ButtonUp_7x4);
|
|
canvas_draw_icon(canvas, 1, 15, &I_ButtonDown_7x4);
|
|
canvas_draw_icon(canvas, 2, 23, &I_ButtonLeft_4x7);
|
|
canvas_draw_icon(canvas, 2, 33, &I_ButtonRight_4x7);
|
|
canvas_draw_icon(canvas, 0, 42, &I_Ok_btn_9x9);
|
|
canvas_draw_icon(canvas, 0, 53, &I_back_10px);
|
|
|
|
//Labels
|
|
canvas_set_font(canvas, FontSecondary);
|
|
canvas_draw_str(canvas, 10, 10, app->up_label);
|
|
canvas_draw_str(canvas, 10, 20, app->down_label);
|
|
canvas_draw_str(canvas, 10, 30, app->left_label);
|
|
canvas_draw_str(canvas, 10, 40, app->right_label);
|
|
canvas_draw_str(canvas, 10, 50, app->ok_label);
|
|
|
|
canvas_draw_str_aligned(canvas, 11, 62, AlignLeft, AlignBottom, "Press=Exit.");
|
|
|
|
//Status text and indicator
|
|
canvas_draw_str_aligned(canvas, 126, 10, AlignRight, AlignBottom, app->send_status);
|
|
|
|
switch(app->send_status_c) {
|
|
case 0:
|
|
canvas_draw_icon(canvas, 113, 15, &I_Pin_cell_13x13);
|
|
break;
|
|
case 1:
|
|
canvas_draw_icon(canvas, 113, 15, &I_Pin_cell_13x13);
|
|
canvas_draw_icon(canvas, 116, 17, &I_Pin_arrow_up_7x9);
|
|
break;
|
|
case 2:
|
|
canvas_draw_icon(canvas, 113, 15, &I_Pin_cell_13x13);
|
|
canvas_draw_icon(canvas, 116, 17, &I_Pin_arrow_down_7x9);
|
|
break;
|
|
case 3:
|
|
canvas_draw_icon(canvas, 113, 15, &I_Pin_cell_13x13);
|
|
canvas_draw_icon(canvas, 115, 18, &I_Pin_arrow_right_9x7);
|
|
break;
|
|
case 4:
|
|
canvas_draw_icon(canvas, 113, 15, &I_Pin_cell_13x13);
|
|
canvas_draw_icon(canvas, 115, 18, &I_Pin_arrow_left_9x7);
|
|
break;
|
|
case 5:
|
|
canvas_draw_icon(canvas, 113, 15, &I_Pin_cell_13x13);
|
|
canvas_draw_icon(canvas, 116, 18, &I_Pin_star_7x7);
|
|
break;
|
|
}
|
|
|
|
//Repeat indicator
|
|
//canvas_draw_str_aligned(canvas, 125, 40, AlignRight, AlignBottom, "Repeat:");
|
|
//canvas_draw_icon(canvas, 115, 39, &I_SubGHzRemote_Repeat_12x14);
|
|
//canvas_draw_str_aligned(canvas, 125, 62, AlignRight, AlignBottom, int_to_char(app->repeat));
|
|
}
|
|
|
|
furi_mutex_release(app->model_mutex);
|
|
}
|
|
|
|
static void input_callback(InputEvent* input_event, void* ctx) {
|
|
SubGHzRemote* app = ctx;
|
|
furi_message_queue_put(app->input_queue, input_event, 0);
|
|
}
|
|
|
|
void subghz_remote_subghz_alloc(SubGHzRemote* app) {
|
|
// load subghz presets
|
|
app->setting = subghz_setting_alloc();
|
|
subghz_setting_load(app->setting, EXT_PATH("subghz/assets/setting_user"));
|
|
|
|
// load mfcodes
|
|
app->environment = subghz_environment_alloc();
|
|
subghz_environment_load_keystore(app->environment, EXT_PATH("subghz/assets/keeloq_mfcodes"));
|
|
subghz_environment_load_keystore(
|
|
app->environment, EXT_PATH("subghz/assets/keeloq_mfcodes_user"));
|
|
subghz_environment_set_came_atomo_rainbow_table_file_name(
|
|
app->environment, EXT_PATH("subghz/assets/came_atomo"));
|
|
subghz_environment_set_nice_flor_s_rainbow_table_file_name(
|
|
app->environment, EXT_PATH("subghz/assets/nice_flor_s"));
|
|
subghz_environment_set_protocol_registry(app->environment, (void*)&subghz_protocol_registry);
|
|
|
|
app->subghz_receiver = subghz_receiver_alloc_init(app->environment);
|
|
}
|
|
|
|
SubGHzRemote* subghz_remote_alloc(void) {
|
|
SubGHzRemote* app = malloc(sizeof(SubGHzRemote));
|
|
|
|
// Enable power for External CC1101 if it is connected
|
|
furi_hal_subghz_enable_ext_power();
|
|
// Auto switch to internal radio if external radio is not available
|
|
furi_delay_ms(15);
|
|
if(!furi_hal_subghz_check_radio()) {
|
|
furi_hal_subghz_set_radio_type(SubGhzRadioInternal);
|
|
}
|
|
|
|
furi_hal_power_suppress_charge_enter();
|
|
|
|
app->model_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
|
|
|
|
app->input_queue = furi_message_queue_alloc(32, sizeof(InputEvent));
|
|
|
|
app->view_port = view_port_alloc();
|
|
view_port_draw_callback_set(app->view_port, render_callback, app);
|
|
view_port_input_callback_set(app->view_port, input_callback, app);
|
|
|
|
// Open GUI and register view_port
|
|
app->gui = furi_record_open(RECORD_GUI);
|
|
gui_add_view_port(app->gui, app->view_port, GuiLayerFullscreen);
|
|
|
|
app->notification = furi_record_open(RECORD_NOTIFICATION);
|
|
|
|
return app;
|
|
}
|
|
|
|
void subghz_remote_free(SubGHzRemote* app, bool with_subghz) {
|
|
furi_hal_power_suppress_charge_exit();
|
|
|
|
// Disable power for External CC1101 if it was enabled and module is connected
|
|
furi_hal_subghz_disable_ext_power();
|
|
|
|
furi_string_free(app->up_file);
|
|
furi_string_free(app->down_file);
|
|
furi_string_free(app->left_file);
|
|
furi_string_free(app->right_file);
|
|
furi_string_free(app->ok_file);
|
|
|
|
furi_string_free(app->file_path);
|
|
furi_string_free(app->signal);
|
|
|
|
gui_remove_view_port(app->gui, app->view_port);
|
|
furi_record_close(RECORD_GUI);
|
|
view_port_free(app->view_port);
|
|
app->gui = NULL;
|
|
|
|
furi_message_queue_free(app->input_queue);
|
|
|
|
furi_mutex_free(app->model_mutex);
|
|
|
|
if(with_subghz) {
|
|
furi_hal_subghz_sleep();
|
|
subghz_setting_free(app->setting);
|
|
subghz_receiver_free(app->subghz_receiver);
|
|
subghz_environment_free(app->environment);
|
|
}
|
|
|
|
furi_record_close(RECORD_NOTIFICATION);
|
|
app->notification = NULL;
|
|
|
|
free(app);
|
|
}
|
|
|
|
int32_t subghz_remote_app(void* p) {
|
|
UNUSED(p);
|
|
SubGHzRemote* app = subghz_remote_alloc();
|
|
|
|
app->file_path = furi_string_alloc();
|
|
app->signal = furi_string_alloc();
|
|
|
|
//setup variables before population
|
|
app->up_file = furi_string_alloc();
|
|
app->down_file = furi_string_alloc();
|
|
app->left_file = furi_string_alloc();
|
|
app->right_file = furi_string_alloc();
|
|
app->ok_file = furi_string_alloc();
|
|
|
|
app->file_result = 3;
|
|
|
|
Storage* storage = furi_record_open(RECORD_STORAGE);
|
|
storage_common_migrate(storage, EXT_PATH("unirf"), SUBREMOTEMAP_FOLDER);
|
|
|
|
if(!storage_simply_mkdir(storage, SUBREMOTEMAP_FOLDER)) {
|
|
FURI_LOG_E(TAG, "Could not create folder %s", SUBREMOTEMAP_FOLDER);
|
|
}
|
|
furi_record_close(RECORD_STORAGE);
|
|
|
|
furi_string_set(app->file_path, SUBREMOTEMAP_FOLDER);
|
|
|
|
DialogsApp* dialogs = furi_record_open(RECORD_DIALOGS);
|
|
|
|
DialogsFileBrowserOptions browser_options;
|
|
dialog_file_browser_set_basic_options(&browser_options, SUBREMOTEMAP_EXTENSION, &I_sub1_10px);
|
|
browser_options.base_path = SUBREMOTEMAP_FOLDER;
|
|
|
|
bool res = dialog_file_browser_show(dialogs, app->file_path, app->file_path, &browser_options);
|
|
|
|
furi_record_close(RECORD_DIALOGS);
|
|
if(!res) {
|
|
FURI_LOG_E(TAG, "No file selected");
|
|
subghz_remote_free(app, false);
|
|
return 255;
|
|
} else {
|
|
//check map and population variables
|
|
subghz_remote_cfg_set_check(app, app->file_path);
|
|
}
|
|
|
|
// init subghz stuff
|
|
subghz_remote_subghz_alloc(app);
|
|
|
|
bool exit_loop = false;
|
|
|
|
if(app->file_result == 2) {
|
|
FURI_LOG_D(
|
|
TAG,
|
|
"U: %s - D: %s - L: %s - R: %s - O: %s ",
|
|
furi_string_get_cstr(app->up_file),
|
|
furi_string_get_cstr(app->down_file),
|
|
furi_string_get_cstr(app->left_file),
|
|
furi_string_get_cstr(app->right_file),
|
|
furi_string_get_cstr(app->ok_file));
|
|
|
|
//variables to control multiple button presses and status updates
|
|
app->send_status = "Idle";
|
|
app->send_status_c = 0;
|
|
app->processing = 0;
|
|
//app->repeat = 1;
|
|
app->button = 0;
|
|
|
|
//refresh screen to update variables before processing main screen or error screens
|
|
furi_mutex_release(app->model_mutex);
|
|
view_port_update(app->view_port);
|
|
|
|
//input detect loop start
|
|
InputEvent input;
|
|
while(1) {
|
|
furi_check(
|
|
furi_message_queue_get(app->input_queue, &input, FuriWaitForever) == FuriStatusOk);
|
|
FURI_LOG_D(
|
|
TAG,
|
|
"key: %s type: %s",
|
|
input_get_key_name(input.key),
|
|
input_get_type_name(input.type));
|
|
|
|
switch(input.key) {
|
|
case InputKeyUp:
|
|
if(input.type == InputTypePress) {
|
|
if(app->up_enabled) {
|
|
if(app->processing == 0) {
|
|
furi_string_reset(app->signal);
|
|
furi_string_set(app->signal, app->up_file);
|
|
app->button = 1;
|
|
app->processing = 1;
|
|
}
|
|
}
|
|
}
|
|
if(input.type == InputTypeRelease) {
|
|
if(app->up_enabled) {
|
|
subghz_remote_tx_stop(app);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case InputKeyDown:
|
|
if(input.type == InputTypePress) {
|
|
if(app->down_enabled) {
|
|
if(app->processing == 0) {
|
|
furi_string_reset(app->signal);
|
|
furi_string_set(app->signal, app->down_file);
|
|
app->button = 2;
|
|
app->processing = 1;
|
|
}
|
|
}
|
|
}
|
|
if(input.type == InputTypeRelease) {
|
|
if(app->down_enabled) {
|
|
subghz_remote_tx_stop(app);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case InputKeyRight:
|
|
if(input.type == InputTypePress) {
|
|
if(app->right_enabled) {
|
|
if(app->processing == 0) {
|
|
furi_string_reset(app->signal);
|
|
furi_string_set(app->signal, app->right_file);
|
|
app->button = 3;
|
|
app->processing = 1;
|
|
}
|
|
}
|
|
}
|
|
if(input.type == InputTypeRelease) {
|
|
if(app->right_enabled) {
|
|
subghz_remote_tx_stop(app);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case InputKeyLeft:
|
|
if(input.type == InputTypePress) {
|
|
if(app->left_enabled) {
|
|
if(app->processing == 0) {
|
|
furi_string_reset(app->signal);
|
|
furi_string_set(app->signal, app->left_file);
|
|
app->button = 4;
|
|
app->processing = 1;
|
|
}
|
|
}
|
|
}
|
|
if(input.type == InputTypeRelease) {
|
|
if(app->left_enabled) {
|
|
subghz_remote_tx_stop(app);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case InputKeyOk:
|
|
if(input.type == InputTypePress) {
|
|
if(app->ok_enabled) {
|
|
if(app->processing == 0) {
|
|
furi_string_reset(app->signal);
|
|
furi_string_set(app->signal, app->ok_file);
|
|
app->button = 5;
|
|
app->processing = 1;
|
|
}
|
|
}
|
|
}
|
|
if(input.type == InputTypeRelease) {
|
|
if(app->ok_enabled) {
|
|
subghz_remote_tx_stop(app);
|
|
}
|
|
}
|
|
break;
|
|
|
|
case InputKeyBack:
|
|
subghz_remote_tx_stop(app);
|
|
exit_loop = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if(app->processing == 0) {
|
|
FURI_LOG_D(TAG, "processing 0");
|
|
app->send_status = "Idle";
|
|
app->send_status_c = 0;
|
|
app->button = 0;
|
|
} else if(app->processing == 1) {
|
|
FURI_LOG_D(TAG, "processing 1");
|
|
|
|
app->send_status = "Send";
|
|
|
|
switch(app->button) {
|
|
case 1:
|
|
app->send_status_c = 1;
|
|
break;
|
|
case 2:
|
|
app->send_status_c = 2;
|
|
break;
|
|
case 3:
|
|
app->send_status_c = 3;
|
|
break;
|
|
case 4:
|
|
app->send_status_c = 4;
|
|
break;
|
|
case 5:
|
|
app->send_status_c = 5;
|
|
break;
|
|
}
|
|
|
|
app->processing = 2;
|
|
|
|
subghz_remote_process_signal(app, app->signal);
|
|
}
|
|
|
|
if(exit_loop == true) {
|
|
furi_mutex_release(app->model_mutex);
|
|
break;
|
|
}
|
|
|
|
furi_mutex_release(app->model_mutex);
|
|
view_port_update(app->view_port);
|
|
}
|
|
} else if(app->file_result == 1 || app->file_result == 3) {
|
|
//refresh screen to update variables before processing main screen or error screens
|
|
view_port_update(app->view_port);
|
|
|
|
InputEvent input;
|
|
while(1) {
|
|
furi_check(
|
|
furi_message_queue_get(app->input_queue, &input, FuriWaitForever) == FuriStatusOk);
|
|
FURI_LOG_D(
|
|
TAG,
|
|
"key: %s type: %s",
|
|
input_get_key_name(input.key),
|
|
input_get_type_name(input.type));
|
|
|
|
switch(input.key) {
|
|
case InputKeyRight:
|
|
break;
|
|
case InputKeyLeft:
|
|
break;
|
|
case InputKeyUp:
|
|
break;
|
|
case InputKeyDown:
|
|
break;
|
|
case InputKeyOk:
|
|
break;
|
|
case InputKeyBack:
|
|
exit_loop = true;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
|
|
if(exit_loop == true) {
|
|
furi_mutex_release(app->model_mutex);
|
|
break;
|
|
}
|
|
|
|
furi_mutex_release(app->model_mutex);
|
|
view_port_update(app->view_port);
|
|
}
|
|
} else {
|
|
furi_mutex_release(app->model_mutex);
|
|
}
|
|
|
|
// remove & free all stuff created by app
|
|
subghz_remote_free(app, true);
|
|
|
|
return 0;
|
|
}
|