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

[FL-2230] SubGhz: protocol API refactoring (#969)

Browse Source 
* SubGhz: protocols library refactoring
* SubGhz: new architecture and refactoring
* SubGhz: simplify protocol structure, remove unused types
* SubGhz: rename Subghz to SubGhz
* SubGhz: add environment concept

Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
Co-authored-by: DrZlo13 <who.just.the.doctor@gmail.com>
This commit is contained in:
Skorpionm
2022-03-03 13:48:56 +04:00
committed by GitHub
parent 052237f8c9
commit 3164184bbc
173 changed files with 9836 additions and 8486 deletions
Download Patch File Download Diff File Expand all files Collapse all files

105
applications/subghz/views/subghz_receiver.c → applications/subghz/views/receiver.c
View File

@@ -1,4 +1,4 @@
#include "subghz_receiver.h"
#include "receiver.h"
#include "../subghz_i.h"
#include <math.h>
@@ -29,14 +29,14 @@ struct SubGhzReceiverHistory {
typedef struct SubGhzReceiverHistory SubGhzReceiverHistory;
static const Icon* ReceiverItemIcons[] = {
[SubGhzProtocolCommonTypeUnknown] = &I_Quest_7x8,
[SubGhzProtocolCommonTypeStatic] = &I_Unlock_7x8,
[SubGhzProtocolCommonTypeDynamic] = &I_Lock_7x8,
[SubGhzProtocolTypeUnknown] = &I_Quest_7x8,
[SubGhzProtocolTypeStatic] = &I_Unlock_7x8,
[SubGhzProtocolTypeDynamic] = &I_Lock_7x8,
};
struct SubghzReceiver {
struct SubGhzViewReceiver {
View* view;
SubghzReceiverCallback callback;
SubGhzViewReceiverCallback callback;
void* context;
};
@@ -48,11 +48,11 @@ typedef struct {
uint16_t idx;
uint16_t list_offset;
uint16_t history_item;
} SubghzReceiverModel;
} SubGhzViewReceiverModel;
void subghz_receiver_set_callback(
SubghzReceiver* subghz_receiver,
SubghzReceiverCallback callback,
void subghz_view_receiver_set_callback(
SubGhzViewReceiver* subghz_receiver,
SubGhzViewReceiverCallback callback,
void* context) {
furi_assert(subghz_receiver);
furi_assert(callback);
@@ -60,11 +60,11 @@ void subghz_receiver_set_callback(
subghz_receiver->context = context;
}
static void subghz_receiver_update_offset(SubghzReceiver* subghz_receiver) {
static void subghz_view_receiver_update_offset(SubGhzViewReceiver* subghz_receiver) {
furi_assert(subghz_receiver);
with_view_model(
subghz_receiver->view, (SubghzReceiverModel * model) {
subghz_receiver->view, (SubGhzViewReceiverModel * model) {
size_t history_item = model->history_item;
uint16_t bounds = history_item > 3 ? 2 : history_item;
@@ -79,13 +79,13 @@ static void subghz_receiver_update_offset(SubghzReceiver* subghz_receiver) {
});
}
void subghz_receiver_add_item_to_menu(
SubghzReceiver* subghz_receiver,
void subghz_view_receiver_add_item_to_menu(
SubGhzViewReceiver* subghz_receiver,
const char* name,
uint8_t type) {
furi_assert(subghz_receiver);
with_view_model(
subghz_receiver->view, (SubghzReceiverModel * model) {
subghz_receiver->view, (SubGhzViewReceiverModel * model) {
SubGhzReceiverMenuItem* item_menu =
SubGhzReceiverMenuItemArray_push_raw(model->history->data);
string_init_set_str(item_menu->item_str, name);
@@ -99,17 +99,17 @@ void subghz_receiver_add_item_to_menu(
return true;
});
subghz_receiver_update_offset(subghz_receiver);
subghz_view_receiver_update_offset(subghz_receiver);
}
void subghz_receiver_add_data_statusbar(
SubghzReceiver* subghz_receiver,
void subghz_view_receiver_add_data_statusbar(
SubGhzViewReceiver* subghz_receiver,
const char* frequency_str,
const char* preset_str,
const char* history_stat_str) {
furi_assert(subghz_receiver);
with_view_model(
subghz_receiver->view, (SubghzReceiverModel * model) {
subghz_receiver->view, (SubGhzViewReceiverModel * model) {
string_set(model->frequency_str, frequency_str);
string_set(model->preset_str, preset_str);
string_set(model->history_stat_str, history_stat_str);
@@ -117,7 +117,7 @@ void subghz_receiver_add_data_statusbar(
});
}
static void subghz_receiver_draw_frame(Canvas* canvas, uint16_t idx, bool scrollbar) {
static void subghz_view_receiver_draw_frame(Canvas* canvas, uint16_t idx, bool scrollbar) {
canvas_set_color(canvas, ColorBlack);
canvas_draw_box(canvas, 0, 0 + idx * FRAME_HEIGHT, scrollbar ? 122 : 127, FRAME_HEIGHT);
@@ -131,7 +131,7 @@ static void subghz_receiver_draw_frame(Canvas* canvas, uint16_t idx, bool scroll
canvas_draw_dot(canvas, scrollbar ? 121 : 126, (0 + idx * FRAME_HEIGHT) + 11);
}
void subghz_receiver_draw(Canvas* canvas, SubghzReceiverModel* model) {
void subghz_view_receiver_draw(Canvas* canvas, SubGhzViewReceiverModel* model) {
canvas_clear(canvas);
canvas_set_color(canvas, ColorBlack);
canvas_set_font(canvas, FontSecondary);
@@ -162,7 +162,7 @@ void subghz_receiver_draw(Canvas* canvas, SubghzReceiverModel* model) {
string_set(str_buff, item_menu->item_str);
elements_string_fit_width(canvas, str_buff, scrollbar ? MAX_LEN_PX - 6 : MAX_LEN_PX);
if(model->idx == idx) {
subghz_receiver_draw_frame(canvas, i, scrollbar);
subghz_view_receiver_draw_frame(canvas, i, scrollbar);
} else {
canvas_set_color(canvas, ColorBlack);
}
@@ -176,17 +176,17 @@ void subghz_receiver_draw(Canvas* canvas, SubghzReceiverModel* model) {
string_clear(str_buff);
}
bool subghz_receiver_input(InputEvent* event, void* context) {
bool subghz_view_receiver_input(InputEvent* event, void* context) {
furi_assert(context);
SubghzReceiver* subghz_receiver = context;
SubGhzViewReceiver* subghz_receiver = context;
if(event->key == InputKeyBack && event->type == InputTypeShort) {
subghz_receiver->callback(SubghzCustomEventViewReceverBack, subghz_receiver->context);
subghz_receiver->callback(SubGhzCustomEventViewReceverBack, subghz_receiver->context);
} else if(
event->key == InputKeyUp &&
(event->type == InputTypeShort || event->type == InputTypeRepeat)) {
with_view_model(
subghz_receiver->view, (SubghzReceiverModel * model) {
subghz_receiver->view, (SubGhzViewReceiverModel * model) {
if(model->idx != 0) model->idx--;
return true;
});
@@ -194,38 +194,38 @@ bool subghz_receiver_input(InputEvent* event, void* context) {
event->key == InputKeyDown &&
(event->type == InputTypeShort || event->type == InputTypeRepeat)) {
with_view_model(
subghz_receiver->view, (SubghzReceiverModel * model) {
subghz_receiver->view, (SubGhzViewReceiverModel * model) {
if(model->idx != model->history_item - 1) model->idx++;
return true;
});
} else if(event->key == InputKeyLeft && event->type == InputTypeShort) {
subghz_receiver->callback(SubghzCustomEventViewReceverConfig, subghz_receiver->context);
subghz_receiver->callback(SubGhzCustomEventViewReceverConfig, subghz_receiver->context);
} else if(event->key == InputKeyOk && event->type == InputTypeShort) {
with_view_model(
subghz_receiver->view, (SubghzReceiverModel * model) {
subghz_receiver->view, (SubGhzViewReceiverModel * model) {
if(model->history_item != 0) {
subghz_receiver->callback(
SubghzCustomEventViewReceverOK, subghz_receiver->context);
SubGhzCustomEventViewReceverOK, subghz_receiver->context);
}
return false;
});
}
subghz_receiver_update_offset(subghz_receiver);
subghz_view_receiver_update_offset(subghz_receiver);
return true;
}
void subghz_receiver_enter(void* context) {
void subghz_view_receiver_enter(void* context) {
furi_assert(context);
//SubghzReceiver* subghz_receiver = context;
//SubGhzViewReceiver* subghz_receiver = context;
}
void subghz_receiver_exit(void* context) {
void subghz_view_receiver_exit(void* context) {
furi_assert(context);
SubghzReceiver* subghz_receiver = context;
SubGhzViewReceiver* subghz_receiver = context;
with_view_model(
subghz_receiver->view, (SubghzReceiverModel * model) {
subghz_receiver->view, (SubGhzViewReceiverModel * model) {
string_reset(model->frequency_str);
string_reset(model->preset_str);
string_reset(model->history_stat_str);
@@ -242,20 +242,21 @@ void subghz_receiver_exit(void* context) {
});
}
SubghzReceiver* subghz_receiver_alloc() {
SubghzReceiver* subghz_receiver = malloc(sizeof(SubghzReceiver));
SubGhzViewReceiver* subghz_view_receiver_alloc() {
SubGhzViewReceiver* subghz_receiver = malloc(sizeof(SubGhzViewReceiver));
// View allocation and configuration
subghz_receiver->view = view_alloc();
view_allocate_model(subghz_receiver->view, ViewModelTypeLocking, sizeof(SubghzReceiverModel));
view_allocate_model(
subghz_receiver->view, ViewModelTypeLocking, sizeof(SubGhzViewReceiverModel));
view_set_context(subghz_receiver->view, subghz_receiver);
view_set_draw_callback(subghz_receiver->view, (ViewDrawCallback)subghz_receiver_draw);
view_set_input_callback(subghz_receiver->view, subghz_receiver_input);
view_set_enter_callback(subghz_receiver->view, subghz_receiver_enter);
view_set_exit_callback(subghz_receiver->view, subghz_receiver_exit);
view_set_draw_callback(subghz_receiver->view, (ViewDrawCallback)subghz_view_receiver_draw);
view_set_input_callback(subghz_receiver->view, subghz_view_receiver_input);
view_set_enter_callback(subghz_receiver->view, subghz_view_receiver_enter);
view_set_exit_callback(subghz_receiver->view, subghz_view_receiver_exit);
with_view_model(
subghz_receiver->view, (SubghzReceiverModel * model) {
subghz_receiver->view, (SubGhzViewReceiverModel * model) {
string_init(model->frequency_str);
string_init(model->preset_str);
string_init(model->history_stat_str);
@@ -267,11 +268,11 @@ SubghzReceiver* subghz_receiver_alloc() {
return subghz_receiver;
}
void subghz_receiver_free(SubghzReceiver* subghz_receiver) {
void subghz_view_receiver_free(SubGhzViewReceiver* subghz_receiver) {
furi_assert(subghz_receiver);
with_view_model(
subghz_receiver->view, (SubghzReceiverModel * model) {
subghz_receiver->view, (SubGhzViewReceiverModel * model) {
string_clear(model->frequency_str);
string_clear(model->preset_str);
string_clear(model->history_stat_str);
@@ -288,29 +289,29 @@ void subghz_receiver_free(SubghzReceiver* subghz_receiver) {
free(subghz_receiver);
}
View* subghz_receiver_get_view(SubghzReceiver* subghz_receiver) {
View* subghz_view_receiver_get_view(SubGhzViewReceiver* subghz_receiver) {
furi_assert(subghz_receiver);
return subghz_receiver->view;
}
uint16_t subghz_receiver_get_idx_menu(SubghzReceiver* subghz_receiver) {
uint16_t subghz_view_receiver_get_idx_menu(SubGhzViewReceiver* subghz_receiver) {
furi_assert(subghz_receiver);
uint32_t idx = 0;
with_view_model(
subghz_receiver->view, (SubghzReceiverModel * model) {
subghz_receiver->view, (SubGhzViewReceiverModel * model) {
idx = model->idx;
return false;
});
return idx;
}
void subghz_receiver_set_idx_menu(SubghzReceiver* subghz_receiver, uint16_t idx) {
void subghz_view_receiver_set_idx_menu(SubGhzViewReceiver* subghz_receiver, uint16_t idx) {
furi_assert(subghz_receiver);
with_view_model(
subghz_receiver->view, (SubghzReceiverModel * model) {
subghz_receiver->view, (SubGhzViewReceiverModel * model) {
model->idx = idx;
if(model->idx > 2) model->list_offset = idx - 2;
return true;
});
subghz_receiver_update_offset(subghz_receiver);
subghz_view_receiver_update_offset(subghz_receiver);
}

36
applications/subghz/views/receiver.h Normal file
View File

@@ -0,0 +1,36 @@
#pragma once
#include <gui/view.h>
#include "../helpers/subghz_custom_event.h"
typedef struct SubGhzViewReceiver SubGhzViewReceiver;
typedef void (*SubGhzViewReceiverCallback)(SubGhzCustomEvent event, void* context);
void subghz_view_receiver_set_callback(
SubGhzViewReceiver* subghz_receiver,
SubGhzViewReceiverCallback callback,
void* context);
SubGhzViewReceiver* subghz_view_receiver_alloc();
void subghz_view_receiver_free(SubGhzViewReceiver* subghz_receiver);
View* subghz_view_receiver_get_view(SubGhzViewReceiver* subghz_receiver);
void subghz_view_receiver_add_data_statusbar(
SubGhzViewReceiver* subghz_receiver,
const char* frequency_str,
const char* preset_str,
const char* history_stat_str);
void subghz_view_receiver_add_item_to_menu(
SubGhzViewReceiver* subghz_receiver,
const char* name,
uint8_t type);
uint16_t subghz_view_receiver_get_idx_menu(SubGhzViewReceiver* subghz_receiver);
void subghz_view_receiver_set_idx_menu(SubGhzViewReceiver* subghz_receiver, uint16_t idx);
void subghz_view_receiver_exit(void* context);

42
applications/subghz/views/subghz_frequency_analyzer.c
View File

@@ -6,30 +6,29 @@
#include <furi_hal.h>
#include <input/input.h>
#include <notification/notification_messages.h>
#include <lib/subghz/protocols/subghz_protocol_princeton.h>
#include "../helpers/subghz_frequency_analyzer_worker.h"
#include <assets_icons.h>
typedef enum {
SubghzFrequencyAnalyzerStatusIDLE,
} SubghzFrequencyAnalyzerStatus;
SubGhzFrequencyAnalyzerStatusIDLE,
} SubGhzFrequencyAnalyzerStatus;
struct SubghzFrequencyAnalyzer {
struct SubGhzFrequencyAnalyzer {
View* view;
SubGhzFrequencyAnalyzerWorker* worker;
SubghzFrequencyAnalyzerCallback callback;
SubGhzFrequencyAnalyzerCallback callback;
void* context;
};
typedef struct {
uint32_t frequency;
float rssi;
} SubghzFrequencyAnalyzerModel;
} SubGhzFrequencyAnalyzerModel;
void subghz_frequency_analyzer_set_callback(
SubghzFrequencyAnalyzer* subghz_frequency_analyzer,
SubghzFrequencyAnalyzerCallback callback,
SubGhzFrequencyAnalyzer* subghz_frequency_analyzer,
SubGhzFrequencyAnalyzerCallback callback,
void* context) {
furi_assert(subghz_frequency_analyzer);
furi_assert(callback);
@@ -53,7 +52,7 @@ void subghz_frequency_analyzer_draw_rssi(Canvas* canvas, float rssi) {
}
}
void subghz_frequency_analyzer_draw(Canvas* canvas, SubghzFrequencyAnalyzerModel* model) {
void subghz_frequency_analyzer_draw(Canvas* canvas, SubGhzFrequencyAnalyzerModel* model) {
char buffer[64];
canvas_set_color(canvas, ColorBlack);
@@ -77,7 +76,6 @@ void subghz_frequency_analyzer_draw(Canvas* canvas, SubghzFrequencyAnalyzerModel
bool subghz_frequency_analyzer_input(InputEvent* event, void* context) {
furi_assert(context);
//SubghzFrequencyAnalyzer* instance = context;
if(event->key == InputKeyBack) {
return false;
@@ -87,9 +85,9 @@ bool subghz_frequency_analyzer_input(InputEvent* event, void* context) {
}
void subghz_frequency_analyzer_pair_callback(void* context, uint32_t frequency, float rssi) {
SubghzFrequencyAnalyzer* instance = context;
SubGhzFrequencyAnalyzer* instance = context;
with_view_model(
instance->view, (SubghzFrequencyAnalyzerModel * model) {
instance->view, (SubGhzFrequencyAnalyzerModel * model) {
model->rssi = rssi;
model->frequency = frequency;
return true;
@@ -98,7 +96,7 @@ void subghz_frequency_analyzer_pair_callback(void* context, uint32_t frequency,
void subghz_frequency_analyzer_enter(void* context) {
furi_assert(context);
SubghzFrequencyAnalyzer* instance = context;
SubGhzFrequencyAnalyzer* instance = context;
//Start worker
instance->worker = subghz_frequency_analyzer_worker_alloc();
@@ -111,7 +109,7 @@ void subghz_frequency_analyzer_enter(void* context) {
subghz_frequency_analyzer_worker_start(instance->worker);
with_view_model(
instance->view, (SubghzFrequencyAnalyzerModel * model) {
instance->view, (SubGhzFrequencyAnalyzerModel * model) {
model->rssi = 0;
model->frequency = 0;
return true;
@@ -120,7 +118,7 @@ void subghz_frequency_analyzer_enter(void* context) {
void subghz_frequency_analyzer_exit(void* context) {
furi_assert(context);
SubghzFrequencyAnalyzer* instance = context;
SubGhzFrequencyAnalyzer* instance = context;
//Stop worker
if(subghz_frequency_analyzer_worker_is_running(instance->worker)) {
@@ -129,19 +127,19 @@ void subghz_frequency_analyzer_exit(void* context) {
subghz_frequency_analyzer_worker_free(instance->worker);
with_view_model(
instance->view, (SubghzFrequencyAnalyzerModel * model) {
instance->view, (SubGhzFrequencyAnalyzerModel * model) {
model->rssi = 0;
return true;
});
}
SubghzFrequencyAnalyzer* subghz_frequency_analyzer_alloc() {
SubghzFrequencyAnalyzer* instance = malloc(sizeof(SubghzFrequencyAnalyzer));
SubGhzFrequencyAnalyzer* subghz_frequency_analyzer_alloc() {
SubGhzFrequencyAnalyzer* instance = malloc(sizeof(SubGhzFrequencyAnalyzer));
// View allocation and configuration
instance->view = view_alloc();
view_allocate_model(
instance->view, ViewModelTypeLocking, sizeof(SubghzFrequencyAnalyzerModel));
instance->view, ViewModelTypeLocking, sizeof(SubGhzFrequencyAnalyzerModel));
view_set_context(instance->view, instance);
view_set_draw_callback(instance->view, (ViewDrawCallback)subghz_frequency_analyzer_draw);
view_set_input_callback(instance->view, subghz_frequency_analyzer_input);
@@ -149,7 +147,7 @@ SubghzFrequencyAnalyzer* subghz_frequency_analyzer_alloc() {
view_set_exit_callback(instance->view, subghz_frequency_analyzer_exit);
with_view_model(
instance->view, (SubghzFrequencyAnalyzerModel * model) {
instance->view, (SubGhzFrequencyAnalyzerModel * model) {
model->rssi = 0;
return true;
});
@@ -157,14 +155,14 @@ SubghzFrequencyAnalyzer* subghz_frequency_analyzer_alloc() {
return instance;
}
void subghz_frequency_analyzer_free(SubghzFrequencyAnalyzer* instance) {
void subghz_frequency_analyzer_free(SubGhzFrequencyAnalyzer* instance) {
furi_assert(instance);
view_free(instance->view);
free(instance);
}
View* subghz_frequency_analyzer_get_view(SubghzFrequencyAnalyzer* instance) {
View* subghz_frequency_analyzer_get_view(SubGhzFrequencyAnalyzer* instance) {
furi_assert(instance);
return instance->view;
}

14
applications/subghz/views/subghz_frequency_analyzer.h
View File

@@ -3,17 +3,17 @@
#include <gui/view.h>
#include "../helpers/subghz_custom_event.h"
typedef struct SubghzFrequencyAnalyzer SubghzFrequencyAnalyzer;
typedef struct SubGhzFrequencyAnalyzer SubGhzFrequencyAnalyzer;
typedef void (*SubghzFrequencyAnalyzerCallback)(SubghzCustomEvent event, void* context);
typedef void (*SubGhzFrequencyAnalyzerCallback)(SubGhzCustomEvent event, void* context);
void subghz_frequency_analyzer_set_callback(
SubghzFrequencyAnalyzer* subghz_frequency_analyzer,
SubghzFrequencyAnalyzerCallback callback,
SubGhzFrequencyAnalyzer* subghz_frequency_analyzer,
SubGhzFrequencyAnalyzerCallback callback,
void* context);
SubghzFrequencyAnalyzer* subghz_frequency_analyzer_alloc();
SubGhzFrequencyAnalyzer* subghz_frequency_analyzer_alloc();
void subghz_frequency_analyzer_free(SubghzFrequencyAnalyzer* subghz_static);
void subghz_frequency_analyzer_free(SubGhzFrequencyAnalyzer* subghz_static);
View* subghz_frequency_analyzer_get_view(SubghzFrequencyAnalyzer* subghz_static);
View* subghz_frequency_analyzer_get_view(SubGhzFrequencyAnalyzer* subghz_static);

234
applications/subghz/views/subghz_read_raw.c
View File

@@ -6,15 +6,14 @@
#include <furi_hal.h>
#include <input/input.h>
#include <gui/elements.h>
#include <lib/subghz/protocols/subghz_protocol_princeton.h>
#include <assets_icons.h>
#define SUBGHZ_READ_RAW_RSSI_HISTORY_SIZE 100
#define TAG "SubghzReadRAW"
#define TAG "SubGhzReadRAW"
struct SubghzReadRAW {
struct SubGhzReadRAW {
View* view;
SubghzReadRAWCallback callback;
SubGhzReadRAWCallback callback;
void* context;
};
@@ -27,12 +26,12 @@ typedef struct {
bool rssi_history_end;
uint8_t ind_write;
uint8_t ind_sin;
SubghzReadRAWStatus satus;
} SubghzReadRAWModel;
SubGhzReadRAWStatus satus;
} SubGhzReadRAWModel;
void subghz_read_raw_set_callback(
SubghzReadRAW* subghz_read_raw,
SubghzReadRAWCallback callback,
SubGhzReadRAW* subghz_read_raw,
SubGhzReadRAWCallback callback,
void* context) {
furi_assert(subghz_read_raw);
furi_assert(callback);
@@ -41,19 +40,19 @@ void subghz_read_raw_set_callback(
}
void subghz_read_raw_add_data_statusbar(
SubghzReadRAW* instance,
SubGhzReadRAW* instance,
const char* frequency_str,
const char* preset_str) {
furi_assert(instance);
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
instance->view, (SubGhzReadRAWModel * model) {
string_set(model->frequency_str, frequency_str);
string_set(model->preset_str, preset_str);
return true;
});
}
void subghz_read_raw_add_data_rssi(SubghzReadRAW* instance, float rssi) {
void subghz_read_raw_add_data_rssi(SubGhzReadRAW* instance, float rssi) {
furi_assert(instance);
uint8_t u_rssi = 0;
@@ -62,10 +61,9 @@ void subghz_read_raw_add_data_rssi(SubghzReadRAW* instance, float rssi) {
} else {
u_rssi = (uint8_t)((rssi + 90) / 2.7);
}
//if(u_rssi > 34) u_rssi = 34;
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
instance->view, (SubGhzReadRAWModel * model) {
model->rssi_history[model->ind_write++] = u_rssi;
if(model->ind_write > SUBGHZ_READ_RAW_RSSI_HISTORY_SIZE) {
model->rssi_history_end = true;
@@ -75,46 +73,46 @@ void subghz_read_raw_add_data_rssi(SubghzReadRAW* instance, float rssi) {
});
}
void subghz_read_raw_update_sample_write(SubghzReadRAW* instance, size_t sample) {
void subghz_read_raw_update_sample_write(SubGhzReadRAW* instance, size_t sample) {
furi_assert(instance);
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
instance->view, (SubGhzReadRAWModel * model) {
string_printf(model->sample_write, "%d spl.", sample);
return false;
});
}
void subghz_read_raw_stop_send(SubghzReadRAW* instance) {
void subghz_read_raw_stop_send(SubGhzReadRAW* instance) {
furi_assert(instance);
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
instance->view, (SubGhzReadRAWModel * model) {
switch(model->satus) {
case SubghzReadRAWStatusTXRepeat:
case SubghzReadRAWStatusLoadKeyTXRepeat:
instance->callback(SubghzCustomEventViewReadRAWSendStart, instance->context);
case SubGhzReadRAWStatusTXRepeat:
case SubGhzReadRAWStatusLoadKeyTXRepeat:
instance->callback(SubGhzCustomEventViewReadRAWSendStart, instance->context);
break;
case SubghzReadRAWStatusTX:
model->satus = SubghzReadRAWStatusIDLE;
case SubGhzReadRAWStatusTX:
model->satus = SubGhzReadRAWStatusIDLE;
break;
case SubghzReadRAWStatusLoadKeyTX:
model->satus = SubghzReadRAWStatusLoadKeyIDLE;
case SubGhzReadRAWStatusLoadKeyTX:
model->satus = SubGhzReadRAWStatusLoadKeyIDLE;
break;
default:
FURI_LOG_W(TAG, "unknown status");
model->satus = SubghzReadRAWStatusIDLE;
model->satus = SubGhzReadRAWStatusIDLE;
break;
}
return true;
});
}
void subghz_read_raw_update_sin(SubghzReadRAW* instance) {
void subghz_read_raw_update_sin(SubGhzReadRAW* instance) {
furi_assert(instance);
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
instance->view, (SubGhzReadRAWModel * model) {
if(model->ind_sin++ > 62) {
model->ind_sin = 0;
}
@@ -134,7 +132,7 @@ static int8_t subghz_read_raw_tab_sin(uint8_t x) {
return r;
}
void subghz_read_raw_draw_sin(Canvas* canvas, SubghzReadRAWModel* model) {
void subghz_read_raw_draw_sin(Canvas* canvas, SubGhzReadRAWModel* model) {
#define SUBGHZ_RAW_SIN_AMPLITUDE 11
for(int i = 113; i > 0; i--) {
canvas_draw_line(
@@ -154,7 +152,7 @@ void subghz_read_raw_draw_sin(Canvas* canvas, SubghzReadRAWModel* model) {
}
}
void subghz_read_raw_draw_scale(Canvas* canvas, SubghzReadRAWModel* model) {
void subghz_read_raw_draw_scale(Canvas* canvas, SubGhzReadRAWModel* model) {
#define SUBGHZ_RAW_TOP_SCALE 14
#define SUBGHZ_RAW_END_SCALE 115
@@ -178,7 +176,7 @@ void subghz_read_raw_draw_scale(Canvas* canvas, SubghzReadRAWModel* model) {
}
}
void subghz_read_raw_draw_rssi(Canvas* canvas, SubghzReadRAWModel* model) {
void subghz_read_raw_draw_rssi(Canvas* canvas, SubGhzReadRAWModel* model) {
int ind = 0;
int base = 0;
if(model->rssi_history_end == false) {
@@ -214,7 +212,7 @@ void subghz_read_raw_draw_rssi(Canvas* canvas, SubghzReadRAWModel* model) {
}
}
void subghz_read_raw_draw(Canvas* canvas, SubghzReadRAWModel* model) {
void subghz_read_raw_draw(Canvas* canvas, SubGhzReadRAWModel* model) {
uint8_t graphics_mode = 1;
canvas_set_color(canvas, ColorBlack);
canvas_set_font(canvas, FontSecondary);
@@ -228,12 +226,12 @@ void subghz_read_raw_draw(Canvas* canvas, SubghzReadRAWModel* model) {
canvas_draw_line(canvas, 115, 14, 115, 48);
switch(model->satus) {
case SubghzReadRAWStatusIDLE:
case SubGhzReadRAWStatusIDLE:
elements_button_left(canvas, "Erase");
elements_button_center(canvas, "Send");
elements_button_right(canvas, "Save");
break;
case SubghzReadRAWStatusLoadKeyIDLE:
case SubGhzReadRAWStatusLoadKeyIDLE:
elements_button_left(canvas, "New");
elements_button_center(canvas, "Send");
elements_button_right(canvas, "More");
@@ -241,15 +239,15 @@ void subghz_read_raw_draw(Canvas* canvas, SubghzReadRAWModel* model) {
canvas, 4, 12, 110, 44, AlignCenter, AlignCenter, string_get_cstr(model->file_name));
break;
case SubghzReadRAWStatusTX:
case SubghzReadRAWStatusTXRepeat:
case SubghzReadRAWStatusLoadKeyTX:
case SubghzReadRAWStatusLoadKeyTXRepeat:
case SubGhzReadRAWStatusTX:
case SubGhzReadRAWStatusTXRepeat:
case SubGhzReadRAWStatusLoadKeyTX:
case SubGhzReadRAWStatusLoadKeyTXRepeat:
graphics_mode = 0;
elements_button_center(canvas, "Send");
break;
case SubghzReadRAWStatusStart:
case SubGhzReadRAWStatusStart:
elements_button_left(canvas, "Config");
elements_button_center(canvas, "REC");
break;
@@ -272,7 +270,7 @@ void subghz_read_raw_draw(Canvas* canvas, SubghzReadRAWModel* model) {
bool subghz_read_raw_input(InputEvent* event, void* context) {
furi_assert(context);
SubghzReadRAW* instance = context;
SubGhzReadRAW* instance = context;
if((event->key == InputKeyOk) &&
(event->type == InputTypeLong || event->type == InputTypeRepeat)) {
@@ -281,30 +279,30 @@ bool subghz_read_raw_input(InputEvent* event, void* context) {
return false;
} else if(event->key == InputKeyOk && event->type == InputTypePress) {
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
instance->view, (SubGhzReadRAWModel * model) {
uint8_t ret = false;
switch(model->satus) {
case SubghzReadRAWStatusIDLE:
case SubGhzReadRAWStatusIDLE:
// Start TX
instance->callback(SubghzCustomEventViewReadRAWSendStart, instance->context);
instance->callback(SubghzCustomEventViewReadRAWVibro, instance->context);
model->satus = SubghzReadRAWStatusTXRepeat;
instance->callback(SubGhzCustomEventViewReadRAWSendStart, instance->context);
instance->callback(SubGhzCustomEventViewReadRAWVibro, instance->context);
model->satus = SubGhzReadRAWStatusTXRepeat;
ret = true;
break;
case SubghzReadRAWStatusTX:
case SubGhzReadRAWStatusTX:
// Start TXRepeat
model->satus = SubghzReadRAWStatusTXRepeat;
model->satus = SubGhzReadRAWStatusTXRepeat;
break;
case SubghzReadRAWStatusLoadKeyIDLE:
case SubGhzReadRAWStatusLoadKeyIDLE:
// Start Load Key TX
instance->callback(SubghzCustomEventViewReadRAWSendStart, instance->context);
instance->callback(SubghzCustomEventViewReadRAWVibro, instance->context);
model->satus = SubghzReadRAWStatusLoadKeyTXRepeat;
instance->callback(SubGhzCustomEventViewReadRAWSendStart, instance->context);
instance->callback(SubGhzCustomEventViewReadRAWVibro, instance->context);
model->satus = SubGhzReadRAWStatusLoadKeyTXRepeat;
ret = true;
break;
case SubghzReadRAWStatusLoadKeyTX:
case SubGhzReadRAWStatusLoadKeyTX:
// Start Load Key TXRepeat
model->satus = SubghzReadRAWStatusLoadKeyTXRepeat;
model->satus = SubGhzReadRAWStatusLoadKeyTXRepeat;
break;
default:
@@ -314,91 +312,91 @@ bool subghz_read_raw_input(InputEvent* event, void* context) {
});
} else if(event->key == InputKeyOk && event->type == InputTypeRelease) {
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
if(model->satus == SubghzReadRAWStatusTXRepeat) {
instance->view, (SubGhzReadRAWModel * model) {
if(model->satus == SubGhzReadRAWStatusTXRepeat) {
// Stop repeat TX
model->satus = SubghzReadRAWStatusTX;
} else if(model->satus == SubghzReadRAWStatusLoadKeyTXRepeat) {
model->satus = SubGhzReadRAWStatusTX;
} else if(model->satus == SubGhzReadRAWStatusLoadKeyTXRepeat) {
// Stop repeat TX
model->satus = SubghzReadRAWStatusLoadKeyTX;
model->satus = SubGhzReadRAWStatusLoadKeyTX;
}
return false;
});
} else if(event->key == InputKeyBack && event->type == InputTypeShort) {
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
instance->view, (SubGhzReadRAWModel * model) {
switch(model->satus) {
case SubghzReadRAWStatusREC:
case SubGhzReadRAWStatusREC:
//Stop REC
instance->callback(SubghzCustomEventViewReadRAWIDLE, instance->context);
model->satus = SubghzReadRAWStatusIDLE;
instance->callback(SubGhzCustomEventViewReadRAWIDLE, instance->context);
model->satus = SubGhzReadRAWStatusIDLE;
break;
case SubghzReadRAWStatusLoadKeyTX:
case SubGhzReadRAWStatusLoadKeyTX:
//Stop TxRx
instance->callback(SubghzCustomEventViewReadRAWTXRXStop, instance->context);
model->satus = SubghzReadRAWStatusLoadKeyIDLE;
instance->callback(SubGhzCustomEventViewReadRAWTXRXStop, instance->context);
model->satus = SubGhzReadRAWStatusLoadKeyIDLE;
break;
case SubghzReadRAWStatusTX:
case SubGhzReadRAWStatusTX:
//Stop TxRx
instance->callback(SubghzCustomEventViewReadRAWTXRXStop, instance->context);
model->satus = SubghzReadRAWStatusIDLE;
instance->callback(SubGhzCustomEventViewReadRAWTXRXStop, instance->context);
model->satus = SubGhzReadRAWStatusIDLE;
break;
case SubghzReadRAWStatusLoadKeyIDLE:
case SubGhzReadRAWStatusLoadKeyIDLE:
//Exit
instance->callback(SubghzCustomEventViewReadRAWBack, instance->context);
instance->callback(SubGhzCustomEventViewReadRAWBack, instance->context);
break;
default:
//Exit
instance->callback(SubghzCustomEventViewReadRAWBack, instance->context);
instance->callback(SubGhzCustomEventViewReadRAWBack, instance->context);
break;
}
return true;
});
} else if(event->key == InputKeyLeft && event->type == InputTypeShort) {
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
if(model->satus == SubghzReadRAWStatusStart) {
instance->view, (SubGhzReadRAWModel * model) {
if(model->satus == SubGhzReadRAWStatusStart) {
//Config
instance->callback(SubghzCustomEventViewReadRAWConfig, instance->context);
instance->callback(SubGhzCustomEventViewReadRAWConfig, instance->context);
} else if(
(model->satus == SubghzReadRAWStatusIDLE) ||
(model->satus == SubghzReadRAWStatusLoadKeyIDLE)) {
(model->satus == SubGhzReadRAWStatusIDLE) ||
(model->satus == SubGhzReadRAWStatusLoadKeyIDLE)) {
//Erase
model->satus = SubghzReadRAWStatusStart;
model->satus = SubGhzReadRAWStatusStart;
model->rssi_history_end = false;
model->ind_write = 0;
string_set(model->sample_write, "0 spl.");
string_reset(model->file_name);
instance->callback(SubghzCustomEventViewReadRAWErase, instance->context);
instance->callback(SubGhzCustomEventViewReadRAWErase, instance->context);
}
return true;
});
} else if(event->key == InputKeyRight && event->type == InputTypeShort) {
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
if(model->satus == SubghzReadRAWStatusIDLE) {
instance->view, (SubGhzReadRAWModel * model) {
if(model->satus == SubGhzReadRAWStatusIDLE) {
//Save
instance->callback(SubghzCustomEventViewReadRAWSave, instance->context);
} else if(model->satus == SubghzReadRAWStatusLoadKeyIDLE) {
instance->callback(SubGhzCustomEventViewReadRAWSave, instance->context);
} else if(model->satus == SubGhzReadRAWStatusLoadKeyIDLE) {
//More
instance->callback(SubghzCustomEventViewReadRAWMore, instance->context);
instance->callback(SubGhzCustomEventViewReadRAWMore, instance->context);
}
return true;
});
} else if(event->key == InputKeyOk && event->type == InputTypeShort) {
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
if(model->satus == SubghzReadRAWStatusStart) {
instance->view, (SubGhzReadRAWModel * model) {
if(model->satus == SubGhzReadRAWStatusStart) {
//Record
instance->callback(SubghzCustomEventViewReadRAWREC, instance->context);
model->satus = SubghzReadRAWStatusREC;
instance->callback(SubGhzCustomEventViewReadRAWREC, instance->context);
model->satus = SubGhzReadRAWStatusREC;
model->ind_write = 0;
model->rssi_history_end = false;
} else if(model->satus == SubghzReadRAWStatusREC) {
} else if(model->satus == SubGhzReadRAWStatusREC) {
//Stop
instance->callback(SubghzCustomEventViewReadRAWIDLE, instance->context);
model->satus = SubghzReadRAWStatusIDLE;
instance->callback(SubGhzCustomEventViewReadRAWIDLE, instance->context);
model->satus = SubGhzReadRAWStatusIDLE;
}
return true;
});
@@ -407,16 +405,16 @@ bool subghz_read_raw_input(InputEvent* event, void* context) {
}
void subghz_read_raw_set_status(
SubghzReadRAW* instance,
SubghzReadRAWStatus satus,
SubGhzReadRAW* instance,
SubGhzReadRAWStatus satus,
const char* file_name) {
furi_assert(instance);
switch(satus) {
case SubghzReadRAWStatusStart:
case SubGhzReadRAWStatusStart:
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
model->satus = SubghzReadRAWStatusStart;
instance->view, (SubGhzReadRAWModel * model) {
model->satus = SubGhzReadRAWStatusStart;
model->rssi_history_end = false;
model->ind_write = 0;
string_reset(model->file_name);
@@ -424,17 +422,17 @@ void subghz_read_raw_set_status(
return true;
});
break;
case SubghzReadRAWStatusIDLE:
case SubGhzReadRAWStatusIDLE:
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
model->satus = SubghzReadRAWStatusIDLE;
instance->view, (SubGhzReadRAWModel * model) {
model->satus = SubGhzReadRAWStatusIDLE;
return true;
});
break;
case SubghzReadRAWStatusLoadKeyTX:
case SubGhzReadRAWStatusLoadKeyTX:
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
model->satus = SubghzReadRAWStatusLoadKeyIDLE;
instance->view, (SubGhzReadRAWModel * model) {
model->satus = SubGhzReadRAWStatusLoadKeyIDLE;
model->rssi_history_end = false;
model->ind_write = 0;
string_set(model->file_name, file_name);
@@ -442,10 +440,10 @@ void subghz_read_raw_set_status(
return true;
});
break;
case SubghzReadRAWStatusSaveKey:
case SubGhzReadRAWStatusSaveKey:
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
model->satus = SubghzReadRAWStatusLoadKeyIDLE;
instance->view, (SubGhzReadRAWModel * model) {
model->satus = SubGhzReadRAWStatusLoadKeyIDLE;
if(!model->ind_write) {
string_set(model->file_name, file_name);
string_set(model->sample_write, "RAW");
@@ -464,31 +462,31 @@ void subghz_read_raw_set_status(
void subghz_read_raw_enter(void* context) {
furi_assert(context);
//SubghzReadRAW* instance = context;
//SubGhzReadRAW* instance = context;
}
void subghz_read_raw_exit(void* context) {
furi_assert(context);
SubghzReadRAW* instance = context;
SubGhzReadRAW* instance = context;
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
if(model->satus != SubghzReadRAWStatusIDLE &&
model->satus != SubghzReadRAWStatusStart &&
model->satus != SubghzReadRAWStatusLoadKeyIDLE) {
instance->callback(SubghzCustomEventViewReadRAWIDLE, instance->context);
model->satus = SubghzReadRAWStatusStart;
instance->view, (SubGhzReadRAWModel * model) {
if(model->satus != SubGhzReadRAWStatusIDLE &&
model->satus != SubGhzReadRAWStatusStart &&
model->satus != SubGhzReadRAWStatusLoadKeyIDLE) {
instance->callback(SubGhzCustomEventViewReadRAWIDLE, instance->context);
model->satus = SubGhzReadRAWStatusStart;
}
return true;
});
}
SubghzReadRAW* subghz_read_raw_alloc() {
SubghzReadRAW* instance = malloc(sizeof(SubghzReadRAW));
SubGhzReadRAW* subghz_read_raw_alloc() {
SubGhzReadRAW* instance = malloc(sizeof(SubGhzReadRAW));
// View allocation and configuration
instance->view = view_alloc();
view_allocate_model(instance->view, ViewModelTypeLocking, sizeof(SubghzReadRAWModel));
view_allocate_model(instance->view, ViewModelTypeLocking, sizeof(SubGhzReadRAWModel));
view_set_context(instance->view, instance);
view_set_draw_callback(instance->view, (ViewDrawCallback)subghz_read_raw_draw);
view_set_input_callback(instance->view, subghz_read_raw_input);
@@ -496,7 +494,7 @@ SubghzReadRAW* subghz_read_raw_alloc() {
view_set_exit_callback(instance->view, subghz_read_raw_exit);
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
instance->view, (SubGhzReadRAWModel * model) {
string_init(model->frequency_str);
string_init(model->preset_str);
string_init(model->sample_write);
@@ -508,11 +506,11 @@ SubghzReadRAW* subghz_read_raw_alloc() {
return instance;
}
void subghz_read_raw_free(SubghzReadRAW* instance) {
void subghz_read_raw_free(SubGhzReadRAW* instance) {
furi_assert(instance);
with_view_model(
instance->view, (SubghzReadRAWModel * model) {
instance->view, (SubGhzReadRAWModel * model) {
string_clear(model->frequency_str);
string_clear(model->preset_str);
string_clear(model->sample_write);
@@ -524,7 +522,7 @@ void subghz_read_raw_free(SubghzReadRAW* instance) {
free(instance);
}
View* subghz_read_raw_get_view(SubghzReadRAW* instance) {
View* subghz_read_raw_get_view(SubGhzReadRAW* instance) {
furi_assert(instance);
return instance->view;
}

48
applications/subghz/views/subghz_read_raw.h
View File

@@ -3,48 +3,48 @@
#include <gui/view.h>
#include "../helpers/subghz_custom_event.h"
typedef struct SubghzReadRAW SubghzReadRAW;
typedef struct SubGhzReadRAW SubGhzReadRAW;
typedef void (*SubghzReadRAWCallback)(SubghzCustomEvent event, void* context);
typedef void (*SubGhzReadRAWCallback)(SubGhzCustomEvent event, void* context);
typedef enum {
SubghzReadRAWStatusStart,
SubghzReadRAWStatusIDLE,
SubghzReadRAWStatusREC,
SubghzReadRAWStatusTX,
SubghzReadRAWStatusTXRepeat,
SubGhzReadRAWStatusStart,
SubGhzReadRAWStatusIDLE,
SubGhzReadRAWStatusREC,
SubGhzReadRAWStatusTX,
SubGhzReadRAWStatusTXRepeat,
SubghzReadRAWStatusLoadKeyIDLE,
SubghzReadRAWStatusLoadKeyTX,
SubghzReadRAWStatusLoadKeyTXRepeat,
SubghzReadRAWStatusSaveKey,
} SubghzReadRAWStatus;
SubGhzReadRAWStatusLoadKeyIDLE,
SubGhzReadRAWStatusLoadKeyTX,
SubGhzReadRAWStatusLoadKeyTXRepeat,
SubGhzReadRAWStatusSaveKey,
} SubGhzReadRAWStatus;
void subghz_read_raw_set_callback(
SubghzReadRAW* subghz_read_raw,
SubghzReadRAWCallback callback,
SubGhzReadRAW* subghz_read_raw,
SubGhzReadRAWCallback callback,
void* context);
SubghzReadRAW* subghz_read_raw_alloc();
SubGhzReadRAW* subghz_read_raw_alloc();
void subghz_read_raw_free(SubghzReadRAW* subghz_static);
void subghz_read_raw_free(SubGhzReadRAW* subghz_static);
void subghz_read_raw_add_data_statusbar(
SubghzReadRAW* instance,
SubGhzReadRAW* instance,
const char* frequency_str,
const char* preset_str);
void subghz_read_raw_update_sample_write(SubghzReadRAW* instance, size_t sample);
void subghz_read_raw_update_sample_write(SubGhzReadRAW* instance, size_t sample);
void subghz_read_raw_stop_send(SubghzReadRAW* instance);
void subghz_read_raw_stop_send(SubGhzReadRAW* instance);
void subghz_read_raw_update_sin(SubghzReadRAW* instance);
void subghz_read_raw_update_sin(SubGhzReadRAW* instance);
void subghz_read_raw_add_data_rssi(SubghzReadRAW* instance, float rssi);
void subghz_read_raw_add_data_rssi(SubGhzReadRAW* instance, float rssi);
void subghz_read_raw_set_status(
SubghzReadRAW* instance,
SubghzReadRAWStatus satus,
SubGhzReadRAW* instance,
SubGhzReadRAWStatus satus,
const char* file_name);
View* subghz_read_raw_get_view(SubghzReadRAW* subghz_static);
View* subghz_read_raw_get_view(SubGhzReadRAW* subghz_static);

36
applications/subghz/views/subghz_receiver.h
View File

@@ -1,36 +0,0 @@
#pragma once
#include <gui/view.h>
#include "../helpers/subghz_custom_event.h"
typedef struct SubghzReceiver SubghzReceiver;
typedef void (*SubghzReceiverCallback)(SubghzCustomEvent event, void* context);
void subghz_receiver_set_callback(
SubghzReceiver* subghz_receiver,
SubghzReceiverCallback callback,
void* context);
SubghzReceiver* subghz_receiver_alloc();
void subghz_receiver_free(SubghzReceiver* subghz_receiver);
View* subghz_receiver_get_view(SubghzReceiver* subghz_receiver);
void subghz_receiver_add_data_statusbar(
SubghzReceiver* subghz_receiver,
const char* frequency_str,
const char* preset_str,
const char* history_stat_str);
void subghz_receiver_add_item_to_menu(
SubghzReceiver* subghz_receiver,
const char* name,
uint8_t type);
uint16_t subghz_receiver_get_idx_menu(SubghzReceiver* subghz_receiver);
void subghz_receiver_set_idx_menu(SubghzReceiver* subghz_receiver, uint16_t idx);
void subghz_receiver_exit(void* context);

60
applications/subghz/views/subghz_test_carrier.c
View File

@@ -7,29 +7,29 @@
#include <furi_hal.h>
#include <input/input.h>
struct SubghzTestCarrier {
struct SubGhzTestCarrier {
View* view;
osTimerId_t timer;
SubghzTestCarrierCallback callback;
SubGhzTestCarrierCallback callback;
void* context;
};
typedef enum {
SubghzTestCarrierModelStatusRx,
SubghzTestCarrierModelStatusTx,
} SubghzTestCarrierModelStatus;
SubGhzTestCarrierModelStatusRx,
SubGhzTestCarrierModelStatusTx,
} SubGhzTestCarrierModelStatus;
typedef struct {
uint8_t frequency;
uint32_t real_frequency;
FuriHalSubGhzPath path;
float rssi;
SubghzTestCarrierModelStatus status;
} SubghzTestCarrierModel;
SubGhzTestCarrierModelStatus status;
} SubGhzTestCarrierModel;
void subghz_test_carrier_set_callback(
SubghzTestCarrier* subghz_test_carrier,
SubghzTestCarrierCallback callback,
SubGhzTestCarrier* subghz_test_carrier,
SubGhzTestCarrierCallback callback,
void* context) {
furi_assert(subghz_test_carrier);
furi_assert(callback);
@@ -37,7 +37,7 @@ void subghz_test_carrier_set_callback(
subghz_test_carrier->context = context;
}
void subghz_test_carrier_draw(Canvas* canvas, SubghzTestCarrierModel* model) {
void subghz_test_carrier_draw(Canvas* canvas, SubGhzTestCarrierModel* model) {
char buffer[64];
canvas_set_color(canvas, ColorBlack);
@@ -67,7 +67,7 @@ void subghz_test_carrier_draw(Canvas* canvas, SubghzTestCarrierModel* model) {
}
snprintf(buffer, sizeof(buffer), "Path: %d - %s", model->path, path_name);
canvas_draw_str(canvas, 0, 31, buffer);
if(model->status == SubghzTestCarrierModelStatusRx) {
if(model->status == SubGhzTestCarrierModelStatusRx) {
snprintf(
buffer,
sizeof(buffer),
@@ -82,14 +82,14 @@ void subghz_test_carrier_draw(Canvas* canvas, SubghzTestCarrierModel* model) {
bool subghz_test_carrier_input(InputEvent* event, void* context) {
furi_assert(context);
SubghzTestCarrier* subghz_test_carrier = context;
SubGhzTestCarrier* subghz_test_carrier = context;
if(event->key == InputKeyBack || event->type != InputTypeShort) {
return false;
}
with_view_model(
subghz_test_carrier->view, (SubghzTestCarrierModel * model) {
subghz_test_carrier->view, (SubGhzTestCarrierModel * model) {
furi_hal_subghz_idle();
if(event->key == InputKeyLeft) {
@@ -101,10 +101,10 @@ bool subghz_test_carrier_input(InputEvent* event, void* context) {
} else if(event->key == InputKeyUp) {
if(model->path < FuriHalSubGhzPath868) model->path++;
} else if(event->key == InputKeyOk) {
if(model->status == SubghzTestCarrierModelStatusTx) {
model->status = SubghzTestCarrierModelStatusRx;
if(model->status == SubGhzTestCarrierModelStatusTx) {
model->status = SubGhzTestCarrierModelStatusRx;
} else {
model->status = SubghzTestCarrierModelStatusTx;
model->status = SubGhzTestCarrierModelStatusTx;
}
}
@@ -112,7 +112,7 @@ bool subghz_test_carrier_input(InputEvent* event, void* context) {
furi_hal_subghz_set_frequency(subghz_frequencies_testing[model->frequency]);
furi_hal_subghz_set_path(model->path);
if(model->status == SubghzTestCarrierModelStatusRx) {
if(model->status == SubGhzTestCarrierModelStatusRx) {
hal_gpio_init(&gpio_cc1101_g0, GpioModeInput, GpioPullNo, GpioSpeedLow);
furi_hal_subghz_rx();
} else {
@@ -121,7 +121,7 @@ bool subghz_test_carrier_input(InputEvent* event, void* context) {
if(!furi_hal_subghz_tx()) {
hal_gpio_init(&gpio_cc1101_g0, GpioModeInput, GpioPullNo, GpioSpeedLow);
subghz_test_carrier->callback(
SubghzTestCarrierEventOnlyRx, subghz_test_carrier->context);
SubGhzTestCarrierEventOnlyRx, subghz_test_carrier->context);
}
}
@@ -133,7 +133,7 @@ bool subghz_test_carrier_input(InputEvent* event, void* context) {
void subghz_test_carrier_enter(void* context) {
furi_assert(context);
SubghzTestCarrier* subghz_test_carrier = context;
SubGhzTestCarrier* subghz_test_carrier = context;
furi_hal_subghz_reset();
furi_hal_subghz_load_preset(FuriHalSubGhzPresetOok650Async);
@@ -141,13 +141,13 @@ void subghz_test_carrier_enter(void* context) {
hal_gpio_init(&gpio_cc1101_g0, GpioModeInput, GpioPullNo, GpioSpeedLow);
with_view_model(
subghz_test_carrier->view, (SubghzTestCarrierModel * model) {
subghz_test_carrier->view, (SubGhzTestCarrierModel * model) {
model->frequency = subghz_frequencies_433_92_testing; // 433
model->real_frequency =
furi_hal_subghz_set_frequency(subghz_frequencies_testing[model->frequency]);
model->path = FuriHalSubGhzPathIsolate; // isolate
model->rssi = 0.0f;
model->status = SubghzTestCarrierModelStatusRx;
model->status = SubGhzTestCarrierModelStatusRx;
return true;
});
@@ -158,7 +158,7 @@ void subghz_test_carrier_enter(void* context) {
void subghz_test_carrier_exit(void* context) {
furi_assert(context);
SubghzTestCarrier* subghz_test_carrier = context;
SubGhzTestCarrier* subghz_test_carrier = context;
osTimerStop(subghz_test_carrier->timer);
@@ -168,11 +168,11 @@ void subghz_test_carrier_exit(void* context) {
void subghz_test_carrier_rssi_timer_callback(void* context) {
furi_assert(context);
SubghzTestCarrier* subghz_test_carrier = context;
SubGhzTestCarrier* subghz_test_carrier = context;
with_view_model(
subghz_test_carrier->view, (SubghzTestCarrierModel * model) {
if(model->status == SubghzTestCarrierModelStatusRx) {
subghz_test_carrier->view, (SubGhzTestCarrierModel * model) {
if(model->status == SubGhzTestCarrierModelStatusRx) {
model->rssi = furi_hal_subghz_get_rssi();
return true;
}
@@ -180,13 +180,13 @@ void subghz_test_carrier_rssi_timer_callback(void* context) {
});
}
SubghzTestCarrier* subghz_test_carrier_alloc() {
SubghzTestCarrier* subghz_test_carrier = malloc(sizeof(SubghzTestCarrier));
SubGhzTestCarrier* subghz_test_carrier_alloc() {
SubGhzTestCarrier* subghz_test_carrier = malloc(sizeof(SubGhzTestCarrier));
// View allocation and configuration
subghz_test_carrier->view = view_alloc();
view_allocate_model(
subghz_test_carrier->view, ViewModelTypeLocking, sizeof(SubghzTestCarrierModel));
subghz_test_carrier->view, ViewModelTypeLocking, sizeof(SubGhzTestCarrierModel));
view_set_context(subghz_test_carrier->view, subghz_test_carrier);
view_set_draw_callback(subghz_test_carrier->view, (ViewDrawCallback)subghz_test_carrier_draw);
view_set_input_callback(subghz_test_carrier->view, subghz_test_carrier_input);
@@ -199,14 +199,14 @@ SubghzTestCarrier* subghz_test_carrier_alloc() {
return subghz_test_carrier;
}
void subghz_test_carrier_free(SubghzTestCarrier* subghz_test_carrier) {
void subghz_test_carrier_free(SubGhzTestCarrier* subghz_test_carrier) {
furi_assert(subghz_test_carrier);
osTimerDelete(subghz_test_carrier->timer);
view_free(subghz_test_carrier->view);
free(subghz_test_carrier);
}
View* subghz_test_carrier_get_view(SubghzTestCarrier* subghz_test_carrier) {
View* subghz_test_carrier_get_view(SubGhzTestCarrier* subghz_test_carrier) {
furi_assert(subghz_test_carrier);
return subghz_test_carrier->view;
}

18
applications/subghz/views/subghz_test_carrier.h
View File

@@ -3,20 +3,20 @@
#include <gui/view.h>
typedef enum {
SubghzTestCarrierEventOnlyRx,
} SubghzTestCarrierEvent;
SubGhzTestCarrierEventOnlyRx,
} SubGhzTestCarrierEvent;
typedef struct SubghzTestCarrier SubghzTestCarrier;
typedef struct SubGhzTestCarrier SubGhzTestCarrier;
typedef void (*SubghzTestCarrierCallback)(SubghzTestCarrierEvent event, void* context);
typedef void (*SubGhzTestCarrierCallback)(SubGhzTestCarrierEvent event, void* context);
void subghz_test_carrier_set_callback(
SubghzTestCarrier* subghz_test_carrier,
SubghzTestCarrierCallback callback,
SubGhzTestCarrier* subghz_test_carrier,
SubGhzTestCarrierCallback callback,
void* context);
SubghzTestCarrier* subghz_test_carrier_alloc();
SubGhzTestCarrier* subghz_test_carrier_alloc();
void subghz_test_carrier_free(SubghzTestCarrier* subghz_test_carrier);
void subghz_test_carrier_free(SubGhzTestCarrier* subghz_test_carrier);
View* subghz_test_carrier_get_view(SubghzTestCarrier* subghz_test_carrier);
View* subghz_test_carrier_get_view(SubGhzTestCarrier* subghz_test_carrier);

112
applications/subghz/views/subghz_test_packet.c
View File

@@ -7,26 +7,26 @@
#include <furi_hal.h>
#include <input/input.h>
#include <toolbox/level_duration.h>
#include <lib/subghz/protocols/subghz_protocol_princeton.h>
#include <lib/subghz/protocols/princeton_for_testing.h>
#define SUBGHZ_TEST_PACKET_COUNT 500
struct SubghzTestPacket {
struct SubGhzTestPacket {
View* view;
osTimerId_t timer;
SubGhzDecoderPrinceton* decoder;
SubGhzEncoderPrinceton* encoder;
volatile size_t packet_rx;
SubghzTestPacketCallback callback;
SubGhzTestPacketCallback callback;
void* context;
};
typedef enum {
SubghzTestPacketModelStatusRx,
SubghzTestPacketModelStatusOnlyRx,
SubghzTestPacketModelStatusTx,
} SubghzTestPacketModelStatus;
SubGhzTestPacketModelStatusRx,
SubGhzTestPacketModelStatusOnlyRx,
SubGhzTestPacketModelStatusTx,
} SubGhzTestPacketModelStatus;
typedef struct {
uint8_t frequency;
@@ -34,14 +34,14 @@ typedef struct {
FuriHalSubGhzPath path;
float rssi;
size_t packets;
SubghzTestPacketModelStatus status;
} SubghzTestPacketModel;
SubGhzTestPacketModelStatus status;
} SubGhzTestPacketModel;
volatile bool subghz_test_packet_overrun = false;
void subghz_test_packet_set_callback(
SubghzTestPacket* subghz_test_packet,
SubghzTestPacketCallback callback,
SubGhzTestPacket* subghz_test_packet,
SubGhzTestPacketCallback callback,
void* context) {
furi_assert(subghz_test_packet);
furi_assert(callback);
@@ -51,34 +51,36 @@ void subghz_test_packet_set_callback(
static void subghz_test_packet_rx_callback(bool level, uint32_t duration, void* context) {
furi_assert(context);
SubghzTestPacket* instance = context;
subghz_decoder_princeton_parse(instance->decoder, level, duration);
SubGhzTestPacket* instance = context;
subghz_decoder_princeton_for_testing_parse(instance->decoder, level, duration);
}
static void subghz_test_packet_rx_pt_callback(SubGhzProtocolCommon* parser, void* context) {
//todo
static void subghz_test_packet_rx_pt_callback(SubGhzDecoderPrinceton* parser, void* context) {
furi_assert(context);
SubghzTestPacket* instance = context;
SubGhzTestPacket* instance = context;
instance->packet_rx++;
}
static void subghz_test_packet_rssi_timer_callback(void* context) {
furi_assert(context);
SubghzTestPacket* instance = context;
SubGhzTestPacket* instance = context;
with_view_model(
instance->view, (SubghzTestPacketModel * model) {
if(model->status == SubghzTestPacketModelStatusRx) {
instance->view, (SubGhzTestPacketModel * model) {
if(model->status == SubGhzTestPacketModelStatusRx) {
model->rssi = furi_hal_subghz_get_rssi();
model->packets = instance->packet_rx;
} else if(model->status == SubghzTestPacketModelStatusTx) {
model->packets = SUBGHZ_TEST_PACKET_COUNT -
subghz_encoder_princeton_get_repeat_left(instance->encoder);
} else if(model->status == SubGhzTestPacketModelStatusTx) {
model->packets =
SUBGHZ_TEST_PACKET_COUNT -
subghz_encoder_princeton_for_testing_get_repeat_left(instance->encoder);
}
return true;
});
}
static void subghz_test_packet_draw(Canvas* canvas, SubghzTestPacketModel* model) {
static void subghz_test_packet_draw(Canvas* canvas, SubGhzTestPacketModel* model) {
char buffer[64];
canvas_set_color(canvas, ColorBlack);
@@ -112,7 +114,7 @@ static void subghz_test_packet_draw(Canvas* canvas, SubghzTestPacketModel* model
snprintf(buffer, sizeof(buffer), "Packets: %d", model->packets);
canvas_draw_str(canvas, 0, 42, buffer);
if(model->status == SubghzTestPacketModelStatusRx) {
if(model->status == SubGhzTestPacketModelStatusRx) {
snprintf(
buffer,
sizeof(buffer),
@@ -127,18 +129,18 @@ static void subghz_test_packet_draw(Canvas* canvas, SubghzTestPacketModel* model
static bool subghz_test_packet_input(InputEvent* event, void* context) {
furi_assert(context);
SubghzTestPacket* instance = context;
SubGhzTestPacket* instance = context;
if(event->key == InputKeyBack || event->type != InputTypeShort) {
return false;
}
with_view_model(
instance->view, (SubghzTestPacketModel * model) {
if(model->status == SubghzTestPacketModelStatusRx) {
instance->view, (SubGhzTestPacketModel * model) {
if(model->status == SubGhzTestPacketModelStatusRx) {
furi_hal_subghz_stop_async_rx();
} else if(model->status == SubghzTestPacketModelStatusTx) {
subghz_encoder_princeton_stop(instance->encoder, millis());
} else if(model->status == SubGhzTestPacketModelStatusTx) {
subghz_encoder_princeton_for_testing_stop(instance->encoder, millis());
furi_hal_subghz_stop_async_tx();
}
@@ -151,10 +153,10 @@ static bool subghz_test_packet_input(InputEvent* event, void* context) {
} else if(event->key == InputKeyUp) {
if(model->path < FuriHalSubGhzPath868) model->path++;
} else if(event->key == InputKeyOk) {
if(model->status == SubghzTestPacketModelStatusRx) {
model->status = SubghzTestPacketModelStatusTx;
if(model->status == SubGhzTestPacketModelStatusRx) {
model->status = SubGhzTestPacketModelStatusTx;
} else {
model->status = SubghzTestPacketModelStatusRx;
model->status = SubGhzTestPacketModelStatusRx;
}
}
@@ -162,18 +164,18 @@ static bool subghz_test_packet_input(InputEvent* event, void* context) {
furi_hal_subghz_set_frequency(subghz_frequencies_testing[model->frequency]);
furi_hal_subghz_set_path(model->path);
if(model->status == SubghzTestPacketModelStatusRx) {
if(model->status == SubGhzTestPacketModelStatusRx) {
furi_hal_subghz_start_async_rx(subghz_test_packet_rx_callback, instance);
} else {
subghz_encoder_princeton_set(
subghz_encoder_princeton_for_testing_set(
instance->encoder,
0x00AABBCC,
SUBGHZ_TEST_PACKET_COUNT,
subghz_frequencies_testing[model->frequency]);
if(!furi_hal_subghz_start_async_tx(
subghz_encoder_princeton_yield, instance->encoder)) {
model->status = SubghzTestPacketModelStatusOnlyRx;
instance->callback(SubghzTestPacketEventOnlyRx, instance->context);
subghz_encoder_princeton_for_testing_yield, instance->encoder)) {
model->status = SubGhzTestPacketModelStatusOnlyRx;
instance->callback(SubGhzTestPacketEventOnlyRx, instance->context);
}
}
@@ -185,19 +187,19 @@ static bool subghz_test_packet_input(InputEvent* event, void* context) {
void subghz_test_packet_enter(void* context) {
furi_assert(context);
SubghzTestPacket* instance = context;
SubGhzTestPacket* instance = context;
furi_hal_subghz_reset();
furi_hal_subghz_load_preset(FuriHalSubGhzPresetOok650Async);
with_view_model(
instance->view, (SubghzTestPacketModel * model) {
instance->view, (SubGhzTestPacketModel * model) {
model->frequency = subghz_frequencies_433_92_testing;
model->real_frequency =
furi_hal_subghz_set_frequency(subghz_frequencies_testing[model->frequency]);
model->path = FuriHalSubGhzPathIsolate; // isolate
model->rssi = 0.0f;
model->status = SubghzTestPacketModelStatusRx;
model->status = SubGhzTestPacketModelStatusRx;
return true;
});
@@ -208,17 +210,17 @@ void subghz_test_packet_enter(void* context) {
void subghz_test_packet_exit(void* context) {
furi_assert(context);
SubghzTestPacket* instance = context;
SubGhzTestPacket* instance = context;
osTimerStop(instance->timer);
// Reinitialize IC to default state
with_view_model(
instance->view, (SubghzTestPacketModel * model) {
if(model->status == SubghzTestPacketModelStatusRx) {
instance->view, (SubGhzTestPacketModel * model) {
if(model->status == SubGhzTestPacketModelStatusRx) {
furi_hal_subghz_stop_async_rx();
} else if(model->status == SubghzTestPacketModelStatusTx) {
subghz_encoder_princeton_stop(instance->encoder, millis());
} else if(model->status == SubGhzTestPacketModelStatusTx) {
subghz_encoder_princeton_for_testing_stop(instance->encoder, millis());
furi_hal_subghz_stop_async_tx();
}
return true;
@@ -226,12 +228,12 @@ void subghz_test_packet_exit(void* context) {
furi_hal_subghz_sleep();
}
SubghzTestPacket* subghz_test_packet_alloc() {
SubghzTestPacket* instance = malloc(sizeof(SubghzTestPacket));
SubGhzTestPacket* subghz_test_packet_alloc() {
SubGhzTestPacket* instance = malloc(sizeof(SubGhzTestPacket));
// View allocation and configuration
instance->view = view_alloc();
view_allocate_model(instance->view, ViewModelTypeLocking, sizeof(SubghzTestPacketModel));
view_allocate_model(instance->view, ViewModelTypeLocking, sizeof(SubGhzTestPacketModel));
view_set_context(instance->view, instance);
view_set_draw_callback(instance->view, (ViewDrawCallback)subghz_test_packet_draw);
view_set_input_callback(instance->view, subghz_test_packet_input);
@@ -241,26 +243,26 @@ SubghzTestPacket* subghz_test_packet_alloc() {
instance->timer =
osTimerNew(subghz_test_packet_rssi_timer_callback, osTimerPeriodic, instance, NULL);
instance->decoder = subghz_decoder_princeton_alloc();
subghz_protocol_common_set_callback(
(SubGhzProtocolCommon*)instance->decoder, subghz_test_packet_rx_pt_callback, instance);
instance->encoder = subghz_encoder_princeton_alloc();
instance->decoder = subghz_decoder_princeton_for_testing_alloc();
subghz_decoder_princeton_for_testing_set_callback(
instance->decoder, subghz_test_packet_rx_pt_callback, instance);
instance->encoder = subghz_encoder_princeton_for_testing_alloc();
return instance;
}
void subghz_test_packet_free(SubghzTestPacket* instance) {
void subghz_test_packet_free(SubGhzTestPacket* instance) {
furi_assert(instance);
subghz_decoder_princeton_free(instance->decoder);
subghz_encoder_princeton_free(instance->encoder);
subghz_decoder_princeton_for_testing_free(instance->decoder);
subghz_encoder_princeton_for_testing_free(instance->encoder);
osTimerDelete(instance->timer);
view_free(instance->view);
free(instance);
}
View* subghz_test_packet_get_view(SubghzTestPacket* instance) {
View* subghz_test_packet_get_view(SubGhzTestPacket* instance) {
furi_assert(instance);
return instance->view;
}

18
applications/subghz/views/subghz_test_packet.h
View File

@@ -3,20 +3,20 @@
#include <gui/view.h>
typedef enum {
SubghzTestPacketEventOnlyRx,
} SubghzTestPacketEvent;
SubGhzTestPacketEventOnlyRx,
} SubGhzTestPacketEvent;
typedef struct SubghzTestPacket SubghzTestPacket;
typedef struct SubGhzTestPacket SubGhzTestPacket;
typedef void (*SubghzTestPacketCallback)(SubghzTestPacketEvent event, void* context);
typedef void (*SubGhzTestPacketCallback)(SubGhzTestPacketEvent event, void* context);
void subghz_test_packet_set_callback(
SubghzTestPacket* subghz_test_packet,
SubghzTestPacketCallback callback,
SubGhzTestPacket* subghz_test_packet,
SubGhzTestPacketCallback callback,
void* context);
SubghzTestPacket* subghz_test_packet_alloc();
SubGhzTestPacket* subghz_test_packet_alloc();
void subghz_test_packet_free(SubghzTestPacket* subghz_test_packet);
void subghz_test_packet_free(SubGhzTestPacket* subghz_test_packet);
View* subghz_test_packet_get_view(SubghzTestPacket* subghz_test_packet);
View* subghz_test_packet_get_view(SubGhzTestPacket* subghz_test_packet);

62
applications/subghz/views/subghz_test_static.c
View File

@@ -7,14 +7,14 @@
#include <furi_hal.h>
#include <input/input.h>
#include <notification/notification_messages.h>
#include <lib/subghz/protocols/subghz_protocol_princeton.h>
#include <lib/subghz/protocols/princeton_for_testing.h>
#define TAG "SubGhzTestStatic"
typedef enum {
SubghzTestStaticStatusIDLE,
SubghzTestStaticStatusTX,
} SubghzTestStaticStatus;
SubGhzTestStaticStatusIDLE,
SubGhzTestStaticStatusTX,
} SubGhzTestStaticStatus;
static const uint32_t subghz_test_static_keys[] = {
0x0074BADE,
@@ -23,11 +23,11 @@ static const uint32_t subghz_test_static_keys[] = {
0x00E34A4E,
};
struct SubghzTestStatic {
struct SubGhzTestStatic {
View* view;
SubghzTestStaticStatus satus_tx;
SubGhzTestStaticStatus satus_tx;
SubGhzEncoderPrinceton* encoder;
SubghzTestStaticCallback callback;
SubGhzTestStaticCallback callback;
void* context;
};
@@ -35,11 +35,11 @@ typedef struct {
uint8_t frequency;
uint32_t real_frequency;
uint8_t button;
} SubghzTestStaticModel;
} SubGhzTestStaticModel;
void subghz_test_static_set_callback(
SubghzTestStatic* subghz_test_static,
SubghzTestStaticCallback callback,
SubGhzTestStatic* subghz_test_static,
SubGhzTestStaticCallback callback,
void* context) {
furi_assert(subghz_test_static);
furi_assert(callback);
@@ -47,7 +47,7 @@ void subghz_test_static_set_callback(
subghz_test_static->context = context;
}
void subghz_test_static_draw(Canvas* canvas, SubghzTestStaticModel* model) {
void subghz_test_static_draw(Canvas* canvas, SubGhzTestStaticModel* model) {
char buffer[64];
canvas_set_color(canvas, ColorBlack);
@@ -70,14 +70,14 @@ void subghz_test_static_draw(Canvas* canvas, SubghzTestStaticModel* model) {
bool subghz_test_static_input(InputEvent* event, void* context) {
furi_assert(context);
SubghzTestStatic* instance = context;
SubGhzTestStatic* instance = context;
if(event->key == InputKeyBack) {
return false;
}
with_view_model(
instance->view, (SubghzTestStaticModel * model) {
instance->view, (SubGhzTestStaticModel * model) {
if(event->type == InputTypeShort) {
if(event->key == InputKeyLeft) {
if(model->frequency > 0) model->frequency--;
@@ -99,31 +99,31 @@ bool subghz_test_static_input(InputEvent* event, void* context) {
furi_hal_subghz_set_frequency_and_path(
subghz_frequencies_testing[model->frequency]);
if(!furi_hal_subghz_tx()) {
instance->callback(SubghzTestStaticEventOnlyRx, instance->context);
instance->callback(SubGhzTestStaticEventOnlyRx, instance->context);
} else {
notification_message_block(notification, &sequence_set_red_255);
FURI_LOG_I(TAG, "TX Start");
subghz_encoder_princeton_set(
subghz_encoder_princeton_for_testing_set(
instance->encoder,
subghz_test_static_keys[model->button],
10000,
subghz_frequencies_testing[model->frequency]);
furi_hal_subghz_start_async_tx(
subghz_encoder_princeton_yield, instance->encoder);
instance->satus_tx = SubghzTestStaticStatusTX;
subghz_encoder_princeton_for_testing_yield, instance->encoder);
instance->satus_tx = SubGhzTestStaticStatusTX;
}
} else if(event->type == InputTypeRelease) {
if(instance->satus_tx == SubghzTestStaticStatusTX) {
if(instance->satus_tx == SubGhzTestStaticStatusTX) {
FURI_LOG_I(TAG, "TX Stop");
subghz_encoder_princeton_stop(instance->encoder, millis());
subghz_encoder_princeton_print_log(instance->encoder);
subghz_encoder_princeton_for_testing_stop(instance->encoder, millis());
subghz_encoder_princeton_for_testing_print_log(instance->encoder);
furi_hal_subghz_stop_async_tx();
notification_message(notification, &sequence_reset_red);
}
instance->satus_tx = SubghzTestStaticStatusIDLE;
instance->satus_tx = SubGhzTestStaticStatusIDLE;
}
furi_record_close("notification");
}
@@ -136,17 +136,17 @@ bool subghz_test_static_input(InputEvent* event, void* context) {
void subghz_test_static_enter(void* context) {
furi_assert(context);
SubghzTestStatic* instance = context;
SubGhzTestStatic* instance = context;
furi_hal_subghz_reset();
furi_hal_subghz_load_preset(FuriHalSubGhzPresetOok650Async);
hal_gpio_init(&gpio_cc1101_g0, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
hal_gpio_write(&gpio_cc1101_g0, false);
instance->satus_tx = SubghzTestStaticStatusIDLE;
instance->satus_tx = SubGhzTestStaticStatusIDLE;
with_view_model(
instance->view, (SubghzTestStaticModel * model) {
instance->view, (SubGhzTestStaticModel * model) {
model->frequency = subghz_frequencies_433_92_testing;
model->real_frequency = subghz_frequencies_testing[model->frequency];
model->button = 0;
@@ -160,31 +160,31 @@ void subghz_test_static_exit(void* context) {
furi_hal_subghz_sleep();
}
SubghzTestStatic* subghz_test_static_alloc() {
SubghzTestStatic* instance = malloc(sizeof(SubghzTestStatic));
SubGhzTestStatic* subghz_test_static_alloc() {
SubGhzTestStatic* instance = malloc(sizeof(SubGhzTestStatic));
// View allocation and configuration
instance->view = view_alloc();
view_allocate_model(instance->view, ViewModelTypeLocking, sizeof(SubghzTestStaticModel));
view_allocate_model(instance->view, ViewModelTypeLocking, sizeof(SubGhzTestStaticModel));
view_set_context(instance->view, instance);
view_set_draw_callback(instance->view, (ViewDrawCallback)subghz_test_static_draw);
view_set_input_callback(instance->view, subghz_test_static_input);
view_set_enter_callback(instance->view, subghz_test_static_enter);
view_set_exit_callback(instance->view, subghz_test_static_exit);
instance->encoder = subghz_encoder_princeton_alloc();
instance->encoder = subghz_encoder_princeton_for_testing_alloc();
return instance;
}
void subghz_test_static_free(SubghzTestStatic* instance) {
void subghz_test_static_free(SubGhzTestStatic* instance) {
furi_assert(instance);
subghz_encoder_princeton_free(instance->encoder);
subghz_encoder_princeton_for_testing_free(instance->encoder);
view_free(instance->view);
free(instance);
}
View* subghz_test_static_get_view(SubghzTestStatic* instance) {
View* subghz_test_static_get_view(SubGhzTestStatic* instance) {
furi_assert(instance);
return instance->view;
}

18
applications/subghz/views/subghz_test_static.h
View File

@@ -3,20 +3,20 @@
#include <gui/view.h>
typedef enum {
SubghzTestStaticEventOnlyRx,
} SubghzTestStaticEvent;
SubGhzTestStaticEventOnlyRx,
} SubGhzTestStaticEvent;
typedef struct SubghzTestStatic SubghzTestStatic;
typedef struct SubGhzTestStatic SubGhzTestStatic;
typedef void (*SubghzTestStaticCallback)(SubghzTestStaticEvent event, void* context);
typedef void (*SubGhzTestStaticCallback)(SubGhzTestStaticEvent event, void* context);
void subghz_test_static_set_callback(
SubghzTestStatic* subghz_test_static,
SubghzTestStaticCallback callback,
SubGhzTestStatic* subghz_test_static,
SubGhzTestStaticCallback callback,
void* context);
SubghzTestStatic* subghz_test_static_alloc();
SubGhzTestStatic* subghz_test_static_alloc();
void subghz_test_static_free(SubghzTestStatic* subghz_static);
void subghz_test_static_free(SubGhzTestStatic* subghz_static);
View* subghz_test_static_get_view(SubghzTestStatic* subghz_static);
View* subghz_test_static_get_view(SubGhzTestStatic* subghz_static);

26
applications/subghz/views/subghz_transmitter.h
View File

@@ -1,26 +0,0 @@
#pragma once
#include <gui/view.h>
#include "../helpers/subghz_custom_event.h"
typedef struct SubghzTransmitter SubghzTransmitter;
typedef void (*SubghzTransmitterCallback)(SubghzCustomEvent event, void* context);
void subghz_transmitter_set_callback(
SubghzTransmitter* subghz_transmitter,
SubghzTransmitterCallback callback,
void* context);
SubghzTransmitter* subghz_transmitter_alloc();
void subghz_transmitter_free(SubghzTransmitter* subghz_transmitter);
View* subghz_transmitter_get_view(SubghzTransmitter* subghz_transmitter);
void subghz_transmitter_add_data_to_show(
SubghzTransmitter* subghz_transmitter,
const char* key_str,
const char* frequency_str,
const char* preset_str,
uint8_t show_button);

67
applications/subghz/views/subghz_transmitter.c → applications/subghz/views/transmitter.c
View File

@@ -1,12 +1,12 @@
#include "subghz_transmitter.h"
#include "transmitter.h"
#include "../subghz_i.h"
#include <input/input.h>
#include <gui/elements.h>
struct SubghzTransmitter {
struct SubGhzViewTransmitter {
View* view;
SubghzTransmitterCallback callback;
SubGhzViewTransmitterCallback callback;
void* context;
};
@@ -15,11 +15,11 @@ typedef struct {
string_t preset_str;
string_t key_str;
uint8_t show_button;
} SubghzTransmitterModel;
} SubGhzViewTransmitterModel;
void subghz_transmitter_set_callback(
SubghzTransmitter* subghz_transmitter,
SubghzTransmitterCallback callback,
void subghz_view_transmitter_set_callback(
SubGhzViewTransmitter* subghz_transmitter,
SubGhzViewTransmitterCallback callback,
void* context) {
furi_assert(subghz_transmitter);
@@ -27,15 +27,15 @@ void subghz_transmitter_set_callback(
subghz_transmitter->context = context;
}
void subghz_transmitter_add_data_to_show(
SubghzTransmitter* subghz_transmitter,
void subghz_view_transmitter_add_data_to_show(
SubGhzViewTransmitter* subghz_transmitter,
const char* key_str,
const char* frequency_str,
const char* preset_str,
uint8_t show_button) {
furi_assert(subghz_transmitter);
with_view_model(
subghz_transmitter->view, (SubghzTransmitterModel * model) {
subghz_transmitter->view, (SubGhzViewTransmitterModel * model) {
string_set(model->key_str, key_str);
string_set(model->frequency_str, frequency_str);
string_set(model->preset_str, preset_str);
@@ -44,7 +44,7 @@ void subghz_transmitter_add_data_to_show(
});
}
static void subghz_transmitter_button_right(Canvas* canvas, const char* str) {
static void subghz_view_transmitter_button_right(Canvas* canvas, const char* str) {
const uint8_t button_height = 13;
const uint8_t vertical_offset = 3;
const uint8_t horizontal_offset = 1;
@@ -75,24 +75,24 @@ static void subghz_transmitter_button_right(Canvas* canvas, const char* str) {
canvas_invert_color(canvas);
}
void subghz_transmitter_draw(Canvas* canvas, SubghzTransmitterModel* model) {
void subghz_view_transmitter_draw(Canvas* canvas, SubGhzViewTransmitterModel* model) {
canvas_clear(canvas);
canvas_set_color(canvas, ColorBlack);
canvas_set_font(canvas, FontSecondary);
elements_multiline_text(canvas, 0, 8, string_get_cstr(model->key_str));
canvas_draw_str(canvas, 78, 8, string_get_cstr(model->frequency_str));
canvas_draw_str(canvas, 113, 8, string_get_cstr(model->preset_str));
if(model->show_button) subghz_transmitter_button_right(canvas, "Send");
if(model->show_button) subghz_view_transmitter_button_right(canvas, "Send");
}
bool subghz_transmitter_input(InputEvent* event, void* context) {
bool subghz_view_transmitter_input(InputEvent* event, void* context) {
furi_assert(context);
SubghzTransmitter* subghz_transmitter = context;
SubGhzViewTransmitter* subghz_transmitter = context;
bool can_be_sent = false;
if(event->key == InputKeyBack && event->type == InputTypeShort) {
with_view_model(
subghz_transmitter->view, (SubghzTransmitterModel * model) {
subghz_transmitter->view, (SubGhzViewTransmitterModel * model) {
string_reset(model->frequency_str);
string_reset(model->preset_str);
string_reset(model->key_str);
@@ -103,7 +103,7 @@ bool subghz_transmitter_input(InputEvent* event, void* context) {
}
with_view_model(
subghz_transmitter->view, (SubghzTransmitterModel * model) {
subghz_transmitter->view, (SubGhzViewTransmitterModel * model) {
if(model->show_button) {
can_be_sent = true;
}
@@ -112,42 +112,41 @@ bool subghz_transmitter_input(InputEvent* event, void* context) {
if(can_be_sent && event->key == InputKeyOk && event->type == InputTypePress) {
subghz_transmitter->callback(
SubghzCustomEventViewTransmitterSendStart, subghz_transmitter->context);
SubGhzCustomEventViewTransmitterSendStart, subghz_transmitter->context);
return true;
} else if(can_be_sent && event->key == InputKeyOk && event->type == InputTypeRelease) {
subghz_transmitter->callback(
SubghzCustomEventViewTransmitterSendStop, subghz_transmitter->context);
SubGhzCustomEventViewTransmitterSendStop, subghz_transmitter->context);
return true;
}
return true;
}
void subghz_transmitter_enter(void* context) {
void subghz_view_transmitter_enter(void* context) {
furi_assert(context);
// SubghzTransmitter* subghz_transmitter = context;
}
void subghz_transmitter_exit(void* context) {
void subghz_view_transmitter_exit(void* context) {
furi_assert(context);
// SubghzTransmitter* subghz_transmitter = context;
}
SubghzTransmitter* subghz_transmitter_alloc() {
SubghzTransmitter* subghz_transmitter = malloc(sizeof(SubghzTransmitter));
SubGhzViewTransmitter* subghz_view_transmitter_alloc() {
SubGhzViewTransmitter* subghz_transmitter = malloc(sizeof(SubGhzViewTransmitter));
// View allocation and configuration
subghz_transmitter->view = view_alloc();
view_allocate_model(
subghz_transmitter->view, ViewModelTypeLocking, sizeof(SubghzTransmitterModel));
subghz_transmitter->view, ViewModelTypeLocking, sizeof(SubGhzViewTransmitterModel));
view_set_context(subghz_transmitter->view, subghz_transmitter);
view_set_draw_callback(subghz_transmitter->view, (ViewDrawCallback)subghz_transmitter_draw);
view_set_input_callback(subghz_transmitter->view, subghz_transmitter_input);
view_set_enter_callback(subghz_transmitter->view, subghz_transmitter_enter);
view_set_exit_callback(subghz_transmitter->view, subghz_transmitter_exit);
view_set_draw_callback(
subghz_transmitter->view, (ViewDrawCallback)subghz_view_transmitter_draw);
view_set_input_callback(subghz_transmitter->view, subghz_view_transmitter_input);
view_set_enter_callback(subghz_transmitter->view, subghz_view_transmitter_enter);
view_set_exit_callback(subghz_transmitter->view, subghz_view_transmitter_exit);
with_view_model(
subghz_transmitter->view, (SubghzTransmitterModel * model) {
subghz_transmitter->view, (SubGhzViewTransmitterModel * model) {
string_init(model->frequency_str);
string_init(model->preset_str);
string_init(model->key_str);
@@ -156,11 +155,11 @@ SubghzTransmitter* subghz_transmitter_alloc() {
return subghz_transmitter;
}
void subghz_transmitter_free(SubghzTransmitter* subghz_transmitter) {
void subghz_view_transmitter_free(SubGhzViewTransmitter* subghz_transmitter) {
furi_assert(subghz_transmitter);
with_view_model(
subghz_transmitter->view, (SubghzTransmitterModel * model) {
subghz_transmitter->view, (SubGhzViewTransmitterModel * model) {
string_clear(model->frequency_str);
string_clear(model->preset_str);
string_clear(model->key_str);
@@ -170,7 +169,7 @@ void subghz_transmitter_free(SubghzTransmitter* subghz_transmitter) {
free(subghz_transmitter);
}
View* subghz_transmitter_get_view(SubghzTransmitter* subghz_transmitter) {
View* subghz_view_transmitter_get_view(SubGhzViewTransmitter* subghz_transmitter) {
furi_assert(subghz_transmitter);
return subghz_transmitter->view;
}

26
applications/subghz/views/transmitter.h Normal file
View File

@@ -0,0 +1,26 @@
#pragma once
#include <gui/view.h>
#include "../helpers/subghz_custom_event.h"
typedef struct SubGhzViewTransmitter SubGhzViewTransmitter;
typedef void (*SubGhzViewTransmitterCallback)(SubGhzCustomEvent event, void* context);
void subghz_view_transmitter_set_callback(
SubGhzViewTransmitter* subghz_transmitter,
SubGhzViewTransmitterCallback callback,
void* context);
SubGhzViewTransmitter* subghz_view_transmitter_alloc();
void subghz_view_transmitter_free(SubGhzViewTransmitter* subghz_transmitter);
View* subghz_view_transmitter_get_view(SubGhzViewTransmitter* subghz_transmitter);
void subghz_view_transmitter_add_data_to_show(
SubGhzViewTransmitter* subghz_transmitter,
const char* key_str,
const char* frequency_str,
const char* preset_str,
uint8_t show_button);