Skip to content

Commit

Permalink
Spectrum analyzer: new ext radio driver (#2)
Browse files Browse the repository at this point in the history 
* Sub Analyzer app: UPD to new driver
* Sub Analyzer: fix working on start
  • Loading branch information
@gid9798
gid9798 authored Jul 6, 2023
1 parent d208b69 commit cb08b84
Show file tree
Hide file tree
Showing 4 changed files with 153 additions and 41 deletions.
64 changes: 64 additions & 0 deletions applications/external/spectrum_analyzer/helpers/radio_device_loader.c
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,64 @@
#include "radio_device_loader.h"

#include <applications/drivers/subghz/cc1101_ext/cc1101_ext_interconnect.h>
#include <lib/subghz/devices/cc1101_int/cc1101_int_interconnect.h>

static void radio_device_loader_power_on() {
uint8_t attempts = 0;
while(!furi_hal_power_is_otg_enabled() && attempts++ < 5) {
furi_hal_power_enable_otg();
//CC1101 power-up time
furi_delay_ms(10);
}
}

static void radio_device_loader_power_off() {
if(furi_hal_power_is_otg_enabled()) furi_hal_power_disable_otg();
}

bool radio_device_loader_is_connect_external(const char* name) {
bool is_connect = false;
bool is_otg_enabled = furi_hal_power_is_otg_enabled();

if(!is_otg_enabled) {
radio_device_loader_power_on();
}

const SubGhzDevice* device = subghz_devices_get_by_name(name);
if(device) {
is_connect = subghz_devices_is_connect(device);
}

if(!is_otg_enabled) {
radio_device_loader_power_off();
}
return is_connect;
}

const SubGhzDevice* radio_device_loader_set(
const SubGhzDevice* current_radio_device,
SubGhzRadioDeviceType radio_device_type) {
const SubGhzDevice* radio_device;

if(radio_device_type == SubGhzRadioDeviceTypeExternalCC1101 &&
radio_device_loader_is_connect_external(SUBGHZ_DEVICE_CC1101_EXT_NAME)) {
radio_device_loader_power_on();
radio_device = subghz_devices_get_by_name(SUBGHZ_DEVICE_CC1101_EXT_NAME);
subghz_devices_begin(radio_device);
} else if(current_radio_device == NULL) {
radio_device = subghz_devices_get_by_name(SUBGHZ_DEVICE_CC1101_INT_NAME);
} else {
radio_device_loader_end(current_radio_device);
radio_device = subghz_devices_get_by_name(SUBGHZ_DEVICE_CC1101_INT_NAME);
}

return radio_device;
}

void radio_device_loader_end(const SubGhzDevice* radio_device) {
furi_assert(radio_device);
radio_device_loader_power_off();
if(radio_device != subghz_devices_get_by_name(SUBGHZ_DEVICE_CC1101_INT_NAME)) {
subghz_devices_end(radio_device);
}
}
15 changes: 15 additions & 0 deletions applications/external/spectrum_analyzer/helpers/radio_device_loader.h
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,15 @@
#pragma once

#include <lib/subghz/devices/devices.h>

/** SubGhzRadioDeviceType */
typedef enum {
SubGhzRadioDeviceTypeInternal,
SubGhzRadioDeviceTypeExternalCC1101,
} SubGhzRadioDeviceType;

const SubGhzDevice* radio_device_loader_set(
const SubGhzDevice* current_radio_device,
SubGhzRadioDeviceType radio_device_type);

void radio_device_loader_end(const SubGhzDevice* radio_device);
23 changes: 6 additions & 17 deletions applications/external/spectrum_analyzer/spectrum_analyzer.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -389,14 +389,6 @@ void spectrum_analyzer_free(SpectrumAnalyzer* instance) {

free(instance->model);
free(instance);

furi_hal_subghz_idle();
furi_hal_subghz_sleep();

// Disable power for External CC1101 if it was enabled and module is connected
furi_hal_subghz_disable_ext_power();
// Reinit SPI handles for internal radio / nfc
furi_hal_subghz_init_radio_type(SubGhzRadioInternal);
}

int32_t spectrum_analyzer_app(void* p) {
Expand All @@ -405,21 +397,18 @@ int32_t spectrum_analyzer_app(void* p) {
SpectrumAnalyzer* spectrum_analyzer = spectrum_analyzer_alloc();
InputEvent input;

// Enable power for External CC1101 if it is connected
furi_hal_subghz_enable_ext_power();
// Auto switch to internal radio if external radio is not available
furi_delay_ms(15);
if(!furi_hal_subghz_check_radio()) {
furi_hal_subghz_select_radio_type(SubGhzRadioInternal);
furi_hal_subghz_init_radio_type(SubGhzRadioInternal);
}

furi_hal_power_suppress_charge_enter();

FURI_LOG_D("Spectrum", "Main Loop - Starting worker");
furi_delay_ms(50);

spectrum_analyzer_worker_start(spectrum_analyzer->worker);
spectrum_analyzer_calculate_frequencies(spectrum_analyzer->model);
spectrum_analyzer_worker_set_frequencies(
spectrum_analyzer->worker,
spectrum_analyzer->model->channel0_frequency,
spectrum_analyzer->model->spacing,
spectrum_analyzer->model->width);

FURI_LOG_D("Spectrum", "Main Loop - Wait on queue");
furi_delay_ms(50);
Expand Down
92 changes: 68 additions & 24 deletions applications/external/spectrum_analyzer/spectrum_analyzer_worker.c
View file
Original file line number Diff line number Diff line change
Expand Up @@ -4,6 +4,8 @@
#include <furi_hal.h>
#include <furi.h>

#include "helpers/radio_device_loader.h"

#include <lib/drivers/cc1101_regs.h>

struct SpectrumAnalyzerWorker {
Expand All @@ -13,6 +15,8 @@ struct SpectrumAnalyzerWorker {
SpectrumAnalyzerWorkerCallback callback;
void* callback_context;

const SubGhzDevice* radio_device;

uint32_t channel0_frequency;
uint32_t spacing;
uint8_t width;
Expand Down Expand Up @@ -44,7 +48,9 @@ void spectrum_analyzer_worker_set_filter(SpectrumAnalyzerWorker* instance) {
filter_config[0][1] = 0x6C; /* 196 kHz / .8 = 245 kHz --> 270 kHz */
break;
}
furi_hal_subghz_load_registers((uint8_t*)filter_config);

UNUSED(filter_config);
// furi_hal_subghz_load_registers((uint8_t*)filter_config);
}

static int32_t spectrum_analyzer_worker_thread(void* context) {
Expand All @@ -54,32 +60,53 @@ static int32_t spectrum_analyzer_worker_thread(void* context) {
FURI_LOG_D("SpectrumWorker", "spectrum_analyzer_worker_thread: Start");

// Start CC1101
furi_hal_subghz_reset();
furi_hal_subghz_load_preset(FuriHalSubGhzPresetOok650Async);
furi_hal_subghz_set_frequency(433920000);
furi_hal_subghz_flush_rx();
furi_hal_subghz_rx();

static const uint8_t radio_config[][2] = {
{CC1101_FSCTRL1, 0x12},
{CC1101_FSCTRL0, 0x00},

{CC1101_AGCCTRL2, 0xC0},

{CC1101_MDMCFG4, 0x6C},
{CC1101_TEST2, 0x88},
{CC1101_TEST1, 0x31},
{CC1101_TEST0, 0x09},
subghz_devices_reset(instance->radio_device);
subghz_devices_load_preset(instance->radio_device, FuriHalSubGhzPresetOok650Async, NULL);
subghz_devices_set_frequency(instance->radio_device, 433920000);
subghz_devices_flush_rx(instance->radio_device);
subghz_devices_set_rx(instance->radio_device);

const uint8_t radio_config[] = {

CC1101_FSCTRL0,
0x00,
CC1101_FSCTRL1,
0x12,

CC1101_AGCCTRL2,
0xC0,

CC1101_MDMCFG4,
0x6C,
CC1101_TEST2,
0x88,
CC1101_TEST1,
0x31,
CC1101_TEST0,
0x09,

/* End */
{0, 0},
0,
0,

// ook_async_patable
0x00,
0xC0, // 12dBm 0xC0, 10dBm 0xC5, 7dBm 0xCD, 5dBm 0x86, 0dBm 0x50, -6dBm 0x37, -10dBm 0x26, -15dBm 0x1D, -20dBm 0x17, -30dBm 0x03
0x00,
0x00,
0x00,
0x00,
0x00,
0x00,
};

while(instance->should_work) {
furi_delay_ms(50);

// FURI_LOG_T("SpectrumWorker", "spectrum_analyzer_worker_thread: Worker Loop");
furi_hal_subghz_idle();
furi_hal_subghz_load_registers((uint8_t*)radio_config);
subghz_devices_idle(instance->radio_device);
subghz_devices_load_preset(
instance->radio_device, FuriHalSubGhzPresetCustom, (uint8_t*)radio_config);

// TODO: Check filter!
// spectrum_analyzer_worker_set_filter(instance);
Expand All @@ -90,25 +117,31 @@ static int32_t spectrum_analyzer_worker_thread(void* context) {
for(uint8_t ch_offset = 0, chunk = 0; ch_offset < CHUNK_SIZE;
++chunk >= NUM_CHUNKS && ++ch_offset && (chunk = 0)) {
uint8_t ch = chunk * CHUNK_SIZE + ch_offset;
furi_hal_subghz_set_frequency(instance->channel0_frequency + (ch * instance->spacing));

furi_hal_subghz_rx();
if(subghz_devices_is_frequency_valid(
instance->radio_device,
instance->channel0_frequency + (ch * instance->spacing)))
subghz_devices_set_frequency(
instance->radio_device,
instance->channel0_frequency + (ch * instance->spacing));

subghz_devices_set_rx(instance->radio_device);
furi_delay_ms(3);

// dec dBm
//max_ss = 127 -> -10.5
//max_ss = 0 -> -74.0
//max_ss = 255 -> -74.5
//max_ss = 128 -> -138.0
instance->channel_ss[ch] = (furi_hal_subghz_get_rssi() + 138) * 2;
instance->channel_ss[ch] = (subghz_devices_get_rssi(instance->radio_device) + 138) * 2;

if(instance->channel_ss[ch] > instance->max_rssi_dec) {
instance->max_rssi_dec = instance->channel_ss[ch];
instance->max_rssi = (instance->channel_ss[ch] / 2) - 138;
instance->max_rssi_channel = ch;
}

furi_hal_subghz_idle();
subghz_devices_idle(instance->radio_device);
}

// FURI_LOG_T("SpectrumWorker", "channel_ss[0]: %u", instance->channel_ss[0]);
Expand Down Expand Up @@ -138,6 +171,11 @@ SpectrumAnalyzerWorker* spectrum_analyzer_worker_alloc() {
furi_thread_set_context(instance->thread, instance);
furi_thread_set_callback(instance->thread, spectrum_analyzer_worker_thread);

subghz_devices_init();

instance->radio_device =
radio_device_loader_set(instance->radio_device, SubGhzRadioDeviceTypeExternalCC1101);

FURI_LOG_D("Spectrum", "spectrum_analyzer_worker_alloc: End");

return instance;
Expand All @@ -147,6 +185,12 @@ void spectrum_analyzer_worker_free(SpectrumAnalyzerWorker* instance) {
FURI_LOG_D("Spectrum", "spectrum_analyzer_worker_free");
furi_assert(instance);
furi_thread_free(instance->thread);

subghz_devices_sleep(instance->radio_device);
radio_device_loader_end(instance->radio_device);

subghz_devices_deinit();

free(instance);
}

Expand Down

0 comments on commit cb08b84

Please sign in to comment.