Mirror/Momentum-Firmware
1
0
Fork 0
mirror of https://github.com/Next-Flip/Momentum-Firmware.git synced 2026-04-26 03:39:58 -07:00
Code Issues Packages Projects Releases Wiki Activity
Files
16a037fc4ee93e115cfaf0eaae70338fc0db3e79
Momentum-Firmware/applications/plugins/nrf24scan/nrf24scan.c
RogueMaster 7484e573d0 Update nrf24scan.c
2022-11-26 03:03:28 -05:00

917 lines
38 KiB
C
Raw Blame History

//
// Written by vad7, 20.11.2022.
// ver. 1.2
//
#include "nrf24scan.h"
#include <furi.h>
#include <furi_hal.h>
#include <gui/gui.h>
#include <dialogs/dialogs.h>
#include <input/input.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): \
// Rate: 0/1/2 - rate in Mbps (=0.25/1/2) \
// Ch: 0..125 - default channel \
// ESB: 0/1 (1 - Enhanced ShockBurst) \
// DPL: 0/1 (1 - Dynamic Payload Length) \
// CRC: 0/1/2 (CRC length) \
// Payload: 1..32 (bytes) \
// P0: address P0 in hex (5 byte, LSB last) \
// P1: address P1 in hex (5 byte, LSB last) \
// P2: address P2, LSB in hex (1 byte) \
// P3: address P3, LSB in hex (1 byte) \
// P4: address P4, LSB in hex (1 byte) \
// P5: address P5, LSB in hex (1 byte) \
// captured data in raw format, first byte = address # 0..5, Payload len if DPL \
// ... up to MAX_LOG_RECORDS-1
#define LOG_FILENAME "log"
#define LOG_FILEEXT ".txt"
#define MAX_LOG_RECORDS 100
#define LOG_REC_SIZE 33 // max packet size
#define VIEW_LOG_MAX_X 22
const char SettingsFld_Rate[] = "Rate:";
const char SettingsFld_Ch[] = "Ch:";
const char SettingsFld_ESB[] = "ESB:";
const char SettingsFld_DPL[] = "DPL:";
const char SettingsFld_CRC[] = "CRC:";
const char SettingsFld_Payload[] = "Payload:";
char SettingsFld_Addr = 'P';
Nrf24Scan* APP;
uint8_t what_doing = 0; // 0 - setup, 1 - view log, 2 - view addresses
uint8_t what_to_do = 1; // 0 - view, 1 - view & scan
uint32_t key_press_seq_ok = 0;
char screen_buf[64];
char addr_file_name[32];
uint8_t NRF_rate = 1; // 0 - 250Kbps, 1 - 1Mbps, 2 - 2Mbps
uint8_t NRF_channel = 0; // 0..125
uint8_t NRF_ESB = 0; // 0 - ShockBurst, 1 - Enhanced ShockBurst
uint8_t NRF_DPL = 0; // 1 - Dynamic Payload Length
uint8_t NRF_CRC = 0; // 1 - No, 1 - CRC 1byte, 2 - CRC 2byte
uint8_t NRF_Payload = 32; // len in bytes, max 32
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(new), 2 - append, -1 - only clear
uint16_t log_arr_idx;
uint16_t view_log_arr_idx = 0;
uint16_t view_log_arr_x = 0;
bool save_to_new_log = true;
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;
uint32_t start_time;
#define menu_selected_max 5
enum {
Menu_open_file = 0,
Menu_enter_channel,
Menu_enter_rate,
Menu_enter_scan_period,
Menu_log,
Menu_ok
};
//#define MIN(a, b) ((a<b)?a:b)
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;
while(maxlen) {
uint8_t ch = *hex++;
if(ch == 0) break;
if(ch < '0') continue;
*array++ = (GetHexVal(ch) << 4) + GetHexVal(*hex++);
len++;
maxlen--;
}
return len;
}
static void add_to_str_hex_bytes(char* out, char* arr, int bytes) {
if(bytes <= 0) return;
out += strlen(out);
do {
snprintf(out, 3, "%02X", *arr++);
out += 2;
} while(--bytes);
}
static void add_to_furi_str_hex_bytes(FuriString* str, char* arr, int bytes) {
if(!bytes) return;
do {
furi_string_cat_printf(str, "%02X", *arr++);
} while(--bytes);
}
void clear_log() {
log_arr_idx = 0;
view_log_arr_idx = 0;
last_packet_send = -1;
}
void allocate_log_array() {
APP->log_arr = malloc(LOG_REC_SIZE * MAX_LOG_RECORDS);
if(APP->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();
}
void write_to_log_file(Storage* storage) {
if(log_arr_idx == 0) return;
Stream* file_stream = file_stream_alloc(storage);
FuriString* str = furi_string_alloc();
furi_string_set(str, SCAN_APP_PATH_FOLDER);
furi_string_cat(str, "/");
furi_string_cat(str, LOG_FILENAME);
furi_string_cat(str, LOG_FILEEXT);
bool fl;
if(save_to_new_log) {
int cnt = 1;
do {
fl = file_stream_open(
file_stream, furi_string_get_cstr(str), FSAM_READ_WRITE, FSOM_CREATE_NEW);
if(fl) break;
file_stream_close(file_stream);
furi_string_set(str, SCAN_APP_PATH_FOLDER);
furi_string_cat(str, "/");
furi_string_cat(str, LOG_FILENAME);
furi_string_cat_printf(str, "-%02d", cnt);
furi_string_cat(str, LOG_FILEEXT);
} while(++cnt < 100);
if(!fl) {
FURI_LOG_E(TAG, "Failed to create new log file");
notification_message(APP->notification, &sequence_blink_red_100);
}
} else {
fl = file_stream_open(
file_stream, furi_string_get_cstr(str), FSAM_READ_WRITE, FSOM_OPEN_APPEND);
if(fl) {
if(stream_size(file_stream) == 0) save_to_new_log = true;
} else
file_stream_close(file_stream);
}
if(fl) {
FURI_LOG_D(TAG, "Save to log %s", furi_string_get_cstr(str));
if(save_to_new_log) {
furi_string_printf(
str,
"%s %d\n%s %d\n%s %d\n",
SettingsFld_Rate,
NRF_rate,
SettingsFld_Ch,
NRF_channel,
SettingsFld_ESB,
NRF_ESB);
furi_string_cat_printf(
str,
"%s %d\n%s %d\n%s %d\n",
SettingsFld_DPL,
NRF_DPL,
SettingsFld_CRC,
NRF_CRC,
SettingsFld_Payload,
NRF_Payload);
furi_string_cat_printf(str, "P0: ");
add_to_furi_str_hex_bytes(str, (char*)addrs.addr_P0, addrs.addr_len);
furi_string_cat(str, "\n");
if(addrs.addr_count > 1) {
furi_string_cat_printf(str, "P1: ");
add_to_furi_str_hex_bytes(str, (char*)addrs.addr_P1, addrs.addr_len);
furi_string_cat(str, "\n");
}
if(addrs.addr_count > 2) {
furi_string_cat_printf(str, "P2: ");
furi_string_cat_printf(str, "%02X\n", addrs.addr_P2);
}
if(addrs.addr_count > 3) {
furi_string_cat_printf(str, "P3: ");
furi_string_cat_printf(str, "%02X\n", addrs.addr_P3);
}
if(addrs.addr_count > 4) {
furi_string_cat_printf(str, "P4: ");
furi_string_cat_printf(str, "%02X\n", addrs.addr_P4);
}
if(addrs.addr_count > 5) {
furi_string_cat_printf(str, "P5: ");
furi_string_cat_printf(str, "%02X\n", addrs.addr_P5);
}
if(!(fl = stream_write_string(file_stream, str) == furi_string_size(str))) {
FURI_LOG_E(TAG, "Failed to write header to log!");
notification_message(APP->notification, &sequence_blink_red_100);
}
}
if(fl) {
int i = 0;
for(; i < log_arr_idx; i++) {
furi_string_reset(str);
add_to_furi_str_hex_bytes(
str,
(char*)APP->log_arr + i * LOG_REC_SIZE,
MIN(NRF_Payload + 1, LOG_REC_SIZE));
furi_string_cat(str, "\n");
if(stream_write_string(file_stream, str) != furi_string_size(str)) {
FURI_LOG_E(TAG, "Failed to write to log!");
break;
}
}
if(i == log_arr_idx) {
notification_message(APP->notification, &sequence_blink_yellow_100);
FURI_LOG_D(TAG, "Log saved");
}
}
save_to_new_log = false;
file_stream_close(file_stream);
} else {
FURI_LOG_E(TAG, "Failed to open log file");
notification_message(APP->notification, &sequence_blink_red_100);
}
stream_free(file_stream);
furi_string_free(str);
}
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)) {
FURI_LOG_D(TAG, "Cannot open file \"%s\"", furi_string_get_cstr(path));
file_stream_close(stream);
} 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;
}
// 0 - success, otherwise an error
static uint8_t load_settings_file(Stream* file_stream) {
size_t file_size = 0;
char* file_buf;
uint8_t err = 5;
file_size = stream_size(file_stream);
if(file_size == (size_t)0) {
FURI_LOG_D(TAG, "load failed. file_size: %d", file_size);
return 1;
}
file_size = MIN(file_size, LOG_REC_SIZE * MAX_LOG_RECORDS * 2 + 100);
file_buf = malloc(file_size + 1);
if(file_buf == NULL) {
FURI_LOG_D(TAG, "Memory low, need: %d", file_size);
return 2;
}
memset(file_buf, 0, file_size + 1);
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));
bool log_loaded = false;
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';
int line_len = end_ptr - line_ptr;
if(*line_ptr == '\r' || line_len == 0) {
line_ptr = end_ptr + 1;
continue;
}
if(*(end_ptr - 1) < '0') {
*(end_ptr - 1) = '\0';
line_len--;
}
FURI_LOG_D(TAG, " L#%d: [%d]%s", line_num, line_len, line_ptr);
if(strncmp(line_ptr, SettingsFld_Rate, sizeof(SettingsFld_Rate) - 1) == 0) {
NRF_rate = atoi(line_ptr + sizeof(SettingsFld_Rate));
} else if(strncmp(line_ptr, SettingsFld_Ch, sizeof(SettingsFld_Ch) - 1) == 0) {
NRF_channel = atoi(line_ptr + sizeof(SettingsFld_Ch));
} else if(strncmp(line_ptr, SettingsFld_ESB, sizeof(SettingsFld_ESB) - 1) == 0) {
NRF_ESB = atoi(line_ptr + sizeof(SettingsFld_ESB));
} else if(strncmp(line_ptr, SettingsFld_DPL, sizeof(SettingsFld_DPL) - 1) == 0) {
NRF_DPL = atoi(line_ptr + sizeof(SettingsFld_DPL));
} else if(strncmp(line_ptr, SettingsFld_CRC, sizeof(SettingsFld_CRC) - 1) == 0) {
NRF_CRC = atoi(line_ptr + sizeof(SettingsFld_CRC));
} else if(strncmp(line_ptr, SettingsFld_Payload, sizeof(SettingsFld_Payload) - 1) == 0) {
NRF_Payload = atoi(line_ptr + sizeof(SettingsFld_Payload));
if(NRF_Payload == 0 || NRF_Payload > 32) NRF_Payload = 32;
} else if(*line_ptr == SettingsFld_Addr) {
char a = *(++line_ptr);
line_ptr += 3;
switch(a) {
case '0':
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]);
if(addrs.addr_len >= 2) err = 0;
break;
case '1':
ConvertHexToArray(line_ptr, addrs.addr_P1, 5);
FURI_LOG_D(
TAG,
" +Addr: %02X%02X%02X...",
addrs.addr_P0[1],
addrs.addr_P1[1],
addrs.addr_P1[2]);
break;
case '2':
ConvertHexToArray(line_ptr, &addrs.addr_P2, 1);
break;
case '3':
ConvertHexToArray(line_ptr, &addrs.addr_P3, 1);
break;
case '4':
ConvertHexToArray(line_ptr, &addrs.addr_P4, 1);
break;
case '5':
ConvertHexToArray(line_ptr, &addrs.addr_P5, 1);
break;
default:
a = 0;
break;
}
if(a) addrs.addr_count = a - '0' + 1;
} else if(line_len >= (NRF_Payload + 1) * 2) { // data
if(!log_loaded) {
clear_log();
what_to_do = 0;
log_loaded = true;
}
if(log_arr_idx < MAX_LOG_RECORDS - 1) {
ConvertHexToArray(
line_ptr, APP->log_arr + log_arr_idx * LOG_REC_SIZE, MIN(NRF_Payload, 32));
log_arr_idx++;
}
}
line_ptr = end_ptr + 1;
line_num++;
}
} else {
FURI_LOG_D(TAG, "load failed. file size: %d", file_size);
err = 4;
}
free(file_buf);
return err;
}
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 prepare_nrf24() {
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, NRF_CRC == 1 ? 0b1000 : NRF_CRC == 2 ? 0b1100 : 0);
nrf24_write_reg(nrf24_HANDLE, REG_STATUS, 0x70); // clear interrupts
nrf24_write_reg(
nrf24_HANDLE, REG_SETUP_RETR, NRF_ESB ? 1 : 0); // Disable Automatic Retransmission
nrf24_write_reg(nrf24_HANDLE, REG_EN_AA, NRF_ESB ? 0x3F : 0); // Auto acknowledgement
nrf24_write_reg(
nrf24_HANDLE,
REG_FEATURE,
1 + (NRF_DPL || NRF_ESB ?
4 :
1)); // Enables the W_TX_PAYLOAD_NOACK command, Disable Payload with ACK, set Dynamic Payload
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, NRF_Payload);
if(addrs.addr_count > 0)
nrf24_write_reg(
nrf24_HANDLE, REG_DYNPD, NRF_DPL ? (1 << 0) : 0); // Enable dynamic payload reg
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, NRF_Payload);
nrf24_write_reg(nrf24_HANDLE, REG_DYNPD, NRF_DPL ? (1 << 1) : 0);
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, NRF_Payload);
nrf24_write_reg(nrf24_HANDLE, REG_DYNPD, NRF_DPL ? (1 << 2) : 0);
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, NRF_Payload);
nrf24_write_reg(nrf24_HANDLE, REG_DYNPD, NRF_DPL ? (1 << 3) : 0);
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, NRF_Payload);
nrf24_write_reg(nrf24_HANDLE, REG_DYNPD, NRF_DPL ? (1 << 4) : 0);
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, NRF_Payload);
nrf24_write_reg(nrf24_HANDLE, REG_DYNPD, NRF_DPL ? (1 << 5) : 0);
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_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);
nrf24_flush_rx(nrf24_HANDLE);
nrf24_flush_tx(nrf24_HANDLE);
nrf24_set_idle(nrf24_HANDLE);
}
static void start_scanning() {
prepare_nrf24();
nrf24_set_rx_mode(nrf24_HANDLE);
start_time = furi_get_tick();
FURI_LOG_D(TAG, "Start scan: Ch=%d Rate=%d", NRF_channel, NRF_rate);
}
bool nrf24_read_newpacket() {
if(APP->log_arr == NULL) return false;
bool found = false;
uint8_t packetsize;
uint8_t packet[32] = {0};
uint8_t* ptr = APP->log_arr + log_arr_idx * LOG_REC_SIZE;
uint8_t status = nrf24_rxpacket(nrf24_HANDLE, ptr + 1, &packetsize, !NRF_DPL);
if(status & 0x40) {
*ptr = ((packetsize & 0x1F) << 3) | ((status >> 1) & 7); // payload size + pipe #
if(packetsize < 32) memset(ptr + packetsize + 1, 0, 32 - packetsize);
if(log_arr_idx < MAX_LOG_RECORDS - 1) {
log_arr_idx++;
} else {
if(log_to_file == 1 || log_to_file == 2) {
write_to_log_file(APP->storage);
clear_log();
} else {
memmove(APP->log_arr, APP->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);
notification_message(APP->notification, &sequence_blink_white_100);
found = true;
}
return found;
}
bool nrf24_send_packet() {
if(log_arr_idx == 0) return false;
if(!what_to_do) prepare_nrf24();
last_packet_send_st = nrf24_txpacket(
nrf24_HANDLE, APP->log_arr + view_log_arr_idx * LOG_REC_SIZE + 1, 32, false);
last_packet_send = view_log_arr_idx;
notification_message(
APP->notification,
last_packet_send_st ? &sequence_blink_blue_100 : &sequence_blink_red_100);
if(what_to_do) start_scanning();
return last_packet_send_st;
}
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), "Ch: %d", NRF_channel); // menu_selected = 1
canvas_draw_str(canvas, 10, 20, screen_buf);
if(NRF_ESB) {
strcpy(screen_buf, "ESB");
if(NRF_DPL) strcat(screen_buf, " DPL");
canvas_draw_str(canvas, 80, 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);
canvas_set_font(canvas, FontBatteryPercent);
snprintf(screen_buf, sizeof(screen_buf), "R:%d", NRF_Payload);
canvas_draw_str(canvas, 80, 30, screen_buf);
if(NRF_CRC == 1)
canvas_draw_str(canvas, 105, 30, "CRC1");
else if(NRF_CRC == 2)
canvas_draw_str(canvas, 105, 30, "CRC2");
canvas_set_font(canvas, FontSecondary);
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 ? "Append" :
"Clear"); // menu_selected = 4
canvas_draw_str(canvas, 10, 50, screen_buf);
snprintf(
screen_buf,
sizeof(screen_buf),
"%s (pipes: %d)",
what_to_do ? "Start scan" : "View log",
addrs.addr_count); // menu_selected = 5
canvas_draw_str(canvas, 10, 60, screen_buf);
canvas_draw_str(canvas, 0, menu_selected * 10 + 10, ">");
} else if(what_doing == 1) {
canvas_set_font(canvas, FontBatteryPercent); // 5x7 font, 9 lines
bool ch2 = false;
screen_buf[0] = '\0';
if(view_log_arr_x == 0) {
strcat(screen_buf, " ");
ch2 = true;
} else {
snprintf(screen_buf, sizeof(screen_buf), "<%d", view_log_arr_x);
if(view_log_arr_x < VIEW_LOG_MAX_X) ch2 = true;
}
snprintf(
screen_buf + strlen(screen_buf),
sizeof(screen_buf),
" %s ch: %d - %d.",
what_to_do ? "Read" : "View",
NRF_channel,
log_arr_idx);
canvas_draw_str(canvas, 0, 7, screen_buf);
if(ch2) canvas_draw_str(canvas, 121, 7, ">");
if(log_arr_idx) {
if(view_log_arr_idx >= log_arr_idx) view_log_arr_idx = log_arr_idx - 1;
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);
screen_buf[0] = (view_log_arr_idx & 7) != i ? ' ' :
last_packet_send != view_log_arr_idx ? '>' :
last_packet_send_st ? '*' :
'!';
screen_buf[1] = '\0';
char* ptr = (char*)APP->log_arr + (page + i) * LOG_REC_SIZE;
uint8_t dpl = *ptr++;
uint8_t pipe = dpl & 7;
dpl >>= 3;
if(dpl == 0) dpl = 32;
int count = dpl - view_log_arr_x;
if(count > 10) count = 10;
ptr += view_log_arr_x;
if(count > 0) {
if(view_log_arr_x == 0 && addrs.addr_count > 1) {
snprintf(screen_buf + strlen(screen_buf), sizeof(screen_buf), "%d-", pipe);
add_to_str_hex_bytes(screen_buf, ptr, count - 1);
} else {
add_to_str_hex_bytes(screen_buf, ptr, count);
}
}
canvas_draw_str(canvas, 3 * 5, 14 + i * 7, screen_buf);
}
}
} else {
canvas_set_font(canvas, FontBatteryPercent); // 5x7 font
if(addrs.addr_count > 0) {
snprintf(screen_buf, sizeof(screen_buf), "P0: ");
add_to_str_hex_bytes(screen_buf, (char*)addrs.addr_P0, addrs.addr_len);
canvas_draw_str(canvas, 0, 10, screen_buf);
}
if(addrs.addr_count > 1) {
snprintf(screen_buf, sizeof(screen_buf), "P1: ");
add_to_str_hex_bytes(screen_buf, (char*)addrs.addr_P1, addrs.addr_len);
canvas_draw_str(canvas, 0, 20, screen_buf);
}
if(addrs.addr_count > 2) {
canvas_draw_str(canvas, 0, 30, "P2: ");
snprintf(screen_buf, sizeof(screen_buf), "%02X", addrs.addr_P2);
canvas_draw_str(canvas, (4 + (addrs.addr_len - 1) * 2) * 5, 30, screen_buf);
}
if(addrs.addr_count > 3) {
canvas_draw_str(canvas, 0, 40, "P3: ");
snprintf(screen_buf, sizeof(screen_buf), "%02X", addrs.addr_P3);
canvas_draw_str(canvas, (4 + (addrs.addr_len - 1) * 2) * 5, 40, screen_buf);
}
if(addrs.addr_count > 4) {
canvas_draw_str(canvas, 0, 50, "P4: ");
snprintf(screen_buf, sizeof(screen_buf), "%02X", addrs.addr_P4);
canvas_draw_str(canvas, (4 + (addrs.addr_len - 1) * 2) * 5, 50, screen_buf);
}
if(addrs.addr_count > 5) {
canvas_draw_str(canvas, 0, 60, "P5: ");
snprintf(screen_buf, sizeof(screen_buf), "%02X", addrs.addr_P5);
canvas_draw_str(canvas, (4 + (addrs.addr_len - 1) * 2) * 5, 60, screen_buf);
}
}
release_mutex((ValueMutex*)ctx, plugin_state);
}
int32_t nrf24scan_app(void* p) {
UNUSED(p);
APP = malloc(sizeof(Nrf24Scan));
APP->event_queue = furi_message_queue_alloc(8, sizeof(PluginEvent));
APP->plugin_state = malloc(sizeof(PluginState));
ValueMutex state_mutex;
if(!init_mutex(&state_mutex, APP->plugin_state, sizeof(PluginState))) {
furi_message_queue_free(APP->event_queue);
FURI_LOG_E(TAG, "cannot create mutex");
free(APP->plugin_state);
return 255;
}
memset((uint8_t*)&addrs, 0, sizeof(addrs));
nrf24_init();
// Set system callbacks
APP->view_port = view_port_alloc();
view_port_draw_callback_set(APP->view_port, render_callback, &state_mutex);
view_port_input_callback_set(APP->view_port, input_callback, APP->event_queue);
// Open GUI and register view_port
APP->gui = furi_record_open(RECORD_GUI);
gui_add_view_port(APP->gui, APP->view_port, GuiLayerFullscreen);
APP->notification = furi_record_open(RECORD_NOTIFICATION);
APP->storage = furi_record_open(RECORD_STORAGE);
storage_common_mkdir(APP->storage, SCAN_APP_PATH_FOLDER);
Stream* file_stream = file_stream_alloc(APP->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)) {
uint8_t err = load_settings_file(file_stream);
if(!err)
strcpy(addr_file_name, ADDR_FILENAME);
else
snprintf(addr_file_name, sizeof(addr_file_name), "LOAD ERROR#%d", err);
} else {
strcpy(addr_file_name, "NONE");
}
//file_stream_close(file_stream);
stream_free(file_stream);
furi_string_free(path);
allocate_log_array();
PluginEvent event;
for(bool processing = true; processing;) {
FuriStatus event_status = furi_message_queue_get(APP->event_queue, &event, 100);
PluginState* plugin_state = (PluginState*)acquire_mutex_block(&state_mutex);
if(event_status == FuriStatusOk) {
// press events
if(event.type == EventTypeKey) {
//FURI_LOG_D(TAG, "Key: %d Type: %d Sec: %u", event.input.key, event.input.type, event.input.sequence);
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(what_doing == 1) {
view_log_arr_idx -= event.input.type == InputTypeRepeat ? 10 : 1;
if(view_log_arr_idx >= log_arr_idx) view_log_arr_idx = 0;
}
}
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(what_doing == 1) {
view_log_arr_idx += event.input.type == InputTypeRepeat ? 10 : 1;
if(view_log_arr_idx >= log_arr_idx) view_log_arr_idx = log_arr_idx - 1;
}
}
break;
case InputKeyRight:
if(event.input.type == InputTypePress || event.input.type == InputTypeRepeat) {
if(what_doing == 0) {
switch(menu_selected) {
case Menu_enter_channel:
NRF_channel += event.input.type == InputTypeRepeat ? 10 : 1;
if(NRF_channel > MAX_CHANNEL) NRF_channel = 0;
break;
case Menu_enter_rate:
NRF_rate++;
if(NRF_rate > 2) NRF_rate = 0;
break;
case Menu_enter_scan_period:
find_channel_period += event.input.type == InputTypeRepeat ? 10 :
1;
break;
case Menu_log:
if(++log_to_file > 2) log_to_file = -1;
break;
case Menu_ok:
what_to_do = !what_to_do;
break;
}
} else if(what_doing == 1) {
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 Menu_enter_channel:
NRF_channel -= event.input.type == InputTypeRepeat ? 10 : 1;
if(NRF_channel > MAX_CHANNEL) NRF_channel = MAX_CHANNEL;
break;
case Menu_enter_rate:
NRF_Payload -= event.input.type == InputTypeRepeat ? 10 : 1;
if(NRF_Payload == 0 || NRF_Payload > 32) NRF_Payload = 32;
break;
case Menu_enter_scan_period:
find_channel_period -= event.input.type == InputTypeRepeat ? 10 :
1;
if(find_channel_period < 0) find_channel_period = 0;
break;
case Menu_log:
if(--log_to_file < -1) log_to_file = 2;
break;
case Menu_ok:
what_to_do = !what_to_do;
break;
}
} else if(what_doing == 1) {
if(view_log_arr_x > 0) view_log_arr_x--;
}
}
break;
case InputKeyOk:
if(event.input.type == InputTypePress) {
if(what_doing == 0) {
switch(menu_selected) {
case Menu_open_file:
file_stream = file_stream_alloc(APP->storage);
if(select_settings_file(file_stream)) {
uint8_t err = load_settings_file(file_stream);
if(!err)
save_to_new_log = true;
else
snprintf(
addr_file_name,
sizeof(addr_file_name),
"LOAD ERROR#%d",
err);
file_stream_close(file_stream);
}
stream_free(file_stream);
break;
case Menu_enter_channel:
if(NRF_ESB) {
if(NRF_DPL)
NRF_DPL = NRF_ESB = 0;
else
NRF_DPL = 1;
} else
NRF_ESB = 1;
break;
case Menu_enter_rate:
if(++NRF_CRC > 2) NRF_CRC = 0;
break;
case Menu_ok:
if(what_to_do) {
if(addrs.addr_count) {
what_doing = 1;
if(log_to_file == -1) {
clear_log();
save_to_new_log = true;
} else if(log_to_file == 1)
save_to_new_log = true;
start_scanning();
}
} else
what_doing = 1;
key_press_seq_ok = event.input.sequence;
break;
}
}
} else if(event.input.type == InputTypeLong) {
if(what_doing == 0) {
if(menu_selected == Menu_log) { // Log
if(log_arr_idx && (log_to_file == 1 || log_to_file == 2)) {
write_to_log_file(APP->storage);
clear_log();
}
}
nrf24_set_idle(nrf24_HANDLE);
} else if(what_doing == 1) {
what_doing = 2;
}
} else if(event.input.type == InputTypeRelease) {
if(what_doing == 1 && key_press_seq_ok != event.input.sequence) { // Send
nrf24_send_packet();
}
}
break;
case InputKeyBack:
if(event.input.type == InputTypeLong)
processing = false;
else if(event.input.type == InputTypeRelease) {
if(what_doing) what_doing--;
if(what_doing == 0) nrf24_set_idle(nrf24_HANDLE);
;
}
break;
default:
break;
}
}
}
if(what_to_do) {
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(APP->view_port);
release_mutex(&state_mutex, plugin_state);
}
nrf24_set_idle(nrf24_HANDLE);
if(log_arr_idx && (log_to_file == 1 || log_to_file == 2)) {
write_to_log_file(APP->storage);
}
nrf24_deinit();
view_port_enabled_set(APP->view_port, false);
gui_remove_view_port(APP->gui, APP->view_port);
furi_record_close(RECORD_GUI);
furi_record_close(RECORD_NOTIFICATION);
furi_record_close(RECORD_STORAGE);
view_port_free(APP->view_port);
furi_message_queue_free(APP->event_queue);
free(APP->plugin_state);
if(APP->log_arr) free(APP->log_arr);
free(APP);
return 0;
}
Reference in New Issue View Git Blame Copy Permalink