mirror of
https://github.com/Next-Flip/Momentum-Firmware.git
synced 2026-05-06 05:19:09 -07:00
642 lines
26 KiB
C
642 lines
26 KiB
C
//
|
|
// Written by vad7, 20.11.2022.
|
|
// ver. 1.0
|
|
//
|
|
#include "nrf24scan.h"
|
|
|
|
#include <furi.h>
|
|
#include <furi_hal.h>
|
|
#include <gui/gui.h>
|
|
#include <dialogs/dialogs.h>
|
|
#include <input/input.h>
|
|
#include <notification/notification_messages.h>
|
|
#include <stdlib.h>
|
|
#include <dolphin/dolphin.h>
|
|
#include <nrf24.h>
|
|
|
|
#define TAG "nrf24scan"
|
|
#define MAX_CHANNEL 125
|
|
#define MAX_ADDR 6
|
|
|
|
#define SCAN_APP_PATH_FOLDER "/ext/nrf24scan"
|
|
#define ADDR_FILENAME \
|
|
"addr.txt" // File format (1 parameter per line): \
|
|
// 0.25/1/2 - rate in Mbps \
|
|
// 0..125 - default channel \
|
|
// address P0 in hex (5 byte, LSB last) \
|
|
// address P1 in hex (5 byte, LSB last) \
|
|
// address P2, LSB in hex (1 byte) \
|
|
// address P3, LSB in hex (1 byte) \
|
|
// address P4, LSB in hex (1 byte) \
|
|
// address P5, LSB in hex (1 byte) \
|
|
// captured data in raw format, first byte = addr # 0..5 \
|
|
// ... up to MAX_LOG_RECORDS
|
|
#define LOG_FILENAME "log.txt"
|
|
#define MAX_LOG_RECORDS 99
|
|
#define LOG_REC_SIZE 33 // max packet size
|
|
#define VIEW_LOG_MAX_X 21
|
|
|
|
Nrf24Scan* nrf24scan;
|
|
uint8_t what_doing = 0; // 0 - setup, 1 - scanning
|
|
char screen_buf[64];
|
|
char addr_file_name[32];
|
|
uint8_t NRF_rate; // 0 - 250Kbps, 1 - 1Mbps, 2 - 2Mbps
|
|
uint8_t NRF_channel; // 0..125
|
|
struct {
|
|
uint8_t addr_P0[5]; // MSB first
|
|
uint8_t addr_P1[5]; // MSB first
|
|
uint8_t addr_P2; // LSB only, MSB bytes equal addr_P1
|
|
uint8_t addr_P3; // LSB only, MSB bytes equal addr_P1
|
|
uint8_t addr_P4; // LSB only, MSB bytes equal addr_P1
|
|
uint8_t addr_P5; // LSB only, MSB bytes equal addr_P1
|
|
uint8_t addr_len; // 2..5
|
|
uint8_t addr_count;
|
|
} addrs;
|
|
int8_t log_to_file = 0; // 0 - no, 1 - yes, 2 - new, -1 - only clear
|
|
uint16_t log_arr_idx;
|
|
uint16_t view_log_arr_idx = 0;
|
|
uint16_t view_log_arr_x = 0;
|
|
uint16_t last_packet_send = -1;
|
|
uint8_t last_packet_send_st = 0;
|
|
int16_t find_channel_period = 0; // sec
|
|
uint8_t menu_selected = 0;
|
|
#define menu_selected_max 5
|
|
uint32_t start_time;
|
|
|
|
static uint8_t GetHexVal(char hex) {
|
|
return (uint8_t)hex - ((uint8_t)hex < 58 ? 48 : ((uint8_t)hex < 97 ? 55 : 87));
|
|
}
|
|
|
|
// Return num bytes in array
|
|
static uint8_t ConvertHexToArray(char* hex, uint8_t* array, uint8_t maxlen) {
|
|
uint8_t len = 0;
|
|
do {
|
|
uint8_t ch = *hex++;
|
|
if(ch == 0) break;
|
|
if(ch < '0') continue;
|
|
*array++ = (GetHexVal(ch) << 4) + GetHexVal(*hex++);
|
|
len++;
|
|
} while(--maxlen);
|
|
return len;
|
|
}
|
|
|
|
static void add_to_str_hex_bytes(char* out, char* arr, int bytes) {
|
|
if(!bytes) return;
|
|
out += strlen(out);
|
|
do {
|
|
snprintf(out, 3, "%02X", *arr++);
|
|
out += 2;
|
|
} while(--bytes);
|
|
}
|
|
|
|
void clear_log() {
|
|
log_arr_idx = 0;
|
|
view_log_arr_idx = 0;
|
|
last_packet_send = -1;
|
|
}
|
|
|
|
void write_to_log_file(Storage* storage) {
|
|
if(log_arr_idx == 0) return;
|
|
Stream* file_stream = file_stream_alloc(storage);
|
|
FuriString* path = furi_string_alloc();
|
|
furi_string_set(path, SCAN_APP_PATH_FOLDER);
|
|
furi_string_cat(path, "/");
|
|
furi_string_cat(path, LOG_FILENAME);
|
|
char* txt = malloc(LOG_REC_SIZE * 2 + 2);
|
|
if(txt == NULL) {
|
|
FURI_LOG_E(TAG, "No memory to save log!");
|
|
} else {
|
|
if(file_stream_open(
|
|
file_stream, furi_string_get_cstr(path), FSAM_READ_WRITE, FSOM_OPEN_APPEND)) {
|
|
for(int i = 0; i < log_arr_idx; i++) {
|
|
add_to_str_hex_bytes(
|
|
txt, (char*)nrf24scan->log_arr + i * LOG_REC_SIZE, LOG_REC_SIZE);
|
|
strcat(txt, "\n");
|
|
int len = strlen(txt);
|
|
if(stream_write(file_stream, (uint8_t*)txt, len) != len) {
|
|
FURI_LOG_I(TAG, "Failed to write bytes to log!");
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
FURI_LOG_E(TAG, "Failed to open log file");
|
|
}
|
|
free(txt);
|
|
}
|
|
file_stream_close(file_stream);
|
|
furi_string_free(path);
|
|
stream_free(file_stream);
|
|
}
|
|
|
|
static void render_callback(Canvas* const canvas, void* ctx) {
|
|
const PluginState* plugin_state = acquire_mutex((ValueMutex*)ctx, 25);
|
|
if(plugin_state == NULL) return;
|
|
//canvas_draw_frame(canvas, 0, 0, 128, 64); // border around the edge of the screen
|
|
if(what_doing == 0) {
|
|
canvas_set_font(canvas, FontSecondary); // 8x10 font
|
|
snprintf(
|
|
screen_buf, sizeof(screen_buf), "Settings: %s", addr_file_name); // menu_selected = 0
|
|
canvas_draw_str(canvas, 10, 10, screen_buf);
|
|
snprintf(screen_buf, sizeof(screen_buf), "Channel: %d", NRF_channel); // menu_selected = 1
|
|
canvas_draw_str(canvas, 10, 20, screen_buf);
|
|
snprintf(
|
|
screen_buf,
|
|
sizeof(screen_buf),
|
|
"Rate: %sbps",
|
|
NRF_rate == 2 ? "2M" :
|
|
NRF_rate == 1 ? "1M" :
|
|
"250K"); // menu_selected = 2
|
|
canvas_draw_str(canvas, 10, 30, screen_buf);
|
|
strcpy(screen_buf, "Find channel period: "); // menu_selected = 3
|
|
if(find_channel_period == 0)
|
|
strcat(screen_buf, "off");
|
|
else
|
|
snprintf(
|
|
screen_buf + strlen(screen_buf), sizeof(screen_buf), "%d s", find_channel_period);
|
|
canvas_draw_str(canvas, 10, 40, screen_buf);
|
|
snprintf(
|
|
screen_buf,
|
|
sizeof(screen_buf),
|
|
"Log: %s",
|
|
log_to_file == 0 ? "No" :
|
|
log_to_file == 1 ? "Yes" :
|
|
log_to_file == 2 ? "New" :
|
|
"Clear"); // menu_selected = 4
|
|
canvas_draw_str(canvas, 10, 50, screen_buf);
|
|
snprintf(
|
|
screen_buf,
|
|
sizeof(screen_buf),
|
|
"Ok - Start read (%dp)",
|
|
addrs.addr_count); // menu_selected = 5
|
|
canvas_draw_str(canvas, 10, 60, screen_buf);
|
|
canvas_draw_str(canvas, 0, menu_selected * 10 + 10, ">");
|
|
} else {
|
|
canvas_set_font(canvas, FontBatteryPercent); // 5x7 font, 9 lines
|
|
char ch2 = ' ';
|
|
screen_buf[0] = '\0';
|
|
if(view_log_arr_x == 0) {
|
|
strcat(screen_buf, " ");
|
|
ch2 = '>';
|
|
} else {
|
|
snprintf(screen_buf, sizeof(screen_buf), "<%d", view_log_arr_x);
|
|
if(view_log_arr_x < VIEW_LOG_MAX_X) ch2 = '>';
|
|
}
|
|
snprintf(
|
|
screen_buf + strlen(screen_buf),
|
|
sizeof(screen_buf),
|
|
" Read %d channel... %c",
|
|
NRF_channel,
|
|
ch2);
|
|
canvas_draw_str(canvas, 0, 7, screen_buf);
|
|
if(log_arr_idx) {
|
|
uint16_t page = view_log_arr_idx & ~7;
|
|
for(uint8_t i = 0; i < 8 && page + i < log_arr_idx; i++) {
|
|
snprintf(screen_buf, sizeof(screen_buf), "%d: ", page + i + 1);
|
|
canvas_draw_str(canvas, 0, 14 + i * 7, screen_buf);
|
|
char* ptr = (char*)nrf24scan->log_arr + (page + i) * LOG_REC_SIZE + view_log_arr_x;
|
|
if(view_log_arr_x == 0) {
|
|
snprintf(screen_buf, sizeof(screen_buf), "%d-", *ptr + 1);
|
|
add_to_str_hex_bytes(screen_buf, ptr + 1, 10);
|
|
} else {
|
|
screen_buf[0] = '\0';
|
|
add_to_str_hex_bytes(screen_buf, ptr + 1, 11);
|
|
}
|
|
canvas_draw_str(canvas, 13, 14 + i * 7, screen_buf);
|
|
}
|
|
canvas_draw_str(
|
|
canvas,
|
|
10,
|
|
14 + (view_log_arr_idx & 7) * 7,
|
|
last_packet_send != view_log_arr_idx ? ">" :
|
|
last_packet_send_st == 0 ? "!" :
|
|
"+");
|
|
}
|
|
}
|
|
release_mutex((ValueMutex*)ctx, plugin_state);
|
|
}
|
|
|
|
static bool select_settings_file(Stream* stream) {
|
|
DialogsApp* dialogs = furi_record_open("dialogs");
|
|
bool result = false;
|
|
FuriString* path;
|
|
path = furi_string_alloc();
|
|
furi_string_set(path, SCAN_APP_PATH_FOLDER);
|
|
|
|
DialogsFileBrowserOptions browser_options;
|
|
dialog_file_browser_set_basic_options(&browser_options, ".txt", NULL);
|
|
browser_options.hide_ext = false;
|
|
|
|
bool ret = dialog_file_browser_show(dialogs, path, path, &browser_options);
|
|
|
|
furi_record_close("dialogs");
|
|
if(ret) {
|
|
if(!file_stream_open(stream, furi_string_get_cstr(path), FSAM_READ, FSOM_OPEN_EXISTING)) {
|
|
file_stream_close(stream);
|
|
FURI_LOG_D(TAG, "Cannot open file \"%s\"", furi_string_get_cstr(path));
|
|
} else {
|
|
FURI_LOG_D(TAG, "Open file \"%s\"", furi_string_get_cstr(path));
|
|
strncpy(
|
|
addr_file_name,
|
|
furi_string_get_cstr(path) + sizeof(SCAN_APP_PATH_FOLDER),
|
|
sizeof(addr_file_name));
|
|
result = true;
|
|
}
|
|
}
|
|
furi_string_free(path);
|
|
return result;
|
|
}
|
|
|
|
static bool load_settings_file(Stream* file_stream) {
|
|
size_t file_size = 0;
|
|
char* file_buf;
|
|
bool loaded = false;
|
|
file_size = stream_size(file_stream);
|
|
if(file_size == (size_t)0) {
|
|
FURI_LOG_D(TAG, "load failed. file_size: %d", file_size);
|
|
return loaded;
|
|
}
|
|
file_buf = malloc(file_size);
|
|
memset(file_buf, 0, file_size);
|
|
if(stream_read(file_stream, (uint8_t*)file_buf, file_size) == file_size) {
|
|
FURI_LOG_D(TAG, "Loading settings file");
|
|
char* line_ptr = file_buf;
|
|
int16_t line_num = 0;
|
|
memset((uint8_t*)&addrs, 0, sizeof(addrs));
|
|
while(line_ptr && line_ptr - file_buf < file_size) {
|
|
char* end_ptr = strstr((char*)line_ptr, "\n");
|
|
if(end_ptr == NULL)
|
|
end_ptr = file_buf + file_size;
|
|
else
|
|
*end_ptr = '\0';
|
|
FURI_LOG_D(TAG, " L#%d: [%d]%s", line_num, end_ptr - line_ptr, line_ptr);
|
|
if(*line_ptr == '\r') {
|
|
line_ptr = end_ptr + 1;
|
|
continue;
|
|
}
|
|
if(end_ptr - line_ptr >= LOG_REC_SIZE * 2) { // data
|
|
if(log_arr_idx < MAX_LOG_RECORDS) {
|
|
ConvertHexToArray(
|
|
line_ptr, nrf24scan->log_arr + log_arr_idx * LOG_REC_SIZE, LOG_REC_SIZE);
|
|
log_arr_idx++;
|
|
clear_log();
|
|
}
|
|
} else if(addrs.addr_count) {
|
|
ConvertHexToArray(
|
|
line_ptr,
|
|
addrs.addr_count == 1 ? &addrs.addr_P1[0] :
|
|
addrs.addr_count == 2 ? &addrs.addr_P2 :
|
|
addrs.addr_count == 3 ? &addrs.addr_P3 :
|
|
addrs.addr_count == 4 ? &addrs.addr_P4 :
|
|
&addrs.addr_P5,
|
|
addrs.addr_count == 1 ? 5 : 1);
|
|
FURI_LOG_D(TAG, " +Addr_LSB: %s", line_ptr);
|
|
if(++addrs.addr_count == MAX_ADDR) break;
|
|
} else if(end_ptr - line_ptr < 4) { // Rate or Channel
|
|
if(line_num == 0) { // 1st line - Rate
|
|
NRF_rate = atoi(line_ptr);
|
|
FURI_LOG_D(TAG, " Rate: %d", NRF_rate);
|
|
} else if(line_num == 1) { // second line - Channel
|
|
NRF_channel = atoi(line_ptr);
|
|
FURI_LOG_D(TAG, " Ch: %d", NRF_channel);
|
|
}
|
|
} else if(end_ptr - line_ptr <= 5 * 2 + 1) { // addresses
|
|
addrs.addr_len = ConvertHexToArray(line_ptr, addrs.addr_P0, 5);
|
|
FURI_LOG_D(
|
|
TAG,
|
|
" +Addr(%d): %02X%02X%02X...",
|
|
addrs.addr_len,
|
|
addrs.addr_P0[0],
|
|
addrs.addr_P0[1],
|
|
addrs.addr_P0[2]);
|
|
loaded = true;
|
|
if(++addrs.addr_count == MAX_ADDR) break;
|
|
}
|
|
line_ptr = end_ptr + 1;
|
|
line_num++;
|
|
}
|
|
} else {
|
|
FURI_LOG_D(TAG, "load failed. file size: %d", file_size);
|
|
}
|
|
free(file_buf);
|
|
return loaded;
|
|
}
|
|
|
|
static void input_callback(InputEvent* input_event, FuriMessageQueue* event_queue) {
|
|
furi_assert(event_queue);
|
|
PluginEvent event = {.type = EventTypeKey, .input = *input_event};
|
|
furi_message_queue_put(event_queue, &event, FuriWaitForever);
|
|
}
|
|
|
|
static void start_scanning() {
|
|
uint8_t addr[5];
|
|
uint8_t erx_addr = (1 << 0); // Enable RX_P0
|
|
if(addrs.addr_count == 0) return;
|
|
nrf24_write_reg(nrf24_HANDLE, REG_CONFIG, 0x00); // Stop nRF
|
|
nrf24_write_reg(nrf24_HANDLE, REG_STATUS, 0x70); // clear interrupts
|
|
nrf24_write_reg(nrf24_HANDLE, REG_DYNPD, 0x0); // disable shockburst
|
|
nrf24_write_reg(nrf24_HANDLE, REG_EN_AA, 0x00); // Disable Shockburst
|
|
nrf24_write_reg(
|
|
nrf24_HANDLE,
|
|
REG_FEATURE,
|
|
0x01); // Enables the W_TX_PAYLOAD_NOACK command, Disable Payload with ACK, Disable Dynamic Payload Length
|
|
nrf24_set_maclen(nrf24_HANDLE, addrs.addr_len);
|
|
for(int i = 0; i < addrs.addr_len; i++) addr[i] = addrs.addr_P0[addrs.addr_len - i - 1];
|
|
nrf24_write_buf_reg(nrf24_HANDLE, REG_RX_ADDR_P0, &addr[0], addrs.addr_len);
|
|
nrf24_write_reg(nrf24_HANDLE, RX_PW_P0, 32);
|
|
if(addrs.addr_count > 1) {
|
|
for(int i = 0; i < addrs.addr_len; i++) addr[i] = addrs.addr_P1[addrs.addr_len - i - 1];
|
|
nrf24_write_buf_reg(nrf24_HANDLE, REG_RX_ADDR_P1, &addr[0], addrs.addr_len);
|
|
nrf24_write_reg(nrf24_HANDLE, RX_PW_P1, 32);
|
|
erx_addr |= (1 << 1); // Enable RX_P1
|
|
} else
|
|
nrf24_write_reg(nrf24_HANDLE, RX_PW_P1, 0);
|
|
if(addrs.addr_count > 2) {
|
|
nrf24_write_buf_reg(nrf24_HANDLE, REG_RX_ADDR_P2, &addrs.addr_P2, 1);
|
|
nrf24_write_reg(nrf24_HANDLE, RX_PW_P2, 32);
|
|
erx_addr |= (1 << 2); // Enable RX_P2
|
|
} else
|
|
nrf24_write_reg(nrf24_HANDLE, RX_PW_P2, 0);
|
|
if(addrs.addr_count > 3) {
|
|
nrf24_write_buf_reg(nrf24_HANDLE, REG_RX_ADDR_P3, &addrs.addr_P3, 1);
|
|
nrf24_write_reg(nrf24_HANDLE, RX_PW_P3, 32);
|
|
erx_addr |= (1 << 3); // Enable RX_P3
|
|
} else
|
|
nrf24_write_reg(nrf24_HANDLE, RX_PW_P3, 0);
|
|
if(addrs.addr_count > 4) {
|
|
nrf24_write_buf_reg(nrf24_HANDLE, REG_RX_ADDR_P4, &addrs.addr_P4, 1);
|
|
nrf24_write_reg(nrf24_HANDLE, RX_PW_P4, 32);
|
|
erx_addr |= (1 << 4); // Enable RX_P4
|
|
} else
|
|
nrf24_write_reg(nrf24_HANDLE, RX_PW_P4, 0);
|
|
if(addrs.addr_count > 5) {
|
|
nrf24_write_buf_reg(nrf24_HANDLE, REG_RX_ADDR_P5, &addrs.addr_P5, 1);
|
|
nrf24_write_reg(nrf24_HANDLE, RX_PW_P5, 32);
|
|
erx_addr |= (1 << 5); // Enable RX_P5
|
|
} else
|
|
nrf24_write_reg(nrf24_HANDLE, RX_PW_P5, 0);
|
|
nrf24_write_reg(nrf24_HANDLE, REG_STATUS, 0x50); // clear RX_DR, MAX_RT.
|
|
nrf24_set_idle(nrf24_HANDLE);
|
|
nrf24_flush_rx(nrf24_HANDLE);
|
|
nrf24_flush_tx(nrf24_HANDLE);
|
|
nrf24_write_reg(nrf24_HANDLE, REG_EN_RXADDR, erx_addr);
|
|
nrf24_write_reg(nrf24_HANDLE, REG_RF_CH, NRF_channel);
|
|
nrf24_write_reg(nrf24_HANDLE, REG_RF_SETUP, NRF_rate);
|
|
// prime for RX, no checksum
|
|
nrf24_write_reg(nrf24_HANDLE, REG_CONFIG, 0x03); // PWR_UP and PRIM_RX, disable AA and CRC
|
|
furi_hal_gpio_write(nrf24_CE_PIN, true);
|
|
furi_delay_ms(100);
|
|
|
|
start_time = furi_get_tick();
|
|
FURI_LOG_D(TAG, "Start scan: Ch=%d Rate=%d", NRF_channel, NRF_rate);
|
|
}
|
|
|
|
bool nrf24_read_newpacket() {
|
|
if(nrf24scan->log_arr == NULL) return false;
|
|
bool found = false;
|
|
uint8_t packetsize;
|
|
uint8_t packet[32] = {0};
|
|
uint8_t status = nrf24_rxpacket(nrf24_HANDLE, packet, &packetsize, true);
|
|
if(status & 0x40) {
|
|
uint8_t* ptr = nrf24scan->log_arr + log_arr_idx * LOG_REC_SIZE;
|
|
*ptr++ = (status >> 1) & 7; // pipe #
|
|
memcpy(ptr, packet, packetsize);
|
|
if(packetsize < LOG_REC_SIZE) memset(ptr + packetsize, 0, LOG_REC_SIZE - packetsize);
|
|
if(log_arr_idx < MAX_LOG_RECORDS - 1) {
|
|
log_arr_idx++;
|
|
} else {
|
|
if(log_to_file > 0) {
|
|
write_to_log_file(nrf24scan->storage);
|
|
log_arr_idx = 0;
|
|
} else {
|
|
memmove(
|
|
nrf24scan->log_arr,
|
|
nrf24scan->log_arr + LOG_REC_SIZE,
|
|
log_arr_idx * LOG_REC_SIZE);
|
|
}
|
|
}
|
|
FURI_LOG_D(TAG, "Found packet #%d pipe %d", log_arr_idx, (status >> 1) & 7);
|
|
found = true;
|
|
}
|
|
return found;
|
|
}
|
|
|
|
bool nrf24_send_packet() {
|
|
if(log_arr_idx == 0) return false;
|
|
last_packet_send_st = nrf24_txpacket(
|
|
nrf24_HANDLE, nrf24scan->log_arr + view_log_arr_idx * LOG_REC_SIZE + 1, 32, false);
|
|
last_packet_send = view_log_arr_idx;
|
|
return last_packet_send_st;
|
|
}
|
|
|
|
void allocate_log_array() {
|
|
nrf24scan->log_arr = malloc(LOG_REC_SIZE * MAX_LOG_RECORDS);
|
|
if(nrf24scan->log_arr == NULL) {
|
|
FURI_LOG_E(TAG, "Not enouch memory: %d", LOG_REC_SIZE * MAX_LOG_RECORDS);
|
|
strcpy(addr_file_name, "MEMORY LOW!");
|
|
}
|
|
clear_log();
|
|
}
|
|
|
|
int32_t nrf24scan_app(void* p) {
|
|
UNUSED(p);
|
|
nrf24scan = malloc(sizeof(Nrf24Scan));
|
|
nrf24scan->event_queue = furi_message_queue_alloc(8, sizeof(PluginEvent));
|
|
nrf24scan->plugin_state = malloc(sizeof(PluginState));
|
|
ValueMutex state_mutex;
|
|
if(!init_mutex(&state_mutex, nrf24scan->plugin_state, sizeof(PluginState))) {
|
|
furi_message_queue_free(nrf24scan->event_queue);
|
|
FURI_LOG_E(TAG, "cannot create mutex\r\n");
|
|
free(nrf24scan->plugin_state);
|
|
return 255;
|
|
}
|
|
memset((uint8_t*)&addrs, 0, sizeof(addrs));
|
|
nrf24_init();
|
|
|
|
// Set system callbacks
|
|
nrf24scan->view_port = view_port_alloc();
|
|
view_port_draw_callback_set(nrf24scan->view_port, render_callback, &state_mutex);
|
|
view_port_input_callback_set(nrf24scan->view_port, input_callback, nrf24scan->event_queue);
|
|
|
|
// Open GUI and register view_port
|
|
nrf24scan->gui = furi_record_open(RECORD_GUI);
|
|
gui_add_view_port(nrf24scan->gui, nrf24scan->view_port, GuiLayerFullscreen);
|
|
NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
|
|
nrf24scan->storage = furi_record_open(RECORD_STORAGE);
|
|
storage_common_mkdir(nrf24scan->storage, SCAN_APP_PATH_FOLDER);
|
|
Stream* file_stream = file_stream_alloc(nrf24scan->storage);
|
|
FuriString* path = furi_string_alloc();
|
|
furi_string_set(path, SCAN_APP_PATH_FOLDER);
|
|
furi_string_cat(path, "/");
|
|
furi_string_cat(path, ADDR_FILENAME);
|
|
if(file_stream_open(file_stream, furi_string_get_cstr(path), FSAM_READ, FSOM_OPEN_EXISTING)) {
|
|
if(load_settings_file(file_stream))
|
|
strcpy(addr_file_name, ADDR_FILENAME);
|
|
else
|
|
strcpy(addr_file_name, "LOAD ERROR");
|
|
} else {
|
|
strcpy(addr_file_name, "NONE");
|
|
}
|
|
file_stream_close(file_stream);
|
|
furi_string_free(path);
|
|
stream_free(file_stream);
|
|
allocate_log_array();
|
|
|
|
PluginEvent event;
|
|
for(bool processing = true; processing;) {
|
|
FuriStatus event_status = furi_message_queue_get(nrf24scan->event_queue, &event, 100);
|
|
PluginState* plugin_state = (PluginState*)acquire_mutex_block(&state_mutex);
|
|
|
|
if(event_status == FuriStatusOk) {
|
|
// press events
|
|
if(event.type == EventTypeKey) {
|
|
switch(event.input.key) {
|
|
case InputKeyUp:
|
|
if(event.input.type == InputTypePress || event.input.type == InputTypeRepeat) {
|
|
if(what_doing == 0) {
|
|
if(menu_selected > 0)
|
|
menu_selected--;
|
|
else
|
|
menu_selected = menu_selected_max;
|
|
} else {
|
|
if(view_log_arr_idx > 0) view_log_arr_idx--;
|
|
}
|
|
}
|
|
break;
|
|
case InputKeyDown:
|
|
if(event.input.type == InputTypePress || event.input.type == InputTypeRepeat) {
|
|
if(what_doing == 0) {
|
|
if(menu_selected < menu_selected_max)
|
|
menu_selected++;
|
|
else
|
|
menu_selected = 0;
|
|
} else {
|
|
if(view_log_arr_idx < log_arr_idx - 1) view_log_arr_idx++;
|
|
}
|
|
}
|
|
break;
|
|
case InputKeyRight:
|
|
if(event.input.type == InputTypePress || event.input.type == InputTypeRepeat) {
|
|
if(what_doing == 0) {
|
|
switch(menu_selected) {
|
|
case 1:
|
|
NRF_channel += event.input.type == InputTypeRepeat ? 10 : 1;
|
|
if(NRF_channel > MAX_CHANNEL) NRF_channel = 0;
|
|
break;
|
|
case 2:
|
|
NRF_rate++;
|
|
if(NRF_rate > 2) NRF_rate = 0;
|
|
break;
|
|
case 3:
|
|
find_channel_period += event.input.type == InputTypeRepeat ? 10 :
|
|
1;
|
|
break;
|
|
case 4:
|
|
if(++log_to_file > 2) log_to_file = -1;
|
|
break;
|
|
}
|
|
} else {
|
|
if(view_log_arr_x < VIEW_LOG_MAX_X) view_log_arr_x++;
|
|
}
|
|
}
|
|
break;
|
|
case InputKeyLeft:
|
|
if(event.input.type == InputTypePress || event.input.type == InputTypeRepeat) {
|
|
if(what_doing == 0) {
|
|
switch(menu_selected) {
|
|
case 1:
|
|
NRF_channel -= event.input.type == InputTypeRepeat ? 10 : 1;
|
|
if(NRF_channel > MAX_CHANNEL) NRF_channel = MAX_CHANNEL;
|
|
break;
|
|
case 2:
|
|
NRF_rate--;
|
|
if(NRF_rate > 2) NRF_rate = 2;
|
|
break;
|
|
case 3:
|
|
find_channel_period -= event.input.type == InputTypeRepeat ? 10 :
|
|
1;
|
|
if(find_channel_period < 0) find_channel_period = 0;
|
|
break;
|
|
case 4:
|
|
if(--log_to_file < -1) log_to_file = 2;
|
|
break;
|
|
}
|
|
} else {
|
|
if(view_log_arr_x > 0) view_log_arr_x--;
|
|
}
|
|
}
|
|
break;
|
|
case InputKeyOk:
|
|
if(event.input.type == InputTypePress) {
|
|
if(what_doing == 0) {
|
|
if(menu_selected == 0) { // File
|
|
file_stream = file_stream_alloc(nrf24scan->storage);
|
|
if(select_settings_file(file_stream)) {
|
|
if(!load_settings_file(file_stream)) {
|
|
strcpy(addr_file_name, "LOAD ERROR");
|
|
} else {
|
|
if(log_to_file > 0) write_to_log_file(nrf24scan->storage);
|
|
clear_log();
|
|
}
|
|
file_stream_close(file_stream);
|
|
}
|
|
stream_free(file_stream);
|
|
} else if(menu_selected == 5) {
|
|
what_doing = !what_doing;
|
|
if(what_doing) {
|
|
if(log_to_file == 2 || log_to_file == -1) clear_log();
|
|
start_scanning();
|
|
} else
|
|
nrf24_set_idle(nrf24_HANDLE);
|
|
}
|
|
} else { // Send
|
|
nrf24_send_packet();
|
|
}
|
|
} else if(event.input.type == InputTypeLong) {
|
|
what_doing = !what_doing;
|
|
if(what_doing) {
|
|
if(log_to_file == 2 || log_to_file == -1) clear_log();
|
|
start_scanning();
|
|
} else
|
|
nrf24_set_idle(nrf24_HANDLE);
|
|
}
|
|
break;
|
|
case InputKeyBack:
|
|
if(event.input.type == InputTypeLong)
|
|
processing = false;
|
|
else
|
|
what_doing = 0;
|
|
nrf24_set_idle(nrf24_HANDLE);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
if(what_doing) {
|
|
nrf24_read_newpacket();
|
|
if(find_channel_period &&
|
|
furi_get_tick() - start_time >= (uint32_t)find_channel_period * 1000UL) {
|
|
if(++NRF_channel > MAX_CHANNEL) NRF_channel = 0;
|
|
start_scanning();
|
|
}
|
|
}
|
|
|
|
view_port_update(nrf24scan->view_port);
|
|
release_mutex(&state_mutex, plugin_state);
|
|
}
|
|
|
|
nrf24_deinit();
|
|
view_port_enabled_set(nrf24scan->view_port, false);
|
|
gui_remove_view_port(nrf24scan->gui, nrf24scan->view_port);
|
|
furi_record_close(RECORD_GUI);
|
|
furi_record_close(RECORD_NOTIFICATION);
|
|
furi_record_close(RECORD_STORAGE);
|
|
view_port_free(nrf24scan->view_port);
|
|
furi_message_queue_free(nrf24scan->event_queue);
|
|
free(nrf24scan->plugin_state);
|
|
if(nrf24scan->log_arr) free(nrf24scan->log_arr);
|
|
free(nrf24scan);
|
|
return 0;
|
|
}
|