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

[FL-3401, FL-3402] SubGhz: add "SubGhz test" external application and the ability to work "SubGhz" as an external application (#2851)

Browse Source 
* [FL-3401] SubGhz:  add "SubGhz test" external application
* SubGhz: delete test test functionality from SubGhz app
* [FL-3402] SubGhz: move func protocol creation API

Co-authored-by: あく <alleteam@gmail.com>
This commit is contained in:
Skorpionm
2023-07-07 00:15:03 +09:00
committed by GitHub
co-authored by あく
parent d8500510be
commit cef59887ed
40 changed files with 1070 additions and 222 deletions
Download Patch File Download Diff File Expand all files Collapse all files
applications/main/subghz/helpers/subghz_testing.c
-38
View File
@@ -1,38 +0,0 @@
#include "subghz_testing.h"
const uint32_t subghz_frequencies_testing[] = {
/* 300 - 348 */
300000000,
304500000,
310000000,
312025000,
313250000,
313625000,
315000000,
315225000,
321950000,
348000000,
/* 387 - 464 */
387000000,
433075000, /* LPD433 first */
433825000,
433920000, /* LPD433 mid */
434420000,
434775000, /* LPD433 last channels */
438900000,
464000000,
/* 779 - 928 */
779000000,
868150000,
868350000,
868550000,
915000000,
925000000,
926500000,
927950000,
928000000,
};
const uint32_t subghz_frequencies_count_testing =
sizeof(subghz_frequencies_testing) / sizeof(uint32_t);
const uint32_t subghz_frequencies_433_92_testing = 13;
applications/main/subghz/helpers/subghz_testing.h
-6
View File
@@ -1,6 +0,0 @@
#pragma once
#include "../subghz_i.h"
extern const uint32_t subghz_frequencies_testing[];
extern const uint32_t subghz_frequencies_count_testing;
extern const uint32_t subghz_frequencies_433_92_testing;
applications/main/subghz/helpers/subghz_types.h
-3
View File
@@ -80,9 +80,6 @@ typedef enum {
SubGhzViewIdFrequencyAnalyzer,
SubGhzViewIdReadRAW,
SubGhzViewIdStatic,
SubGhzViewIdTestCarrier,
SubGhzViewIdTestPacket,
} SubGhzViewId;
/** SubGhz load type file */
applications/main/subghz/scenes/subghz_scene_config.h
-4
View File
@@ -12,10 +12,6 @@ ADD_SCENE(subghz, show_only_rx, ShowOnlyRx)
ADD_SCENE(subghz, saved_menu, SavedMenu)
ADD_SCENE(subghz, delete, Delete)
ADD_SCENE(subghz, delete_success, DeleteSuccess)
ADD_SCENE(subghz, test, Test)
ADD_SCENE(subghz, test_static, TestStatic)
ADD_SCENE(subghz, test_carrier, TestCarrier)
ADD_SCENE(subghz, test_packet, TestPacket)
ADD_SCENE(subghz, set_type, SetType)
ADD_SCENE(subghz, frequency_analyzer, FrequencyAnalyzer)
ADD_SCENE(subghz, read_raw, ReadRAW)
applications/main/subghz/scenes/subghz_scene_start.c
-10
View File
@@ -4,7 +4,6 @@
enum SubmenuIndex {
SubmenuIndexRead = 10,
SubmenuIndexSaved,
SubmenuIndexTest,
SubmenuIndexAddManually,
SubmenuIndexFrequencyAnalyzer,
SubmenuIndexReadRAW,
@@ -56,10 +55,6 @@ void subghz_scene_start_on_enter(void* context) {
SubmenuIndexRadioSetting,
subghz_scene_start_submenu_callback,
subghz);
if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagDebug)) {
submenu_add_item(
subghz->submenu, "Test", SubmenuIndexTest, subghz_scene_start_submenu_callback, subghz);
}
submenu_set_selected_item(
subghz->submenu, scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneStart));
@@ -101,11 +96,6 @@ bool subghz_scene_start_on_event(void* context, SceneManagerEvent event) {
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneFrequencyAnalyzer);
dolphin_deed(DolphinDeedSubGhzFrequencyAnalyzer);
return true;
} else if(event.event == SubmenuIndexTest) {
scene_manager_set_scene_state(
subghz->scene_manager, SubGhzSceneStart, SubmenuIndexTest);
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneTest);
return true;
} else if(event.event == SubmenuIndexShowRegionInfo) {
scene_manager_set_scene_state(
subghz->scene_manager, SubGhzSceneStart, SubmenuIndexShowRegionInfo);
applications/main/subghz/scenes/subghz_scene_test.c
-61
View File
@@ -1,61 +0,0 @@
#include "../subghz_i.h"
enum SubmenuIndex {
SubmenuIndexCarrier,
SubmenuIndexPacket,
SubmenuIndexStatic,
};
void subghz_scene_test_submenu_callback(void* context, uint32_t index) {
SubGhz* subghz = context;
view_dispatcher_send_custom_event(subghz->view_dispatcher, index);
}
void subghz_scene_test_on_enter(void* context) {
SubGhz* subghz = context;
submenu_add_item(
subghz->submenu,
"Carrier",
SubmenuIndexCarrier,
subghz_scene_test_submenu_callback,
subghz);
submenu_add_item(
subghz->submenu, "Packet", SubmenuIndexPacket, subghz_scene_test_submenu_callback, subghz);
submenu_add_item(
subghz->submenu, "Static", SubmenuIndexStatic, subghz_scene_test_submenu_callback, subghz);
submenu_set_selected_item(
subghz->submenu, scene_manager_get_scene_state(subghz->scene_manager, SubGhzSceneTest));
view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdMenu);
}
bool subghz_scene_test_on_event(void* context, SceneManagerEvent event) {
SubGhz* subghz = context;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == SubmenuIndexCarrier) {
scene_manager_set_scene_state(
subghz->scene_manager, SubGhzSceneTest, SubmenuIndexCarrier);
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneTestCarrier);
return true;
} else if(event.event == SubmenuIndexPacket) {
scene_manager_set_scene_state(
subghz->scene_manager, SubGhzSceneTest, SubmenuIndexPacket);
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneTestPacket);
return true;
} else if(event.event == SubmenuIndexStatic) {
scene_manager_set_scene_state(
subghz->scene_manager, SubGhzSceneTest, SubmenuIndexStatic);
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneTestStatic);
return true;
}
}
return false;
}
void subghz_scene_test_on_exit(void* context) {
SubGhz* subghz = context;
submenu_reset(subghz->submenu);
}
applications/main/subghz/scenes/subghz_scene_test_carrier.c
-30
View File
@@ -1,30 +0,0 @@
#include "../subghz_i.h"
#include "../views/subghz_test_carrier.h"
void subghz_scene_test_carrier_callback(SubGhzTestCarrierEvent event, void* context) {
furi_assert(context);
SubGhz* subghz = context;
view_dispatcher_send_custom_event(subghz->view_dispatcher, event);
}
void subghz_scene_test_carrier_on_enter(void* context) {
SubGhz* subghz = context;
subghz_test_carrier_set_callback(
subghz->subghz_test_carrier, subghz_scene_test_carrier_callback, subghz);
view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdTestCarrier);
}
bool subghz_scene_test_carrier_on_event(void* context, SceneManagerEvent event) {
SubGhz* subghz = context;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == SubGhzTestCarrierEventOnlyRx) {
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowOnlyRx);
return true;
}
}
return false;
}
void subghz_scene_test_carrier_on_exit(void* context) {
UNUSED(context);
}
applications/main/subghz/scenes/subghz_scene_test_packet.c
-30
View File
@@ -1,30 +0,0 @@
#include "../subghz_i.h"
#include "../views/subghz_test_packet.h"
void subghz_scene_test_packet_callback(SubGhzTestPacketEvent event, void* context) {
furi_assert(context);
SubGhz* subghz = context;
view_dispatcher_send_custom_event(subghz->view_dispatcher, event);
}
void subghz_scene_test_packet_on_enter(void* context) {
SubGhz* subghz = context;
subghz_test_packet_set_callback(
subghz->subghz_test_packet, subghz_scene_test_packet_callback, subghz);
view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdTestPacket);
}
bool subghz_scene_test_packet_on_event(void* context, SceneManagerEvent event) {
SubGhz* subghz = context;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == SubGhzTestPacketEventOnlyRx) {
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowOnlyRx);
return true;
}
}
return false;
}
void subghz_scene_test_packet_on_exit(void* context) {
UNUSED(context);
}
applications/main/subghz/scenes/subghz_scene_test_static.c
-30
View File
@@ -1,30 +0,0 @@
#include "../subghz_i.h"
#include "../views/subghz_test_static.h"
void subghz_scene_test_static_callback(SubGhzTestStaticEvent event, void* context) {
furi_assert(context);
SubGhz* subghz = context;
view_dispatcher_send_custom_event(subghz->view_dispatcher, event);
}
void subghz_scene_test_static_on_enter(void* context) {
SubGhz* subghz = context;
subghz_test_static_set_callback(
subghz->subghz_test_static, subghz_scene_test_static_callback, subghz);
view_dispatcher_switch_to_view(subghz->view_dispatcher, SubGhzViewIdStatic);
}
bool subghz_scene_test_static_on_event(void* context, SceneManagerEvent event) {
SubGhz* subghz = context;
if(event.type == SceneManagerEventTypeCustom) {
if(event.event == SubGhzTestStaticEventOnlyRx) {
scene_manager_next_scene(subghz->scene_manager, SubGhzSceneShowOnlyRx);
return true;
}
}
return false;
}
void subghz_scene_test_static_on_exit(void* context) {
UNUSED(context);
}
applications/main/subghz/subghz.c
-33
View File
@@ -129,27 +129,6 @@ SubGhz* subghz_alloc() {
SubGhzViewIdReadRAW,
subghz_read_raw_get_view(subghz->subghz_read_raw));
// Carrier Test Module
subghz->subghz_test_carrier = subghz_test_carrier_alloc();
view_dispatcher_add_view(
subghz->view_dispatcher,
SubGhzViewIdTestCarrier,
subghz_test_carrier_get_view(subghz->subghz_test_carrier));
// Packet Test
subghz->subghz_test_packet = subghz_test_packet_alloc();
view_dispatcher_add_view(
subghz->view_dispatcher,
SubGhzViewIdTestPacket,
subghz_test_packet_get_view(subghz->subghz_test_packet));
// Static send
subghz->subghz_test_static = subghz_test_static_alloc();
view_dispatcher_add_view(
subghz->view_dispatcher,
SubGhzViewIdStatic,
subghz_test_static_get_view(subghz->subghz_test_static));
//init threshold rssi
subghz->threshold_rssi = subghz_threshold_rssi_alloc();
@@ -183,18 +162,6 @@ void subghz_free(SubGhz* subghz) {
subghz_txrx_stop(subghz->txrx);
subghz_txrx_sleep(subghz->txrx);
// Packet Test
view_dispatcher_remove_view(subghz->view_dispatcher, SubGhzViewIdTestPacket);
subghz_test_packet_free(subghz->subghz_test_packet);
// Carrier Test
view_dispatcher_remove_view(subghz->view_dispatcher, SubGhzViewIdTestCarrier);
subghz_test_carrier_free(subghz->subghz_test_carrier);
// Static
view_dispatcher_remove_view(subghz->view_dispatcher, SubGhzViewIdStatic);
subghz_test_static_free(subghz->subghz_test_static);
// Receiver
view_dispatcher_remove_view(subghz->view_dispatcher, SubGhzViewIdReceiver);
subghz_view_receiver_free(subghz->subghz_receiver);
applications/main/subghz/subghz_i.h
-7
View File
@@ -9,10 +9,6 @@
#include "views/subghz_frequency_analyzer.h"
#include "views/subghz_read_raw.h"
#include "views/subghz_test_static.h"
#include "views/subghz_test_carrier.h"
#include "views/subghz_test_packet.h"
#include <gui/gui.h>
#include <assets_icons.h>
#include <dialogs/dialogs.h>
@@ -64,9 +60,6 @@ struct SubGhz {
SubGhzFrequencyAnalyzer* subghz_frequency_analyzer;
SubGhzReadRAW* subghz_read_raw;
SubGhzTestStatic* subghz_test_static;
SubGhzTestCarrier* subghz_test_carrier;
SubGhzTestPacket* subghz_test_packet;
SubGhzProtocolFlag filter;
FuriString* error_str;
applications/main/subghz/views/subghz_test_carrier.c
-218
View File
@@ -1,218 +0,0 @@
#include "subghz_test_carrier.h"
#include "../subghz_i.h"
#include "../helpers/subghz_testing.h"
#include <lib/subghz/devices/cc1101_configs.h>
#include <math.h>
#include <furi.h>
#include <furi_hal.h>
#include <input/input.h>
struct SubGhzTestCarrier {
View* view;
FuriTimer* timer;
SubGhzTestCarrierCallback callback;
void* context;
};
typedef enum {
SubGhzTestCarrierModelStatusRx,
SubGhzTestCarrierModelStatusTx,
} SubGhzTestCarrierModelStatus;
typedef struct {
uint8_t frequency;
uint32_t real_frequency;
FuriHalSubGhzPath path;
float rssi;
SubGhzTestCarrierModelStatus status;
} SubGhzTestCarrierModel;
void subghz_test_carrier_set_callback(
SubGhzTestCarrier* subghz_test_carrier,
SubGhzTestCarrierCallback callback,
void* context) {
furi_assert(subghz_test_carrier);
furi_assert(callback);
subghz_test_carrier->callback = callback;
subghz_test_carrier->context = context;
}
void subghz_test_carrier_draw(Canvas* canvas, SubGhzTestCarrierModel* model) {
char buffer[64];
canvas_set_color(canvas, ColorBlack);
canvas_set_font(canvas, FontPrimary);
canvas_draw_str(canvas, 0, 8, "CC1101 Basic Test");
canvas_set_font(canvas, FontSecondary);
// Frequency
snprintf(
buffer,
sizeof(buffer),
"Freq: %03ld.%03ld.%03ld Hz",
model->real_frequency / 1000000 % 1000,
model->real_frequency / 1000 % 1000,
model->real_frequency % 1000);
canvas_draw_str(canvas, 0, 20, buffer);
// Path
char* path_name = "Unknown";
if(model->path == FuriHalSubGhzPathIsolate) {
path_name = "isolate";
} else if(model->path == FuriHalSubGhzPath433) {
path_name = "433MHz";
} else if(model->path == FuriHalSubGhzPath315) {
path_name = "315MHz";
} else if(model->path == FuriHalSubGhzPath868) {
path_name = "868MHz";
}
snprintf(buffer, sizeof(buffer), "Path: %d - %s", model->path, path_name);
canvas_draw_str(canvas, 0, 31, buffer);
if(model->status == SubGhzTestCarrierModelStatusRx) {
snprintf(
buffer,
sizeof(buffer),
"RSSI: %ld.%ld dBm",
(int32_t)(model->rssi),
(int32_t)fabs(model->rssi * 10) % 10);
canvas_draw_str(canvas, 0, 42, buffer);
} else {
canvas_draw_str(canvas, 0, 42, "TX");
}
}
bool subghz_test_carrier_input(InputEvent* event, void* context) {
furi_assert(context);
SubGhzTestCarrier* subghz_test_carrier = context;
if(event->key == InputKeyBack || event->type != InputTypeShort) {
return false;
}
with_view_model(
subghz_test_carrier->view,
SubGhzTestCarrierModel * model,
{
furi_hal_subghz_idle();
if(event->key == InputKeyLeft) {
if(model->frequency > 0) model->frequency--;
} else if(event->key == InputKeyRight) {
if(model->frequency < subghz_frequencies_count_testing - 1) model->frequency++;
} else if(event->key == InputKeyDown) {
if(model->path > 0) model->path--;
} else if(event->key == InputKeyUp) {
if(model->path < FuriHalSubGhzPath868) model->path++;
} else if(event->key == InputKeyOk) {
if(model->status == SubGhzTestCarrierModelStatusTx) {
model->status = SubGhzTestCarrierModelStatusRx;
} else {
model->status = SubGhzTestCarrierModelStatusTx;
}
}
model->real_frequency =
furi_hal_subghz_set_frequency(subghz_frequencies_testing[model->frequency]);
furi_hal_subghz_set_path(model->path);
if(model->status == SubGhzTestCarrierModelStatusRx) {
furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeInput, GpioPullNo, GpioSpeedLow);
furi_hal_subghz_rx();
} else {
furi_hal_gpio_init(
&gpio_cc1101_g0, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
furi_hal_gpio_write(&gpio_cc1101_g0, true);
if(!furi_hal_subghz_tx()) {
furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeInput, GpioPullNo, GpioSpeedLow);
subghz_test_carrier->callback(
SubGhzTestCarrierEventOnlyRx, subghz_test_carrier->context);
}
}
},
true);
return true;
}
void subghz_test_carrier_enter(void* context) {
furi_assert(context);
SubGhzTestCarrier* subghz_test_carrier = context;
furi_hal_subghz_reset();
furi_hal_subghz_load_custom_preset(subghz_device_cc1101_preset_ook_650khz_async_regs);
furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeInput, GpioPullNo, GpioSpeedLow);
with_view_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;
},
true);
furi_hal_subghz_rx();
furi_timer_start(subghz_test_carrier->timer, furi_kernel_get_tick_frequency() / 4);
}
void subghz_test_carrier_exit(void* context) {
furi_assert(context);
SubGhzTestCarrier* subghz_test_carrier = context;
furi_timer_stop(subghz_test_carrier->timer);
// Reinitialize IC to default state
furi_hal_subghz_sleep();
}
void subghz_test_carrier_rssi_timer_callback(void* context) {
furi_assert(context);
SubGhzTestCarrier* subghz_test_carrier = context;
with_view_model(
subghz_test_carrier->view,
SubGhzTestCarrierModel * model,
{
if(model->status == SubGhzTestCarrierModelStatusRx) {
model->rssi = furi_hal_subghz_get_rssi();
}
},
false);
}
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));
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);
view_set_enter_callback(subghz_test_carrier->view, subghz_test_carrier_enter);
view_set_exit_callback(subghz_test_carrier->view, subghz_test_carrier_exit);
subghz_test_carrier->timer = furi_timer_alloc(
subghz_test_carrier_rssi_timer_callback, FuriTimerTypePeriodic, subghz_test_carrier);
return subghz_test_carrier;
}
void subghz_test_carrier_free(SubGhzTestCarrier* subghz_test_carrier) {
furi_assert(subghz_test_carrier);
furi_timer_free(subghz_test_carrier->timer);
view_free(subghz_test_carrier->view);
free(subghz_test_carrier);
}
View* subghz_test_carrier_get_view(SubGhzTestCarrier* subghz_test_carrier) {
furi_assert(subghz_test_carrier);
return subghz_test_carrier->view;
}
applications/main/subghz/views/subghz_test_carrier.h
-22
View File
@@ -1,22 +0,0 @@
#pragma once
#include <gui/view.h>
typedef enum {
SubGhzTestCarrierEventOnlyRx,
} SubGhzTestCarrierEvent;
typedef struct SubGhzTestCarrier SubGhzTestCarrier;
typedef void (*SubGhzTestCarrierCallback)(SubGhzTestCarrierEvent event, void* context);
void subghz_test_carrier_set_callback(
SubGhzTestCarrier* subghz_test_carrier,
SubGhzTestCarrierCallback callback,
void* context);
SubGhzTestCarrier* subghz_test_carrier_alloc();
void subghz_test_carrier_free(SubGhzTestCarrier* subghz_test_carrier);
View* subghz_test_carrier_get_view(SubGhzTestCarrier* subghz_test_carrier);
applications/main/subghz/views/subghz_test_packet.c
-277
View File
@@ -1,277 +0,0 @@
#include "subghz_test_packet.h"
#include "../subghz_i.h"
#include "../helpers/subghz_testing.h"
#include <lib/subghz/devices/cc1101_configs.h>
#include <math.h>
#include <furi.h>
#include <furi_hal.h>
#include <input/input.h>
#include <toolbox/level_duration.h>
#include <lib/subghz/protocols/princeton_for_testing.h>
#define SUBGHZ_TEST_PACKET_COUNT 500
struct SubGhzTestPacket {
View* view;
FuriTimer* timer;
SubGhzDecoderPrinceton* decoder;
SubGhzEncoderPrinceton* encoder;
volatile size_t packet_rx;
SubGhzTestPacketCallback callback;
void* context;
};
typedef enum {
SubGhzTestPacketModelStatusRx,
SubGhzTestPacketModelStatusOnlyRx,
SubGhzTestPacketModelStatusTx,
} SubGhzTestPacketModelStatus;
typedef struct {
uint8_t frequency;
uint32_t real_frequency;
FuriHalSubGhzPath path;
float rssi;
size_t packets;
SubGhzTestPacketModelStatus status;
} SubGhzTestPacketModel;
volatile bool subghz_test_packet_overrun = false;
void subghz_test_packet_set_callback(
SubGhzTestPacket* subghz_test_packet,
SubGhzTestPacketCallback callback,
void* context) {
furi_assert(subghz_test_packet);
furi_assert(callback);
subghz_test_packet->callback = callback;
subghz_test_packet->context = context;
}
static void subghz_test_packet_rx_callback(bool level, uint32_t duration, void* context) {
furi_assert(context);
SubGhzTestPacket* instance = context;
subghz_decoder_princeton_for_testing_parse(instance->decoder, level, duration);
}
//todo
static void subghz_test_packet_rx_pt_callback(SubGhzDecoderPrinceton* parser, void* context) {
UNUSED(parser);
furi_assert(context);
SubGhzTestPacket* instance = context;
instance->packet_rx++;
}
static void subghz_test_packet_rssi_timer_callback(void* context) {
furi_assert(context);
SubGhzTestPacket* instance = context;
with_view_model(
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_for_testing_get_repeat_left(instance->encoder);
}
},
true);
}
static void subghz_test_packet_draw(Canvas* canvas, SubGhzTestPacketModel* model) {
char buffer[64];
canvas_set_color(canvas, ColorBlack);
canvas_set_font(canvas, FontPrimary);
canvas_draw_str(canvas, 0, 8, "CC1101 Packet Test");
canvas_set_font(canvas, FontSecondary);
// Frequency
snprintf(
buffer,
sizeof(buffer),
"Freq: %03ld.%03ld.%03ld Hz",
model->real_frequency / 1000000 % 1000,
model->real_frequency / 1000 % 1000,
model->real_frequency % 1000);
canvas_draw_str(canvas, 0, 20, buffer);
// Path
char* path_name = "Unknown";
if(model->path == FuriHalSubGhzPathIsolate) {
path_name = "isolate";
} else if(model->path == FuriHalSubGhzPath433) {
path_name = "433MHz";
} else if(model->path == FuriHalSubGhzPath315) {
path_name = "315MHz";
} else if(model->path == FuriHalSubGhzPath868) {
path_name = "868MHz";
}
snprintf(buffer, sizeof(buffer), "Path: %d - %s", model->path, path_name);
canvas_draw_str(canvas, 0, 31, buffer);
snprintf(buffer, sizeof(buffer), "Packets: %zu", model->packets);
canvas_draw_str(canvas, 0, 42, buffer);
if(model->status == SubGhzTestPacketModelStatusRx) {
snprintf(
buffer,
sizeof(buffer),
"RSSI: %ld.%ld dBm",
(int32_t)(model->rssi),
(int32_t)fabs(model->rssi * 10) % 10);
canvas_draw_str(canvas, 0, 53, buffer);
} else {
canvas_draw_str(canvas, 0, 53, "TX");
}
}
static bool subghz_test_packet_input(InputEvent* event, void* context) {
furi_assert(context);
SubGhzTestPacket* instance = context;
if(event->key == InputKeyBack || event->type != InputTypeShort) {
return false;
}
with_view_model(
instance->view,
SubGhzTestPacketModel * model,
{
if(model->status == SubGhzTestPacketModelStatusRx) {
furi_hal_subghz_stop_async_rx();
} else if(model->status == SubGhzTestPacketModelStatusTx) {
subghz_encoder_princeton_for_testing_stop(instance->encoder, furi_get_tick());
furi_hal_subghz_stop_async_tx();
}
if(event->key == InputKeyLeft) {
if(model->frequency > 0) model->frequency--;
} else if(event->key == InputKeyRight) {
if(model->frequency < subghz_frequencies_count_testing - 1) model->frequency++;
} else if(event->key == InputKeyDown) {
if(model->path > 0) model->path--;
} else if(event->key == InputKeyUp) {
if(model->path < FuriHalSubGhzPath868) model->path++;
} else if(event->key == InputKeyOk) {
if(model->status == SubGhzTestPacketModelStatusRx) {
model->status = SubGhzTestPacketModelStatusTx;
} else {
model->status = SubGhzTestPacketModelStatusRx;
}
}
model->real_frequency =
furi_hal_subghz_set_frequency(subghz_frequencies_testing[model->frequency]);
furi_hal_subghz_set_path(model->path);
if(model->status == SubGhzTestPacketModelStatusRx) {
furi_hal_subghz_start_async_rx(subghz_test_packet_rx_callback, instance);
} else {
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_for_testing_yield, instance->encoder)) {
model->status = SubGhzTestPacketModelStatusOnlyRx;
instance->callback(SubGhzTestPacketEventOnlyRx, instance->context);
}
}
},
true);
return true;
}
void subghz_test_packet_enter(void* context) {
furi_assert(context);
SubGhzTestPacket* instance = context;
furi_hal_subghz_reset();
furi_hal_subghz_load_custom_preset(subghz_device_cc1101_preset_ook_650khz_async_regs);
with_view_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;
},
true);
furi_hal_subghz_start_async_rx(subghz_test_packet_rx_callback, instance);
furi_timer_start(instance->timer, furi_kernel_get_tick_frequency() / 4);
}
void subghz_test_packet_exit(void* context) {
furi_assert(context);
SubGhzTestPacket* instance = context;
furi_timer_stop(instance->timer);
// Reinitialize IC to default state
with_view_model(
instance->view,
SubGhzTestPacketModel * model,
{
if(model->status == SubGhzTestPacketModelStatusRx) {
furi_hal_subghz_stop_async_rx();
} else if(model->status == SubGhzTestPacketModelStatusTx) {
subghz_encoder_princeton_for_testing_stop(instance->encoder, furi_get_tick());
furi_hal_subghz_stop_async_tx();
}
},
true);
furi_hal_subghz_sleep();
}
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_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);
view_set_enter_callback(instance->view, subghz_test_packet_enter);
view_set_exit_callback(instance->view, subghz_test_packet_exit);
instance->timer =
furi_timer_alloc(subghz_test_packet_rssi_timer_callback, FuriTimerTypePeriodic, instance);
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) {
furi_assert(instance);
subghz_decoder_princeton_for_testing_free(instance->decoder);
subghz_encoder_princeton_for_testing_free(instance->encoder);
furi_timer_free(instance->timer);
view_free(instance->view);
free(instance);
}
View* subghz_test_packet_get_view(SubGhzTestPacket* instance) {
furi_assert(instance);
return instance->view;
}
applications/main/subghz/views/subghz_test_packet.h
-22
View File
@@ -1,22 +0,0 @@
#pragma once
#include <gui/view.h>
typedef enum {
SubGhzTestPacketEventOnlyRx,
} SubGhzTestPacketEvent;
typedef struct SubGhzTestPacket SubGhzTestPacket;
typedef void (*SubGhzTestPacketCallback)(SubGhzTestPacketEvent event, void* context);
void subghz_test_packet_set_callback(
SubGhzTestPacket* subghz_test_packet,
SubGhzTestPacketCallback callback,
void* context);
SubGhzTestPacket* subghz_test_packet_alloc();
void subghz_test_packet_free(SubGhzTestPacket* subghz_test_packet);
View* subghz_test_packet_get_view(SubGhzTestPacket* subghz_test_packet);
applications/main/subghz/views/subghz_test_static.c
-194
View File
@@ -1,194 +0,0 @@
#include "subghz_test_static.h"
#include "../subghz_i.h"
#include "../helpers/subghz_testing.h"
#include <lib/subghz/devices/cc1101_configs.h>
#include <math.h>
#include <furi.h>
#include <furi_hal.h>
#include <input/input.h>
#include <notification/notification_messages.h>
#include <lib/subghz/protocols/princeton_for_testing.h>
#define TAG "SubGhzTestStatic"
typedef enum {
SubGhzTestStaticStatusIDLE,
SubGhzTestStaticStatusTX,
} SubGhzTestStaticStatus;
static const uint32_t subghz_test_static_keys[] = {
0x0074BADE,
0x0074BADD,
0x0074BADB,
0x00E34A4E,
};
struct SubGhzTestStatic {
View* view;
SubGhzTestStaticStatus status_tx;
SubGhzEncoderPrinceton* encoder;
SubGhzTestStaticCallback callback;
void* context;
};
typedef struct {
uint8_t frequency;
uint32_t real_frequency;
uint8_t button;
} SubGhzTestStaticModel;
void subghz_test_static_set_callback(
SubGhzTestStatic* subghz_test_static,
SubGhzTestStaticCallback callback,
void* context) {
furi_assert(subghz_test_static);
furi_assert(callback);
subghz_test_static->callback = callback;
subghz_test_static->context = context;
}
void subghz_test_static_draw(Canvas* canvas, SubGhzTestStaticModel* model) {
char buffer[64];
canvas_set_color(canvas, ColorBlack);
canvas_set_font(canvas, FontPrimary);
canvas_draw_str(canvas, 0, 8, "CC1101 Static");
canvas_set_font(canvas, FontSecondary);
// Frequency
snprintf(
buffer,
sizeof(buffer),
"Freq: %03ld.%03ld.%03ld Hz",
model->real_frequency / 1000000 % 1000,
model->real_frequency / 1000 % 1000,
model->real_frequency % 1000);
canvas_draw_str(canvas, 0, 20, buffer);
snprintf(buffer, sizeof(buffer), "Key: %d", model->button);
canvas_draw_str(canvas, 0, 31, buffer);
}
bool subghz_test_static_input(InputEvent* event, void* context) {
furi_assert(context);
SubGhzTestStatic* instance = context;
if(event->key == InputKeyBack) {
return false;
}
with_view_model(
instance->view,
SubGhzTestStaticModel * model,
{
if(event->type == InputTypeShort) {
if(event->key == InputKeyLeft) {
if(model->frequency > 0) model->frequency--;
} else if(event->key == InputKeyRight) {
if(model->frequency < subghz_frequencies_count_testing - 1) model->frequency++;
} else if(event->key == InputKeyDown) {
if(model->button > 0) model->button--;
} else if(event->key == InputKeyUp) {
if(model->button < 3) model->button++;
}
}
model->real_frequency = subghz_frequencies_testing[model->frequency];
if(event->key == InputKeyOk) {
NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
if(event->type == InputTypePress) {
furi_hal_subghz_idle();
furi_hal_subghz_set_frequency_and_path(
subghz_frequencies_testing[model->frequency]);
if(!furi_hal_subghz_tx()) {
instance->callback(SubGhzTestStaticEventOnlyRx, instance->context);
} else {
notification_message_block(notification, &sequence_set_red_255);
FURI_LOG_I(TAG, "TX Start");
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_for_testing_yield, instance->encoder);
instance->status_tx = SubGhzTestStaticStatusTX;
}
} else if(event->type == InputTypeRelease) {
if(instance->status_tx == SubGhzTestStaticStatusTX) {
FURI_LOG_I(TAG, "TX Stop");
subghz_encoder_princeton_for_testing_stop(
instance->encoder, furi_get_tick());
subghz_encoder_princeton_for_testing_print_log(instance->encoder);
furi_hal_subghz_stop_async_tx();
notification_message(notification, &sequence_reset_red);
}
instance->status_tx = SubGhzTestStaticStatusIDLE;
}
furi_record_close(RECORD_NOTIFICATION);
}
},
true);
return true;
}
void subghz_test_static_enter(void* context) {
furi_assert(context);
SubGhzTestStatic* instance = context;
furi_hal_subghz_reset();
furi_hal_subghz_load_custom_preset(subghz_device_cc1101_preset_ook_650khz_async_regs);
furi_hal_gpio_init(&gpio_cc1101_g0, GpioModeOutputPushPull, GpioPullNo, GpioSpeedLow);
furi_hal_gpio_write(&gpio_cc1101_g0, false);
instance->status_tx = SubGhzTestStaticStatusIDLE;
with_view_model(
instance->view,
SubGhzTestStaticModel * model,
{
model->frequency = subghz_frequencies_433_92_testing;
model->real_frequency = subghz_frequencies_testing[model->frequency];
model->button = 0;
},
true);
}
void subghz_test_static_exit(void* context) {
furi_assert(context);
furi_hal_subghz_sleep();
}
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_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_for_testing_alloc();
return instance;
}
void subghz_test_static_free(SubGhzTestStatic* instance) {
furi_assert(instance);
subghz_encoder_princeton_for_testing_free(instance->encoder);
view_free(instance->view);
free(instance);
}
View* subghz_test_static_get_view(SubGhzTestStatic* instance) {
furi_assert(instance);
return instance->view;
}
applications/main/subghz/views/subghz_test_static.h
-22
View File
@@ -1,22 +0,0 @@
#pragma once
#include <gui/view.h>
typedef enum {
SubGhzTestStaticEventOnlyRx,
} SubGhzTestStaticEvent;
typedef struct SubGhzTestStatic SubGhzTestStatic;
typedef void (*SubGhzTestStaticCallback)(SubGhzTestStaticEvent event, void* context);
void subghz_test_static_set_callback(
SubGhzTestStatic* subghz_test_static,
SubGhzTestStaticCallback callback,
void* context);
SubGhzTestStatic* subghz_test_static_alloc();
void subghz_test_static_free(SubGhzTestStatic* subghz_static);
View* subghz_test_static_get_view(SubGhzTestStatic* subghz_static);