274c12fc56
* Streams: string stream * String stream: updated insert/delete api * Streams: generic stream interface and string stream implementation * Streams: helpers for insert and delete_and_insert * FFF: now compatible with streams * MinUnit: introduced tests with arguments * FFF: stream access violation * Streams: copy data between streams * Streams: file stream * FFF: documentation * FFStream: documentation * FFF: alloc as file * MinUnit: support for nested tests * Streams: changed delete_and_insert, now it returns success flag. Added ability dump stream inner parameters and data to cout. * FFF: simplified file open function * Streams: unit tests * FFF: tests * Streams: declare cache_size constant as define, to allow variable modified arrays * FFF: lib moved to a separate folder * iButton: new FFF * RFID: new FFF * Animations: new FFF * IR: new FFF * NFC: new FFF * Flipper file format: delete lib * U2F: new FFF * Subghz: new FFF and streams * Streams: read line * Streams: split * FuriCore: implement memset with extra asserts * FuriCore: implement extra heap asserts without inventing memset * Scene manager: protected access to the scene id stack with a size check * NFC worker: dirty fix for issue where hal_nfc was busy on app start * Furi: update allocator to erase memory on allocation. Replace furi_alloc with malloc. * FuriCore: cleanup memmgr code. * Furi HAL: furi_hal_init is split into critical and non-critical parts. The critical part is currently clock and console. * Memmgr: added ability to track allocations and deallocations through console. * FFStream: some speedup * Streams, FF: minor fixes * Tests: restore * File stream: a slightly more thread-safe version of file_stream_delete_and_insert Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
423 lines
13 KiB
C
Executable File
423 lines
13 KiB
C
Executable File
#include "bt_test.h"
|
|
|
|
#include <gui/canvas.h>
|
|
#include <gui/elements.h>
|
|
#include <m-array.h>
|
|
#include <m-string.h>
|
|
#include <furi.h>
|
|
#include <stdint.h>
|
|
|
|
struct BtTestParam {
|
|
const char* label;
|
|
uint8_t current_value_index;
|
|
string_t current_value_text;
|
|
uint8_t values_count;
|
|
BtTestParamChangeCallback change_callback;
|
|
void* context;
|
|
};
|
|
|
|
ARRAY_DEF(BtTestParamArray, BtTestParam, M_POD_OPLIST);
|
|
|
|
struct BtTest {
|
|
View* view;
|
|
BtTestChangeStateCallback change_state_callback;
|
|
BtTestBackCallback back_callback;
|
|
void* context;
|
|
};
|
|
|
|
typedef struct {
|
|
BtTestState state;
|
|
BtTestParamArray_t params;
|
|
uint8_t position;
|
|
uint8_t window_position;
|
|
const char* message;
|
|
float rssi;
|
|
uint32_t packets_num_rx;
|
|
uint32_t packets_num_tx;
|
|
} BtTestModel;
|
|
|
|
#define BT_TEST_START_MESSAGE "Ok - Start"
|
|
#define BT_TEST_STOP_MESSAGE "Ok - Stop"
|
|
|
|
static void bt_test_process_up(BtTest* bt_test);
|
|
static void bt_test_process_down(BtTest* bt_test);
|
|
static void bt_test_process_left(BtTest* bt_test);
|
|
static void bt_test_process_right(BtTest* bt_test);
|
|
static void bt_test_process_ok(BtTest* bt_test);
|
|
static void bt_test_process_back(BtTest* bt_test);
|
|
|
|
static void bt_test_draw_callback(Canvas* canvas, void* _model) {
|
|
BtTestModel* model = _model;
|
|
char info_str[32];
|
|
|
|
const uint8_t param_height = 16;
|
|
const uint8_t param_width = 123;
|
|
|
|
canvas_clear(canvas);
|
|
|
|
uint8_t position = 0;
|
|
BtTestParamArray_it_t it;
|
|
|
|
canvas_set_font(canvas, FontSecondary);
|
|
for(BtTestParamArray_it(it, model->params); !BtTestParamArray_end_p(it);
|
|
BtTestParamArray_next(it)) {
|
|
uint8_t param_position = position - model->window_position;
|
|
uint8_t params_on_screen = 3;
|
|
uint8_t y_offset = 0;
|
|
|
|
if(param_position < params_on_screen) {
|
|
const BtTestParam* param = BtTestParamArray_cref(it);
|
|
uint8_t param_y = y_offset + (param_position * param_height);
|
|
uint8_t param_text_y = param_y + param_height - 4;
|
|
|
|
if(position == model->position) {
|
|
canvas_set_color(canvas, ColorBlack);
|
|
elements_slightly_rounded_box(
|
|
canvas, 0, param_y + 1, param_width, param_height - 2);
|
|
canvas_set_color(canvas, ColorWhite);
|
|
} else {
|
|
canvas_set_color(canvas, ColorBlack);
|
|
}
|
|
|
|
canvas_draw_str(canvas, 6, param_text_y, param->label);
|
|
|
|
if(param->current_value_index > 0) {
|
|
canvas_draw_str(canvas, 50, param_text_y, "<");
|
|
}
|
|
|
|
canvas_draw_str(canvas, 61, param_text_y, string_get_cstr(param->current_value_text));
|
|
|
|
if(param->current_value_index < (param->values_count - 1)) {
|
|
canvas_draw_str(canvas, 113, param_text_y, ">");
|
|
}
|
|
}
|
|
|
|
position++;
|
|
}
|
|
|
|
elements_scrollbar(canvas, model->position, BtTestParamArray_size(model->params));
|
|
canvas_draw_str(canvas, 6, 60, model->message);
|
|
if(model->state == BtTestStateStarted) {
|
|
if(model->rssi != 0.0f) {
|
|
snprintf(info_str, sizeof(info_str), "RSSI:%3.1f dB", model->rssi);
|
|
canvas_draw_str_aligned(canvas, 124, 60, AlignRight, AlignBottom, info_str);
|
|
}
|
|
} else if(model->state == BtTestStateStopped) {
|
|
if(model->packets_num_rx) {
|
|
snprintf(info_str, sizeof(info_str), "%ld pack rcv", model->packets_num_rx);
|
|
canvas_draw_str_aligned(canvas, 124, 60, AlignRight, AlignBottom, info_str);
|
|
} else if(model->packets_num_tx) {
|
|
snprintf(info_str, sizeof(info_str), "%ld pack sent", model->packets_num_tx);
|
|
canvas_draw_str_aligned(canvas, 124, 60, AlignRight, AlignBottom, info_str);
|
|
}
|
|
}
|
|
}
|
|
|
|
static bool bt_test_input_callback(InputEvent* event, void* context) {
|
|
BtTest* bt_test = context;
|
|
furi_assert(bt_test);
|
|
bool consumed = false;
|
|
|
|
if(event->type == InputTypeShort) {
|
|
switch(event->key) {
|
|
case InputKeyUp:
|
|
consumed = true;
|
|
bt_test_process_up(bt_test);
|
|
break;
|
|
case InputKeyDown:
|
|
consumed = true;
|
|
bt_test_process_down(bt_test);
|
|
break;
|
|
case InputKeyLeft:
|
|
consumed = true;
|
|
bt_test_process_left(bt_test);
|
|
break;
|
|
case InputKeyRight:
|
|
consumed = true;
|
|
bt_test_process_right(bt_test);
|
|
break;
|
|
case InputKeyOk:
|
|
consumed = true;
|
|
bt_test_process_ok(bt_test);
|
|
break;
|
|
case InputKeyBack:
|
|
consumed = false;
|
|
bt_test_process_back(bt_test);
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
}
|
|
|
|
return consumed;
|
|
}
|
|
|
|
void bt_test_process_up(BtTest* bt_test) {
|
|
with_view_model(
|
|
bt_test->view, (BtTestModel * model) {
|
|
uint8_t params_on_screen = 3;
|
|
if(model->position > 0) {
|
|
model->position--;
|
|
if(((model->position - model->window_position) < 1) &&
|
|
model->window_position > 0) {
|
|
model->window_position--;
|
|
}
|
|
} else {
|
|
model->position = BtTestParamArray_size(model->params) - 1;
|
|
if(model->position > (params_on_screen - 1)) {
|
|
model->window_position = model->position - (params_on_screen - 1);
|
|
}
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
|
|
void bt_test_process_down(BtTest* bt_test) {
|
|
with_view_model(
|
|
bt_test->view, (BtTestModel * model) {
|
|
uint8_t params_on_screen = 3;
|
|
if(model->position < (BtTestParamArray_size(model->params) - 1)) {
|
|
model->position++;
|
|
if((model->position - model->window_position) > (params_on_screen - 2) &&
|
|
model->window_position <
|
|
(BtTestParamArray_size(model->params) - params_on_screen)) {
|
|
model->window_position++;
|
|
}
|
|
} else {
|
|
model->position = 0;
|
|
model->window_position = 0;
|
|
}
|
|
return true;
|
|
});
|
|
}
|
|
|
|
BtTestParam* bt_test_get_selected_param(BtTestModel* model) {
|
|
BtTestParam* param = NULL;
|
|
|
|
BtTestParamArray_it_t it;
|
|
uint8_t position = 0;
|
|
for(BtTestParamArray_it(it, model->params); !BtTestParamArray_end_p(it);
|
|
BtTestParamArray_next(it)) {
|
|
if(position == model->position) {
|
|
break;
|
|
}
|
|
position++;
|
|
}
|
|
|
|
param = BtTestParamArray_ref(it);
|
|
|
|
furi_assert(param);
|
|
return param;
|
|
}
|
|
|
|
void bt_test_process_left(BtTest* bt_test) {
|
|
BtTestParam* param;
|
|
with_view_model(
|
|
bt_test->view, (BtTestModel * model) {
|
|
param = bt_test_get_selected_param(model);
|
|
if(param->current_value_index > 0) {
|
|
param->current_value_index--;
|
|
if(param->change_callback) {
|
|
model->state = BtTestStateStopped;
|
|
model->message = BT_TEST_START_MESSAGE;
|
|
model->rssi = 0.0f;
|
|
model->packets_num_rx = 0;
|
|
model->packets_num_tx = 0;
|
|
}
|
|
}
|
|
return true;
|
|
});
|
|
if(param->change_callback) {
|
|
param->change_callback(param);
|
|
}
|
|
}
|
|
|
|
void bt_test_process_right(BtTest* bt_test) {
|
|
BtTestParam* param;
|
|
with_view_model(
|
|
bt_test->view, (BtTestModel * model) {
|
|
param = bt_test_get_selected_param(model);
|
|
if(param->current_value_index < (param->values_count - 1)) {
|
|
param->current_value_index++;
|
|
if(param->change_callback) {
|
|
model->state = BtTestStateStopped;
|
|
model->message = BT_TEST_START_MESSAGE;
|
|
model->rssi = 0.0f;
|
|
model->packets_num_rx = 0;
|
|
model->packets_num_tx = 0;
|
|
}
|
|
}
|
|
return true;
|
|
});
|
|
if(param->change_callback) {
|
|
param->change_callback(param);
|
|
}
|
|
}
|
|
|
|
void bt_test_process_ok(BtTest* bt_test) {
|
|
BtTestState state;
|
|
with_view_model(
|
|
bt_test->view, (BtTestModel * model) {
|
|
if(model->state == BtTestStateStarted) {
|
|
model->state = BtTestStateStopped;
|
|
model->message = BT_TEST_START_MESSAGE;
|
|
model->rssi = 0.0f;
|
|
model->packets_num_rx = 0;
|
|
model->packets_num_tx = 0;
|
|
} else if(model->state == BtTestStateStopped) {
|
|
model->state = BtTestStateStarted;
|
|
model->message = BT_TEST_STOP_MESSAGE;
|
|
}
|
|
state = model->state;
|
|
return true;
|
|
});
|
|
if(bt_test->change_state_callback) {
|
|
bt_test->change_state_callback(state, bt_test->context);
|
|
}
|
|
}
|
|
|
|
void bt_test_process_back(BtTest* bt_test) {
|
|
with_view_model(
|
|
bt_test->view, (BtTestModel * model) {
|
|
model->state = BtTestStateStopped;
|
|
model->rssi = 0.0f;
|
|
model->packets_num_rx = 0;
|
|
model->packets_num_tx = 0;
|
|
return false;
|
|
});
|
|
if(bt_test->back_callback) {
|
|
bt_test->back_callback(bt_test->context);
|
|
}
|
|
}
|
|
|
|
BtTest* bt_test_alloc() {
|
|
BtTest* bt_test = malloc(sizeof(BtTest));
|
|
bt_test->view = view_alloc();
|
|
view_set_context(bt_test->view, bt_test);
|
|
view_allocate_model(bt_test->view, ViewModelTypeLocking, sizeof(BtTestModel));
|
|
view_set_draw_callback(bt_test->view, bt_test_draw_callback);
|
|
view_set_input_callback(bt_test->view, bt_test_input_callback);
|
|
|
|
with_view_model(
|
|
bt_test->view, (BtTestModel * model) {
|
|
model->state = BtTestStateStopped;
|
|
model->message = "Ok - Start";
|
|
BtTestParamArray_init(model->params);
|
|
model->position = 0;
|
|
model->window_position = 0;
|
|
model->rssi = 0.0f;
|
|
model->packets_num_tx = 0;
|
|
model->packets_num_rx = 0;
|
|
return true;
|
|
});
|
|
|
|
return bt_test;
|
|
}
|
|
|
|
void bt_test_free(BtTest* bt_test) {
|
|
furi_assert(bt_test);
|
|
|
|
with_view_model(
|
|
bt_test->view, (BtTestModel * model) {
|
|
BtTestParamArray_it_t it;
|
|
for(BtTestParamArray_it(it, model->params); !BtTestParamArray_end_p(it);
|
|
BtTestParamArray_next(it)) {
|
|
string_clear(BtTestParamArray_ref(it)->current_value_text);
|
|
}
|
|
BtTestParamArray_clear(model->params);
|
|
return false;
|
|
});
|
|
view_free(bt_test->view);
|
|
free(bt_test);
|
|
}
|
|
|
|
View* bt_test_get_view(BtTest* bt_test) {
|
|
furi_assert(bt_test);
|
|
return bt_test->view;
|
|
}
|
|
|
|
BtTestParam* bt_test_param_add(
|
|
BtTest* bt_test,
|
|
const char* label,
|
|
uint8_t values_count,
|
|
BtTestParamChangeCallback change_callback,
|
|
void* context) {
|
|
BtTestParam* param = NULL;
|
|
furi_assert(label);
|
|
furi_assert(bt_test);
|
|
|
|
with_view_model(
|
|
bt_test->view, (BtTestModel * model) {
|
|
param = BtTestParamArray_push_new(model->params);
|
|
param->label = label;
|
|
param->values_count = values_count;
|
|
param->change_callback = change_callback;
|
|
param->context = context;
|
|
param->current_value_index = 0;
|
|
string_init(param->current_value_text);
|
|
return true;
|
|
});
|
|
|
|
return param;
|
|
}
|
|
|
|
void bt_test_set_rssi(BtTest* bt_test, float rssi) {
|
|
furi_assert(bt_test);
|
|
with_view_model(
|
|
bt_test->view, (BtTestModel * model) {
|
|
model->rssi = rssi;
|
|
return true;
|
|
});
|
|
}
|
|
|
|
void bt_test_set_packets_tx(BtTest* bt_test, uint32_t packets_num) {
|
|
furi_assert(bt_test);
|
|
with_view_model(
|
|
bt_test->view, (BtTestModel * model) {
|
|
model->packets_num_tx = packets_num;
|
|
return true;
|
|
});
|
|
}
|
|
|
|
void bt_test_set_packets_rx(BtTest* bt_test, uint32_t packets_num) {
|
|
furi_assert(bt_test);
|
|
with_view_model(
|
|
bt_test->view, (BtTestModel * model) {
|
|
model->packets_num_rx = packets_num;
|
|
return true;
|
|
});
|
|
}
|
|
|
|
void bt_test_set_change_state_callback(BtTest* bt_test, BtTestChangeStateCallback callback) {
|
|
furi_assert(bt_test);
|
|
furi_assert(callback);
|
|
bt_test->change_state_callback = callback;
|
|
}
|
|
|
|
void bt_test_set_back_callback(BtTest* bt_test, BtTestBackCallback callback) {
|
|
furi_assert(bt_test);
|
|
furi_assert(callback);
|
|
bt_test->back_callback = callback;
|
|
}
|
|
|
|
void bt_test_set_context(BtTest* bt_test, void* context) {
|
|
furi_assert(bt_test);
|
|
bt_test->context = context;
|
|
}
|
|
|
|
void bt_test_set_current_value_index(BtTestParam* param, uint8_t current_value_index) {
|
|
param->current_value_index = current_value_index;
|
|
}
|
|
|
|
void bt_test_set_current_value_text(BtTestParam* param, const char* current_value_text) {
|
|
string_set_str(param->current_value_text, current_value_text);
|
|
}
|
|
|
|
uint8_t bt_test_get_current_value_index(BtTestParam* param) {
|
|
return param->current_value_index;
|
|
}
|
|
|
|
void* bt_test_get_context(BtTestParam* param) {
|
|
return param->context;
|
|
}
|