DarkFlippers/unleashed-firmware
1
1
Fork 0
mirror of https://github.com/DarkFlippers/unleashed-firmware.git synced 2024-12-23 13:21:44 +03:00
Code Issues Projects Releases Wiki Activity

Merge branch 'fz-dev' into dev

Browse Source
This commit is contained in:
MX 2022-10-07 17:24:20 +03:00
commit bdd052937b
No known key found for this signature in database
GPG Key ID: 6C4C311DFD4B4AB5
95 changed files with 585 additions and 359 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
applications/debug/uart_echo/uart_echo.c
View File

@ -3,7 +3,6 @@
#include <notification/notification.h>
#include <notification/notification_messages.h>
#include <gui/elements.h>
#include <stream_buffer.h>
#include <furi_hal_uart.h>
#include <furi_hal_console.h>
#include <gui/view_dispatcher.h>
@ -20,7 +19,7 @@ typedef struct {
ViewDispatcher* view_dispatcher;
View* view;
FuriThread* worker_thread;
StreamBufferHandle_t rx_stream;
FuriStreamBuffer* rx_stream;
} UartEchoApp;
typedef struct {
@ -92,13 +91,11 @@ static uint32_t uart_echo_exit(void* context) {
static void uart_echo_on_irq_cb(UartIrqEvent ev, uint8_t data, void* context) {
furi_assert(context);
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
UartEchoApp* app = context;
if(ev == UartIrqEventRXNE) {
xStreamBufferSendFromISR(app->rx_stream, &data, 1, &xHigherPriorityTaskWoken);
furi_stream_buffer_send(app->rx_stream, &data, 1, 0);
furi_thread_flags_set(furi_thread_get_id(app->worker_thread), WorkerEventRx);
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
}
@ -158,7 +155,7 @@ static int32_t uart_echo_worker(void* context) {
size_t length = 0;
do {
uint8_t data[64];
length = xStreamBufferReceive(app->rx_stream, data, 64, 0);
length = furi_stream_buffer_receive(app->rx_stream, data, 64, 0);
if(length > 0) {
furi_hal_uart_tx(FuriHalUartIdUSART1, data, length);
with_view_model(
@ -186,7 +183,7 @@ static int32_t uart_echo_worker(void* context) {
static UartEchoApp* uart_echo_app_alloc() {
UartEchoApp* app = malloc(sizeof(UartEchoApp));
app->rx_stream = xStreamBufferCreate(2048, 1);
app->rx_stream = furi_stream_buffer_alloc(2048, 1);
// Gui
app->gui = furi_record_open(RECORD_GUI);
@ -260,7 +257,7 @@ static void uart_echo_app_free(UartEchoApp* app) {
furi_record_close(RECORD_NOTIFICATION);
app->gui = NULL;
vStreamBufferDelete(app->rx_stream);
furi_stream_buffer_free(app->rx_stream);
// Free rest
free(app);

10
applications/debug/unit_tests/infrared/infrared_test.c
View File

@ -221,13 +221,13 @@ static void infrared_test_run_encoder(InfraredProtocol protocol, uint32_t test_i
const char* protocol_name = infrared_get_protocol_name(protocol);
mu_assert(infrared_test_prepare_file(protocol_name), "Failed to prepare test file");
furi_string_printf(buf, "encoder_input%d", test_index);
furi_string_printf(buf, "encoder_input%ld", test_index);
mu_assert(
infrared_test_load_messages(
test->ff, furi_string_get_cstr(buf), &input_messages, &input_messages_count),
"Failed to load messages from file");
furi_string_printf(buf, "encoder_expected%d", test_index);
furi_string_printf(buf, "encoder_expected%ld", test_index);
mu_assert(
infrared_test_load_raw_signal(
test->ff, furi_string_get_cstr(buf), &expected_timings, &expected_timings_count),
@ -277,7 +277,7 @@ static void infrared_test_run_encoder_decoder(InfraredProtocol protocol, uint32_
const char* protocol_name = infrared_get_protocol_name(protocol);
mu_assert(infrared_test_prepare_file(protocol_name), "Failed to prepare test file");
furi_string_printf(buf, "encoder_decoder_input%d", test_index);
furi_string_printf(buf, "encoder_decoder_input%ld", test_index);
mu_assert(
infrared_test_load_messages(
test->ff, furi_string_get_cstr(buf), &input_messages, &input_messages_count),
@ -336,13 +336,13 @@ static void infrared_test_run_decoder(InfraredProtocol protocol, uint32_t test_i
infrared_test_prepare_file(infrared_get_protocol_name(protocol)),
"Failed to prepare test file");
furi_string_printf(buf, "decoder_input%d", test_index);
furi_string_printf(buf, "decoder_input%ld", test_index);
mu_assert(
infrared_test_load_raw_signal(
test->ff, furi_string_get_cstr(buf), &timings, &timings_count),
"Failed to load raw signal from file");
furi_string_printf(buf, "decoder_expected%d", test_index);
furi_string_printf(buf, "decoder_expected%ld", test_index);
mu_assert(
infrared_test_load_messages(
test->ff, furi_string_get_cstr(buf), &messages, &messages_count),

10
applications/debug/unit_tests/nfc/nfc_test.c
View File

@ -112,7 +112,7 @@ static bool nfc_test_digital_signal_test_encode(
// Check timings
if(time > encode_max_time) {
FURI_LOG_E(
TAG, "Encoding time: %d us while accepted value: %d us", time, encode_max_time);
TAG, "Encoding time: %ld us while accepted value: %ld us", time, encode_max_time);
break;
}
@ -132,7 +132,7 @@ static bool nfc_test_digital_signal_test_encode(
ref_timings_sum += ref[i];
if(timings_diff > timing_tolerance) {
FURI_LOG_E(
TAG, "Too big differece in %d timings. Ref: %d, DUT: %d", i, ref[i], dut[i]);
TAG, "Too big differece in %d timings. Ref: %ld, DUT: %ld", i, ref[i], dut[i]);
timing_check_success = false;
break;
}
@ -143,16 +143,16 @@ static bool nfc_test_digital_signal_test_encode(
if(sum_diff > timings_sum_tolerance) {
FURI_LOG_E(
TAG,
"Too big difference in timings sum. Ref: %d, DUT: %d",
"Too big difference in timings sum. Ref: %ld, DUT: %ld",
ref_timings_sum,
dut_timings_sum);
break;
}
FURI_LOG_I(TAG, "Encoding time: %d us. Acceptable time: %d us", time, encode_max_time);
FURI_LOG_I(TAG, "Encoding time: %ld us. Acceptable time: %ld us", time, encode_max_time);
FURI_LOG_I(
TAG,
"Timings sum difference: %d [1/64MHZ]. Acceptable difference: %d [1/64MHz]",
"Timings sum difference: %ld [1/64MHZ]. Acceptable difference: %ld [1/64MHz]",
sum_diff,
timings_sum_tolerance);
success = true;

18
applications/debug/unit_tests/rpc/rpc_test.c
View File

@ -10,7 +10,6 @@
#include <furi.h>
#include "../minunit.h"
#include <stdint.h>
#include <stream_buffer.h>
#include <pb.h>
#include <pb_encode.h>
#include <m-list.h>
@ -34,7 +33,7 @@ static uint32_t command_id = 0;
typedef struct {
RpcSession* session;
StreamBufferHandle_t output_stream;
FuriStreamBuffer* output_stream;
SemaphoreHandle_t close_session_semaphore;
SemaphoreHandle_t terminate_semaphore;
TickType_t timeout;
@ -90,7 +89,7 @@ static void test_rpc_setup(void) {
}
furi_check(rpc_session[0].session);
rpc_session[0].output_stream = xStreamBufferCreate(1000, 1);
rpc_session[0].output_stream = furi_stream_buffer_alloc(1000, 1);
rpc_session_set_send_bytes_callback(rpc_session[0].session, output_bytes_callback);
rpc_session[0].close_session_semaphore = xSemaphoreCreateBinary();
rpc_session[0].terminate_semaphore = xSemaphoreCreateBinary();
@ -110,7 +109,7 @@ static void test_rpc_setup_second_session(void) {
}
furi_check(rpc_session[1].session);
rpc_session[1].output_stream = xStreamBufferCreate(1000, 1);
rpc_session[1].output_stream = furi_stream_buffer_alloc(1000, 1);
rpc_session_set_send_bytes_callback(rpc_session[1].session, output_bytes_callback);
rpc_session[1].close_session_semaphore = xSemaphoreCreateBinary();
rpc_session[1].terminate_semaphore = xSemaphoreCreateBinary();
@ -126,7 +125,7 @@ static void test_rpc_teardown(void) {
rpc_session_close(rpc_session[0].session);
furi_check(xSemaphoreTake(rpc_session[0].terminate_semaphore, portMAX_DELAY));
furi_record_close(RECORD_RPC);
vStreamBufferDelete(rpc_session[0].output_stream);
furi_stream_buffer_free(rpc_session[0].output_stream);
vSemaphoreDelete(rpc_session[0].close_session_semaphore);
vSemaphoreDelete(rpc_session[0].terminate_semaphore);
++command_id;
@ -141,7 +140,7 @@ static void test_rpc_teardown_second_session(void) {
xSemaphoreTake(rpc_session[1].terminate_semaphore, 0);
rpc_session_close(rpc_session[1].session);
furi_check(xSemaphoreTake(rpc_session[1].terminate_semaphore, portMAX_DELAY));
vStreamBufferDelete(rpc_session[1].output_stream);
furi_stream_buffer_free(rpc_session[1].output_stream);
vSemaphoreDelete(rpc_session[1].close_session_semaphore);
vSemaphoreDelete(rpc_session[1].terminate_semaphore);
++command_id;
@ -268,8 +267,8 @@ static PB_CommandStatus test_rpc_storage_get_file_error(File* file) {
static void output_bytes_callback(void* ctx, uint8_t* got_bytes, size_t got_size) {
RpcSessionContext* callbacks_context = ctx;
size_t bytes_sent =
xStreamBufferSend(callbacks_context->output_stream, got_bytes, got_size, FuriWaitForever);
size_t bytes_sent = furi_stream_buffer_send(
callbacks_context->output_stream, got_bytes, got_size, FuriWaitForever);
(void)bytes_sent;
furi_check(bytes_sent == got_size);
}
@ -534,7 +533,8 @@ static bool test_rpc_pb_stream_read(pb_istream_t* istream, pb_byte_t* buf, size_
TickType_t now = xTaskGetTickCount();
int32_t time_left = session_context->timeout - now;
time_left = MAX(time_left, 0);
bytes_received = xStreamBufferReceive(session_context->output_stream, buf, count, time_left);
bytes_received =
furi_stream_buffer_receive(session_context->output_stream, buf, count, time_left);
return (count == bytes_received);
}

4
applications/main/archive/helpers/archive_favorites.h
View File

@ -7,8 +7,8 @@
uint16_t archive_favorites_count(void* context);
bool archive_favorites_read(void* context);
bool archive_favorites_delete(const char* format, ...);
bool archive_is_favorite(const char* format, ...);
bool archive_favorites_delete(const char* format, ...) _ATTRIBUTE((__format__(__printf__, 1, 2)));
bool archive_is_favorite(const char* format, ...) _ATTRIBUTE((__format__(__printf__, 1, 2)));
bool archive_favorites_rename(const char* src, const char* dst);
void archive_add_to_favorites(const char* file_path);
void archive_favorites_save(void* context);

6
applications/main/archive/helpers/archive_files.h
View File

@ -87,6 +87,8 @@ ARRAY_DEF(
void archive_set_file_type(ArchiveFile_t* file, const char* path, bool is_folder, bool is_app);
bool archive_get_items(void* context, const char* path);
void archive_file_append(const char* path, const char* format, ...);
void archive_delete_file(void* context, const char* format, ...);
void archive_file_append(const char* path, const char* format, ...)
_ATTRIBUTE((__format__(__printf__, 2, 3)));
void archive_delete_file(void* context, const char* format, ...)
_ATTRIBUTE((__format__(__printf__, 2, 3)));
FS_Error archive_rename_file_or_dir(void* context, const char* src_path, const char* dst_path);

6
applications/main/bad_usb/bad_usb_script.c
View File

@ -332,7 +332,7 @@ static bool ducky_set_usb_id(BadUsbScript* bad_usb, const char* line) {
}
FURI_LOG_D(
WORKER_TAG,
"set id: %04X:%04X mfr:%s product:%s",
"set id: %04lX:%04lX mfr:%s product:%s",
bad_usb->hid_cfg.vid,
bad_usb->hid_cfg.pid,
bad_usb->hid_cfg.manuf,
@ -397,7 +397,7 @@ static int32_t ducky_script_execute_next(BadUsbScript* bad_usb, File* script_fil
return 0;
} else if(delay_val < 0) { // Script error
bad_usb->st.error_line = bad_usb->st.line_cur - 1;
FURI_LOG_E(WORKER_TAG, "Unknown command at line %lu", bad_usb->st.line_cur - 1);
FURI_LOG_E(WORKER_TAG, "Unknown command at line %u", bad_usb->st.line_cur - 1);
return SCRIPT_STATE_ERROR;
} else {
return (delay_val + bad_usb->defdelay);
@ -429,7 +429,7 @@ static int32_t ducky_script_execute_next(BadUsbScript* bad_usb, File* script_fil
delay_val = ducky_parse_line(bad_usb, bad_usb->line);
if(delay_val < 0) {
bad_usb->st.error_line = bad_usb->st.line_cur;
FURI_LOG_E(WORKER_TAG, "Unknown command at line %lu", bad_usb->st.line_cur);
FURI_LOG_E(WORKER_TAG, "Unknown command at line %u", bad_usb->st.line_cur);
return SCRIPT_STATE_ERROR;
} else {
return (delay_val + bad_usb->defdelay);

2
applications/main/bad_usb/views/bad_usb_view.c
View File

@ -112,7 +112,7 @@ static void bad_usb_draw_callback(Canvas* canvas, void* _model) {
furi_string_reset(disp_str);
canvas_draw_icon(canvas, 117, 26, &I_Percent_10x14);
canvas_set_font(canvas, FontSecondary);
furi_string_printf(disp_str, "delay %us", model->state.delay_remain);
furi_string_printf(disp_str, "delay %lus", model->state.delay_remain);
canvas_draw_str_aligned(
canvas, 127, 50, AlignRight, AlignBottom, furi_string_get_cstr(disp_str));
furi_string_reset(disp_str);

2
applications/main/fap_loader/elf_cpp/elf_hashtable.cpp
View File

@ -31,7 +31,7 @@ bool elf_resolve_from_hashtable(const char* name, Elf32_Addr* address) {
auto find_res = std::lower_bound(elf_api_table.cbegin(), elf_api_table.cend(), key);
if((find_res == elf_api_table.cend() || (find_res->hash != gnu_sym_hash))) {
FURI_LOG_W(TAG, "Cant find symbol '%s' (hash %x)!", name, gnu_sym_hash);
FURI_LOG_W(TAG, "Cant find symbol '%s' (hash %lx)!", name, gnu_sym_hash);
result = false;
} else {
result = true;

17
applications/main/gpio/usb_uart_bridge.c
View File

@ -1,6 +1,5 @@
#include "usb_uart_bridge.h"
#include "furi_hal.h"
#include <stream_buffer.h>
#include <furi_hal_usb_cdc.h>
#include "usb_cdc.h"
#include "cli/cli_vcp.h"
@ -43,7 +42,7 @@ struct UsbUartBridge {
FuriThread* thread;
FuriThread* tx_thread;
StreamBufferHandle_t rx_stream;
FuriStreamBuffer* rx_stream;
FuriMutex* usb_mutex;
@ -74,12 +73,10 @@ static int32_t usb_uart_tx_thread(void* context);
static void usb_uart_on_irq_cb(UartIrqEvent ev, uint8_t data, void* context) {
UsbUartBridge* usb_uart = (UsbUartBridge*)context;
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
if(ev == UartIrqEventRXNE) {
xStreamBufferSendFromISR(usb_uart->rx_stream, &data, 1, &xHigherPriorityTaskWoken);
furi_stream_buffer_send(usb_uart->rx_stream, &data, 1, 0);
furi_thread_flags_set(furi_thread_get_id(usb_uart->thread), WorkerEvtRxDone);
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
}
@ -156,7 +153,7 @@ static int32_t usb_uart_worker(void* context) {
memcpy(&usb_uart->cfg, &usb_uart->cfg_new, sizeof(UsbUartConfig));
usb_uart->rx_stream = xStreamBufferCreate(USB_UART_RX_BUF_SIZE, 1);
usb_uart->rx_stream = furi_stream_buffer_alloc(USB_UART_RX_BUF_SIZE, 1);
usb_uart->tx_sem = furi_semaphore_alloc(1, 1);
usb_uart->usb_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
@ -189,8 +186,8 @@ static int32_t usb_uart_worker(void* context) {
furi_check((events & FuriFlagError) == 0);
if(events & WorkerEvtStop) break;
if(events & WorkerEvtRxDone) {
size_t len =
xStreamBufferReceive(usb_uart->rx_stream, usb_uart->rx_buf, USB_CDC_PKT_LEN, 0);
size_t len = furi_stream_buffer_receive(
usb_uart->rx_stream, usb_uart->rx_buf, USB_CDC_PKT_LEN, 0);
if(len > 0) {
if(furi_semaphore_acquire(usb_uart->tx_sem, 100) == FuriStatusOk) {
usb_uart->st.rx_cnt += len;
@ -199,7 +196,7 @@ static int32_t usb_uart_worker(void* context) {
furi_hal_cdc_send(usb_uart->cfg.vcp_ch, usb_uart->rx_buf, len);
furi_check(furi_mutex_release(usb_uart->usb_mutex) == FuriStatusOk);
} else {
xStreamBufferReset(usb_uart->rx_stream);
furi_stream_buffer_reset(usb_uart->rx_stream);
}
}
}
@ -270,7 +267,7 @@ static int32_t usb_uart_worker(void* context) {
furi_thread_join(usb_uart->tx_thread);
furi_thread_free(usb_uart->tx_thread);
vStreamBufferDelete(usb_uart->rx_stream);
furi_stream_buffer_free(usb_uart->rx_stream);
furi_mutex_free(usb_uart->usb_mutex);
furi_semaphore_free(usb_uart->tx_sem);

4
applications/main/infrared/infrared.c
View File

@ -92,14 +92,14 @@ static void infrared_find_vacant_remote_name(FuriString* name, const char* path)
uint32_t i = 1;
do {
furi_string_printf(
path_temp, "%s%u%s", furi_string_get_cstr(base_path), ++i, INFRARED_APP_EXTENSION);
path_temp, "%s%lu%s", furi_string_get_cstr(base_path), ++i, INFRARED_APP_EXTENSION);
status = storage_common_stat(storage, furi_string_get_cstr(path_temp), NULL);
} while(status == FSE_OK);
furi_string_free(path_temp);
if(status == FSE_NOT_EXIST) {
furi_string_cat_printf(name, "%u", i);
furi_string_cat_printf(name, "%lu", i);
}
}

4
applications/main/infrared/infrared_signal.c
View File

@ -61,7 +61,7 @@ static bool infrared_signal_is_raw_valid(InfraredRawSignal* raw) {
if((raw->frequency > INFRARED_MAX_FREQUENCY) || (raw->frequency < INFRARED_MIN_FREQUENCY)) {
FURI_LOG_E(
TAG,
"Frequency is out of range (%lX - %lX): %lX",
"Frequency is out of range (%X - %X): %lX",
INFRARED_MIN_FREQUENCY,
INFRARED_MAX_FREQUENCY,
raw->frequency);
@ -74,7 +74,7 @@ static bool infrared_signal_is_raw_valid(InfraredRawSignal* raw) {
} else if((raw->timings_size <= 0) || (raw->timings_size > MAX_TIMINGS_AMOUNT)) {
FURI_LOG_E(
TAG,
"Timings amount is out of range (0 - %lX): %lX",
"Timings amount is out of range (0 - %X): %X",
MAX_TIMINGS_AMOUNT,
raw->timings_size);
return false;

2
applications/main/nfc/scenes/nfc_scene_mf_classic_keys_list.c
View File

@ -27,7 +27,7 @@ void nfc_scene_mf_classic_keys_list_prepare(Nfc* nfc, MfClassicDict* dict) {
char* current_key = (char*)malloc(sizeof(char) * 13);
strncpy(current_key, furi_string_get_cstr(temp_key), 12);
MfClassicUserKeys_push_back(nfc->mfc_key_strs, current_key);
FURI_LOG_D("ListKeys", "Key %d: %s", index, current_key);
FURI_LOG_D("ListKeys", "Key %ld: %s", index, current_key);
submenu_add_item(
submenu, current_key, index++, nfc_scene_mf_classic_keys_list_submenu_callback, nfc);
}

4
applications/main/nfc/scenes/nfc_scene_mf_desfire_read_success.c
View File

@ -28,11 +28,11 @@ void nfc_scene_mf_desfire_read_success_on_enter(void* context) {
uint32_t bytes_total = 1 << (data->version.sw_storage >> 1);
uint32_t bytes_free = data->free_memory ? data->free_memory->bytes : 0;
furi_string_cat_printf(temp_str, "\n%d", bytes_total);
furi_string_cat_printf(temp_str, "\n%ld", bytes_total);
if(data->version.sw_storage & 1) {
furi_string_push_back(temp_str, '+');
}
furi_string_cat_printf(temp_str, " bytes, %d bytes free\n", bytes_free);
furi_string_cat_printf(temp_str, " bytes, %ld bytes free\n", bytes_free);
uint16_t n_apps = 0;
uint16_t n_files = 0;

4
applications/main/nfc/scenes/nfc_scene_nfc_data_info.c
View File

@ -59,11 +59,11 @@ void nfc_scene_nfc_data_info_on_enter(void* context) {
MifareDesfireData* data = &dev_data->mf_df_data;
uint32_t bytes_total = 1 << (data->version.sw_storage >> 1);
uint32_t bytes_free = data->free_memory ? data->free_memory->bytes : 0;
furi_string_cat_printf(temp_str, "\n%d", bytes_total);
furi_string_cat_printf(temp_str, "\n%ld", bytes_total);
if(data->version.sw_storage & 1) {
furi_string_push_back(temp_str, '+');
}
furi_string_cat_printf(temp_str, " bytes, %d bytes free\n", bytes_free);
furi_string_cat_printf(temp_str, " bytes, %ld bytes free\n", bytes_free);
uint16_t n_apps = 0;
uint16_t n_files = 0;

8
applications/main/subghz/helpers/subghz_frequency_analyzer_worker.c
View File

@ -148,7 +148,7 @@ static int32_t subghz_frequency_analyzer_worker_thread(void* context) {
FURI_LOG_T(
TAG,
"RSSI: avg %f, max %f at %u, min %f",
"RSSI: avg %f, max %f at %lu, min %f",
(double)(rssi_avg / rssi_avg_samples),
(double)frequency_rssi.rssi_coarse,
frequency_rssi.frequency_coarse,
@ -179,7 +179,7 @@ static int32_t subghz_frequency_analyzer_worker_thread(void* context) {
rssi = furi_hal_subghz_get_rssi();
FURI_LOG_T(TAG, "#:%u:%f", frequency, (double)rssi);
FURI_LOG_T(TAG, "#:%lu:%f", frequency, (double)rssi);
if(frequency_rssi.rssi_fine < rssi) {
frequency_rssi.rssi_fine = rssi;
@ -192,7 +192,7 @@ static int32_t subghz_frequency_analyzer_worker_thread(void* context) {
// Deliver results fine
if(frequency_rssi.rssi_fine > instance->trigger_level) {
FURI_LOG_D(
TAG, "=:%u:%f", frequency_rssi.frequency_fine, (double)frequency_rssi.rssi_fine);
TAG, "=:%lu:%f", frequency_rssi.frequency_fine, (double)frequency_rssi.rssi_fine);
instance->sample_hold_counter = 20;
if(instance->filVal) {
@ -210,7 +210,7 @@ static int32_t subghz_frequency_analyzer_worker_thread(void* context) {
(instance->sample_hold_counter < 10)) {
FURI_LOG_D(
TAG,
"~:%u:%f",
"~:%lu:%f",
frequency_rssi.frequency_coarse,
(double)frequency_rssi.rssi_coarse);

22
applications/main/subghz/subghz_cli.c
View File

@ -2,7 +2,6 @@
#include <furi.h>
#include <furi_hal.h>
#include <stream_buffer.h>
#include <lib/toolbox/args.h>
#include <lib/subghz/subghz_keystore.h>
@ -147,8 +146,8 @@ void subghz_cli_command_tx(Cli* cli, FuriString* args, void* context) {
"Protocol: Princeton\n"
"Bit: 24\n"
"Key: 00 00 00 00 00 %02X %02X %02X\n"
"TE: %d\n"
"Repeat: %d\n",
"TE: %ld\n"
"Repeat: %ld\n",
(uint8_t)((key >> 16) & 0xFF),
(uint8_t)((key >> 8) & 0xFF),
(uint8_t)(key & 0xFF),
@ -189,23 +188,21 @@ void subghz_cli_command_tx(Cli* cli, FuriString* args, void* context) {
typedef struct {
volatile bool overrun;
StreamBufferHandle_t stream;
FuriStreamBuffer* stream;
size_t packet_count;
} SubGhzCliCommandRx;
static void subghz_cli_command_rx_capture_callback(bool level, uint32_t duration, void* context) {
SubGhzCliCommandRx* instance = context;
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
LevelDuration level_duration = level_duration_make(level, duration);
if(instance->overrun) {
instance->overrun = false;
level_duration = level_duration_reset();
}
size_t ret = xStreamBufferSendFromISR(
instance->stream, &level_duration, sizeof(LevelDuration), &xHigherPriorityTaskWoken);
size_t ret =
furi_stream_buffer_send(instance->stream, &level_duration, sizeof(LevelDuration), 0);
if(sizeof(LevelDuration) != ret) instance->overrun = true;
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
static void subghz_cli_command_rx_callback(
@ -244,7 +241,8 @@ void subghz_cli_command_rx(Cli* cli, FuriString* args, void* context) {
// Allocate context and buffers
SubGhzCliCommandRx* instance = malloc(sizeof(SubGhzCliCommandRx));
instance->stream = xStreamBufferCreate(sizeof(LevelDuration) * 1024, sizeof(LevelDuration));
instance->stream =
furi_stream_buffer_alloc(sizeof(LevelDuration) * 1024, sizeof(LevelDuration));
furi_check(instance->stream);
SubGhzEnvironment* environment = subghz_environment_alloc();
@ -274,8 +272,8 @@ void subghz_cli_command_rx(Cli* cli, FuriString* args, void* context) {
printf("Listening at %lu. Press CTRL+C to stop\r\n", frequency);
LevelDuration level_duration;
while(!cli_cmd_interrupt_received(cli)) {
int ret =
xStreamBufferReceive(instance->stream, &level_duration, sizeof(LevelDuration), 10);
int ret = furi_stream_buffer_receive(
instance->stream, &level_duration, sizeof(LevelDuration), 10);
if(ret == sizeof(LevelDuration)) {
if(level_duration_is_reset(level_duration)) {
printf(".");
@ -299,7 +297,7 @@ void subghz_cli_command_rx(Cli* cli, FuriString* args, void* context) {
// Cleanup
subghz_receiver_free(receiver);
subghz_environment_free(environment);
vStreamBufferDelete(instance->stream);
furi_stream_buffer_free(instance->stream);
free(instance);
}

2
applications/main/subghz/subghz_i.c
View File

@ -60,7 +60,7 @@ void subghz_get_frequency_modulation(SubGhz* subghz, FuriString* frequency, Furi
subghz->txrx->preset->frequency / 10000 % 100);
}
if(modulation != NULL) {
furi_string_printf(modulation, "%0.2s", furi_string_get_cstr(subghz->txrx->preset->name));
furi_string_printf(modulation, "%2s", furi_string_get_cstr(subghz->txrx->preset->name));
}
}

6
applications/plugins/music_player/music_player_worker.c
View File

@ -258,7 +258,7 @@ static bool music_player_worker_parse_notes(MusicPlayerWorker* instance, const c
if(!is_valid) {
FURI_LOG_E(
TAG,
"Invalid note: %u%c%c%u.%u",
"Invalid note: %lu%c%c%lu.%lu",
duration,
note_char == '\0' ? '_' : note_char,
sharp_char == '\0' ? '_' : sharp_char,
@ -281,7 +281,7 @@ static bool music_player_worker_parse_notes(MusicPlayerWorker* instance, const c
if(music_player_worker_add_note(instance, semitone, duration, dots)) {
FURI_LOG_D(
TAG,
"Added note: %c%c%u.%u = %u %u",
"Added note: %c%c%lu.%lu = %u %lu",
note_char == '\0' ? '_' : note_char,
sharp_char == '\0' ? '_' : sharp_char,
octave,
@ -291,7 +291,7 @@ static bool music_player_worker_parse_notes(MusicPlayerWorker* instance, const c
} else {
FURI_LOG_E(
TAG,
"Invalid note: %c%c%u.%u = %u %u",
"Invalid note: %c%c%lu.%lu = %u %lu",
note_char == '\0' ? '_' : note_char,
sharp_char == '\0' ? '_' : sharp_char,
octave,

4
applications/services/bt/bt_service/bt.c
View File

@ -77,7 +77,7 @@ static bool bt_pin_code_verify_event_handler(Bt* bt, uint32_t pin) {
notification_message(bt->notification, &sequence_display_backlight_on);
FuriString* pin_str;
dialog_message_set_icon(bt->dialog_message, &I_BLE_Pairing_128x64, 0, 0);
pin_str = furi_string_alloc_printf("Verify code\n%06d", pin);
pin_str = furi_string_alloc_printf("Verify code\n%06ld", pin);
dialog_message_set_text(
bt->dialog_message, furi_string_get_cstr(pin_str), 64, 4, AlignCenter, AlignTop);
dialog_message_set_buttons(bt->dialog_message, "Cancel", "OK", NULL);
@ -277,7 +277,7 @@ static bool bt_on_gap_event_callback(GapEvent event, void* context) {
static void bt_on_key_storage_change_callback(uint8_t* addr, uint16_t size, void* context) {
furi_assert(context);
Bt* bt = context;
FURI_LOG_I(TAG, "Changed addr start: %08lX, size changed: %d", addr, size);
FURI_LOG_I(TAG, "Changed addr start: %p, size changed: %d", addr, size);
BtMessage message = {.type = BtMessageTypeKeysStorageUpdated};
furi_check(
furi_message_queue_put(bt->message_queue, &message, FuriWaitForever) == FuriStatusOk);

9
applications/services/cli/cli_commands.c
View File

@ -7,7 +7,6 @@
#include <time.h>
#include <notification/notification_messages.h>
#include <loader/loader.h>
#include <stream_buffer.h>
// Close to ISO, `date +'%Y-%m-%d %H:%M:%S %u'`
#define CLI_DATE_FORMAT "%.4d-%.2d-%.2d %.2d:%.2d:%.2d %d"
@ -140,7 +139,7 @@ void cli_command_date(Cli* cli, FuriString* args, void* context) {
#define CLI_COMMAND_LOG_BUFFER_SIZE 64
void cli_command_log_tx_callback(const uint8_t* buffer, size_t size, void* context) {
xStreamBufferSend(context, buffer, size, 0);
furi_stream_buffer_send(context, buffer, size, 0);
}
void cli_command_log_level_set_from_string(FuriString* level) {
@ -165,7 +164,7 @@ void cli_command_log_level_set_from_string(FuriString* level) {
void cli_command_log(Cli* cli, FuriString* args, void* context) {
UNUSED(context);
StreamBufferHandle_t ring = xStreamBufferCreate(CLI_COMMAND_LOG_RING_SIZE, 1);
FuriStreamBuffer* ring = furi_stream_buffer_alloc(CLI_COMMAND_LOG_RING_SIZE, 1);
uint8_t buffer[CLI_COMMAND_LOG_BUFFER_SIZE];
FuriLogLevel previous_level = furi_log_get_level();
bool restore_log_level = false;
@ -179,7 +178,7 @@ void cli_command_log(Cli* cli, FuriString* args, void* context) {
printf("Press CTRL+C to stop...\r\n");
while(!cli_cmd_interrupt_received(cli)) {
size_t ret = xStreamBufferReceive(ring, buffer, CLI_COMMAND_LOG_BUFFER_SIZE, 50);
size_t ret = furi_stream_buffer_receive(ring, buffer, CLI_COMMAND_LOG_BUFFER_SIZE, 50);
cli_write(cli, buffer, ret);
}
@ -190,7 +189,7 @@ void cli_command_log(Cli* cli, FuriString* args, void* context) {
furi_log_set_level(previous_level);
}
vStreamBufferDelete(ring);
furi_stream_buffer_free(ring);
}
void cli_command_vibro(Cli* cli, FuriString* args, void* context) {

32
applications/services/cli/cli_vcp.c
View File

@ -1,7 +1,6 @@
#include <furi_hal_usb_cdc.h>
#include <furi_hal.h>
#include <furi.h>
#include <stream_buffer.h>
#include "cli_i.h"
#define TAG "CliVcp"
@ -29,8 +28,8 @@ typedef enum {
typedef struct {
FuriThread* thread;
StreamBufferHandle_t tx_stream;
StreamBufferHandle_t rx_stream;
FuriStreamBuffer* tx_stream;
FuriStreamBuffer* rx_stream;
volatile bool connected;
volatile bool running;
@ -62,8 +61,8 @@ static const uint8_t ascii_eot = 0x04;
static void cli_vcp_init() {
if(vcp == NULL) {
vcp = malloc(sizeof(CliVcp));
vcp->tx_stream = xStreamBufferCreate(VCP_TX_BUF_SIZE, 1);
vcp->rx_stream = xStreamBufferCreate(VCP_RX_BUF_SIZE, 1);
vcp->tx_stream = furi_stream_buffer_alloc(VCP_TX_BUF_SIZE, 1);
vcp->rx_stream = furi_stream_buffer_alloc(VCP_RX_BUF_SIZE, 1);
}
furi_assert(vcp->thread == NULL);
@ -113,7 +112,7 @@ static int32_t vcp_worker(void* context) {
#endif
if(vcp->connected == false) {
vcp->connected = true;
xStreamBufferSend(vcp->rx_stream, &ascii_soh, 1, FuriWaitForever);
furi_stream_buffer_send(vcp->rx_stream, &ascii_soh, 1, FuriWaitForever);
}
}
@ -124,8 +123,8 @@ static int32_t vcp_worker(void* context) {
#endif
if(vcp->connected == true) {
vcp->connected = false;
xStreamBufferReceive(vcp->tx_stream, vcp->data_buffer, USB_CDC_PKT_LEN, 0);
xStreamBufferSend(vcp->rx_stream, &ascii_eot, 1, FuriWaitForever);
furi_stream_buffer_receive(vcp->tx_stream, vcp->data_buffer, USB_CDC_PKT_LEN, 0);
furi_stream_buffer_send(vcp->rx_stream, &ascii_eot, 1, FuriWaitForever);
}
}
@ -134,7 +133,7 @@ static int32_t vcp_worker(void* context) {
#ifdef CLI_VCP_DEBUG
FURI_LOG_D(TAG, "StreamRx");
#endif
if(xStreamBufferSpacesAvailable(vcp->rx_stream) >= USB_CDC_PKT_LEN) {
if(furi_stream_buffer_spaces_available(vcp->rx_stream) >= USB_CDC_PKT_LEN) {
flags |= VcpEvtRx;
missed_rx--;
}
@ -142,14 +141,15 @@ static int32_t vcp_worker(void* context) {
// New data received
if(flags & VcpEvtRx) {
if(xStreamBufferSpacesAvailable(vcp->rx_stream) >= USB_CDC_PKT_LEN) {
if(furi_stream_buffer_spaces_available(vcp->rx_stream) >= USB_CDC_PKT_LEN) {
int32_t len = furi_hal_cdc_receive(VCP_IF_NUM, vcp->data_buffer, USB_CDC_PKT_LEN);
#ifdef CLI_VCP_DEBUG
FURI_LOG_D(TAG, "Rx %d", len);
#endif
if(len > 0) {
furi_check(
xStreamBufferSend(vcp->rx_stream, vcp->data_buffer, len, FuriWaitForever) ==
furi_stream_buffer_send(
vcp->rx_stream, vcp->data_buffer, len, FuriWaitForever) ==
(size_t)len);
}
} else {
@ -173,7 +173,7 @@ static int32_t vcp_worker(void* context) {
// CDC write transfer done
if(flags & VcpEvtTx) {
size_t len =
xStreamBufferReceive(vcp->tx_stream, vcp->data_buffer, USB_CDC_PKT_LEN, 0);
furi_stream_buffer_receive(vcp->tx_stream, vcp->data_buffer, USB_CDC_PKT_LEN, 0);
#ifdef CLI_VCP_DEBUG
FURI_LOG_D(TAG, "Tx %d", len);
#endif
@ -202,8 +202,8 @@ static int32_t vcp_worker(void* context) {
furi_hal_usb_unlock();
furi_hal_usb_set_config(vcp->usb_if_prev, NULL);
}
xStreamBufferReceive(vcp->tx_stream, vcp->data_buffer, USB_CDC_PKT_LEN, 0);
xStreamBufferSend(vcp->rx_stream, &ascii_eot, 1, FuriWaitForever);
furi_stream_buffer_receive(vcp->tx_stream, vcp->data_buffer, USB_CDC_PKT_LEN, 0);
furi_stream_buffer_send(vcp->rx_stream, &ascii_eot, 1, FuriWaitForever);
break;
}
}
@ -229,7 +229,7 @@ static size_t cli_vcp_rx(uint8_t* buffer, size_t size, uint32_t timeout) {
size_t batch_size = size;
if(batch_size > VCP_RX_BUF_SIZE) batch_size = VCP_RX_BUF_SIZE;
size_t len = xStreamBufferReceive(vcp->rx_stream, buffer, batch_size, timeout);
size_t len = furi_stream_buffer_receive(vcp->rx_stream, buffer, batch_size, timeout);
#ifdef CLI_VCP_DEBUG
FURI_LOG_D(TAG, "rx %u ", batch_size);
#endif
@ -262,7 +262,7 @@ static void cli_vcp_tx(const uint8_t* buffer, size_t size) {
size_t batch_size = size;
if(batch_size > USB_CDC_PKT_LEN) batch_size = USB_CDC_PKT_LEN;
xStreamBufferSend(vcp->tx_stream, buffer, batch_size, FuriWaitForever);
furi_stream_buffer_send(vcp->tx_stream, buffer, batch_size, FuriWaitForever);
furi_thread_flags_set(furi_thread_get_id(vcp->thread), VcpEvtStreamTx);
#ifdef CLI_VCP_DEBUG
FURI_LOG_D(TAG, "tx %u", batch_size);

4
applications/services/desktop/animations/animation_storage.c
View File

@ -304,7 +304,7 @@ static bool animation_storage_load_frames(
if(file_info.size > max_filesize) {
FURI_LOG_E(
TAG,
"Filesize %d, max: %d (width %d, height %d)",
"Filesize %lld, max: %d (width %d, height %d)",
file_info.size,
max_filesize,
width,
@ -329,7 +329,7 @@ static bool animation_storage_load_frames(
if(!frames_ok) {
FURI_LOG_E(
TAG,
"Load \'%s\' failed, %dx%d, size: %d",
"Load \'%s\' failed, %dx%d, size: %lld",
furi_string_get_cstr(filename),
width,
height,

2
applications/services/dolphin/helpers/dolphin_state.c
View File

@ -171,7 +171,7 @@ void dolphin_state_on_deed(DolphinState* dolphin_state, DolphinDeed deed) {
FURI_LOG_D(
TAG,
"icounter %d, butthurt %d",
"icounter %ld, butthurt %ld",
dolphin_state->data.icounter,
dolphin_state->data.butthurt);
}

6
applications/services/gui/gui.c
View File

@ -260,7 +260,7 @@ void gui_input(Gui* gui, InputEvent* input_event) {
"non-complementary input, discarding key: %s type: %s, sequence: %p",
input_get_key_name(input_event->key),
input_get_type_name(input_event->type),
input_event->sequence);
(void*)input_event->sequence);
return;
}
@ -290,7 +290,7 @@ void gui_input(Gui* gui, InputEvent* input_event) {
view_port,
input_get_key_name(input_event->key),
input_get_type_name(input_event->type),
input_event->sequence);
(void*)input_event->sequence);
view_port_input(gui->ongoing_input_view_port, input_event);
} else {
FURI_LOG_D(
@ -300,7 +300,7 @@ void gui_input(Gui* gui, InputEvent* input_event) {
view_port,
input_get_key_name(input_event->key),
input_get_type_name(input_event->type),
input_event->sequence);
(void*)input_event->sequence);
}
gui_unlock(gui);

9
applications/services/gui/modules/file_browser_worker.c
View File

@ -295,7 +295,7 @@ static int32_t browser_worker(void* context) {
browser_folder_init(browser, path, filename, &items_cnt, &file_idx);
FURI_LOG_D(
TAG,
"Enter folder: %s items: %u idx: %d",
"Enter folder: %s items: %lu idx: %ld",
furi_string_get_cstr(path),
items_cnt,
file_idx);
@ -317,7 +317,7 @@ static int32_t browser_worker(void* context) {
}
FURI_LOG_D(
TAG,
"Exit to: %s items: %u idx: %d",
"Exit to: %s items: %lu idx: %ld",
furi_string_get_cstr(path),
items_cnt,
file_idx);
@ -334,7 +334,7 @@ static int32_t browser_worker(void* context) {
browser_folder_init(browser, path, filename, &items_cnt, &file_idx);
FURI_LOG_D(
TAG,
"Refresh folder: %s items: %u idx: %d",
"Refresh folder: %s items: %lu idx: %ld",
furi_string_get_cstr(path),
items_cnt,
browser->item_sel_idx);
@ -344,7 +344,8 @@ static int32_t browser_worker(void* context) {
}
if(flags & WorkerEvtLoad) {
FURI_LOG_D(TAG, "Load offset: %u cnt: %u", browser->load_offset, browser->load_count);
FURI_LOG_D(
TAG, "Load offset: %lu cnt: %lu", browser->load_offset, browser->load_count);
browser_folder_load(browser, path, browser->load_offset, browser->load_count);
}

4
applications/services/gui/view_dispatcher.c
View File

@ -246,7 +246,7 @@ void view_dispatcher_handle_input(ViewDispatcher* view_dispatcher, InputEvent* e
"non-complementary input, discarding key: %s, type: %s, sequence: %p",
input_get_key_name(event->key),
input_get_type_name(event->type),
event->sequence);
(void*)event->sequence);
return;
}
@ -286,7 +286,7 @@ void view_dispatcher_handle_input(ViewDispatcher* view_dispatcher, InputEvent* e
view_dispatcher->current_view,
input_get_key_name(event->key),
input_get_type_name(event->type),
event->sequence);
(void*)event->sequence);
view_input(view_dispatcher->ongoing_input_view, event);
}
}

21
applications/services/rpc/rpc.c
View File

@ -13,7 +13,6 @@
#include <cli/cli.h>
#include <stdint.h>
#include <stdio.h>
#include <stream_buffer.h>
#include <m-dict.h>
#define TAG "RpcSrv"
@ -61,7 +60,7 @@ struct RpcSession {
FuriThread* thread;
RpcHandlerDict_t handlers;
StreamBufferHandle_t stream;
FuriStreamBuffer* stream;
PB_Main* decoded_message;
bool terminate;
void** system_contexts;
@ -151,7 +150,7 @@ size_t
furi_assert(encoded_bytes);
furi_assert(size > 0);
size_t bytes_sent = xStreamBufferSend(session->stream, encoded_bytes, size, timeout);
size_t bytes_sent = furi_stream_buffer_send(session->stream, encoded_bytes, size, timeout);
furi_thread_flags_set(furi_thread_get_id(session->thread), RpcEvtNewData);
@ -160,7 +159,7 @@ size_t
size_t rpc_session_get_available_size(RpcSession* session) {
furi_assert(session);
return xStreamBufferSpacesAvailable(session->stream);
return furi_stream_buffer_spaces_available(session->stream);
}
bool rpc_pb_stream_read(pb_istream_t* istream, pb_byte_t* buf, size_t count) {
@ -174,9 +173,9 @@ bool rpc_pb_stream_read(pb_istream_t* istream, pb_byte_t* buf, size_t count) {
size_t bytes_received = 0;
while(1) {
bytes_received +=
xStreamBufferReceive(session->stream, buf + bytes_received, count - bytes_received, 0);
if(xStreamBufferIsEmpty(session->stream)) {
bytes_received += furi_stream_buffer_receive(
session->stream, buf + bytes_received, count - bytes_received, 0);
if(furi_stream_buffer_is_empty(session->stream)) {
if(session->buffer_is_empty_callback) {
session->buffer_is_empty_callback(session->context);
}
@ -190,7 +189,7 @@ bool rpc_pb_stream_read(pb_istream_t* istream, pb_byte_t* buf, size_t count) {
} else {
flags = furi_thread_flags_wait(RPC_ALL_EVENTS, FuriFlagWaitAny, FuriWaitForever);
if(flags & RpcEvtDisconnect) {
if(xStreamBufferIsEmpty(session->stream)) {
if(furi_stream_buffer_is_empty(session->stream)) {
session->terminate = true;
istream->bytes_left = 0;
bytes_received = 0;
@ -279,7 +278,7 @@ static int32_t rpc_session_worker(void* context) {
}
if(message_decode_failed) {
xStreamBufferReset(session->stream);
furi_stream_buffer_reset(session->stream);
if(!session->terminate) {
/* Protobuf can't determine start and end of message.
* Handle this by adding varint at beginning
@ -329,7 +328,7 @@ static void rpc_session_free_callback(FuriThreadState thread_state, void* contex
free(session->system_contexts);
free(session->decoded_message);
RpcHandlerDict_clear(session->handlers);
vStreamBufferDelete(session->stream);
furi_stream_buffer_free(session->stream);
furi_mutex_acquire(session->callbacks_mutex, FuriWaitForever);
if(session->terminated_callback) {
@ -348,7 +347,7 @@ RpcSession* rpc_session_open(Rpc* rpc) {
RpcSession* session = malloc(sizeof(RpcSession));
session->callbacks_mutex = furi_mutex_alloc(FuriMutexTypeNormal);
session->stream = xStreamBufferCreate(RPC_BUFFER_SIZE, 1);
session->stream = furi_stream_buffer_alloc(RPC_BUFFER_SIZE, 1);
session->rpc = rpc;
session->terminate = false;
session->decode_error = false;

18
applications/services/rpc/rpc_app.c
View File

@ -32,7 +32,7 @@ static void rpc_system_app_start_process(const PB_Main* request, void* context)
furi_assert(!rpc_app->last_id);
furi_assert(!rpc_app->last_data);
FURI_LOG_D(TAG, "StartProcess: id %d", request->command_id);
FURI_LOG_D(TAG, "StartProcess: id %ld", request->command_id);
PB_CommandStatus result = PB_CommandStatus_ERROR_APP_CANT_START;
@ -63,7 +63,7 @@ static void rpc_system_app_start_process(const PB_Main* request, void* context)
furi_record_close(RECORD_LOADER);
FURI_LOG_D(TAG, "StartProcess: response id %d, result %d", request->command_id, result);
FURI_LOG_D(TAG, "StartProcess: response id %ld, result %d", request->command_id, result);
rpc_send_and_release_empty(session, request->command_id, result);
}
@ -108,7 +108,7 @@ static void rpc_system_app_exit_request(const PB_Main* request, void* context) {
PB_CommandStatus status;
if(rpc_app->app_callback) {
FURI_LOG_D(TAG, "ExitRequest: id %d", request->command_id);
FURI_LOG_D(TAG, "ExitRequest: id %ld", request->command_id);
furi_assert(!rpc_app->last_id);
furi_assert(!rpc_app->last_data);
rpc_app->last_id = request->command_id;
@ -116,7 +116,7 @@ static void rpc_system_app_exit_request(const PB_Main* request, void* context) {
} else {
status = PB_CommandStatus_ERROR_APP_NOT_RUNNING;
FURI_LOG_E(
TAG, "ExitRequest: APP_NOT_RUNNING, id %d, status: %d", request->command_id, status);
TAG, "ExitRequest: APP_NOT_RUNNING, id %ld, status: %d", request->command_id, status);
rpc_send_and_release_empty(session, request->command_id, status);
}
}
@ -132,7 +132,7 @@ static void rpc_system_app_load_file(const PB_Main* request, void* context) {
PB_CommandStatus status;
if(rpc_app->app_callback) {
FURI_LOG_D(TAG, "LoadFile: id %d", request->command_id);
FURI_LOG_D(TAG, "LoadFile: id %ld", request->command_id);
furi_assert(!rpc_app->last_id);
furi_assert(!rpc_app->last_data);
rpc_app->last_id = request->command_id;
@ -141,7 +141,7 @@ static void rpc_system_app_load_file(const PB_Main* request, void* context) {
} else {
status = PB_CommandStatus_ERROR_APP_NOT_RUNNING;
FURI_LOG_E(
TAG, "LoadFile: APP_NOT_RUNNING, id %d, status: %d", request->command_id, status);
TAG, "LoadFile: APP_NOT_RUNNING, id %ld, status: %d", request->command_id, status);
rpc_send_and_release_empty(session, request->command_id, status);
}
}
@ -166,7 +166,7 @@ static void rpc_system_app_button_press(const PB_Main* request, void* context) {
} else {
status = PB_CommandStatus_ERROR_APP_NOT_RUNNING;
FURI_LOG_E(
TAG, "ButtonPress: APP_NOT_RUNNING, id %d, status: %d", request->command_id, status);
TAG, "ButtonPress: APP_NOT_RUNNING, id %ld, status: %d", request->command_id, status);
rpc_send_and_release_empty(session, request->command_id, status);
}
}
@ -190,7 +190,7 @@ static void rpc_system_app_button_release(const PB_Main* request, void* context)
} else {
status = PB_CommandStatus_ERROR_APP_NOT_RUNNING;
FURI_LOG_E(
TAG, "ButtonRelease: APP_NOT_RUNNING, id %d, status: %d", request->command_id, status);
TAG, "ButtonRelease: APP_NOT_RUNNING, id %ld, status: %d", request->command_id, status);
rpc_send_and_release_empty(session, request->command_id, status);
}
}
@ -243,7 +243,7 @@ void rpc_system_app_confirm(RpcAppSystem* rpc_app, RpcAppSystemEvent event, bool
free(rpc_app->last_data);
rpc_app->last_data = NULL;
}
FURI_LOG_D(TAG, "AppConfirm: event %d last_id %d status %d", event, last_id, status);
FURI_LOG_D(TAG, "AppConfirm: event %d last_id %ld status %d", event, last_id, status);
rpc_send_and_release_empty(session, last_id, status);
break;
default:

2
applications/services/rpc/rpc_cli.c
View File

@ -44,7 +44,7 @@ void rpc_cli_command_start_session(Cli* cli, FuriString* args, void* context) {
Rpc* rpc = context;
uint32_t mem_before = memmgr_get_free_heap();
FURI_LOG_D(TAG, "Free memory %d", mem_before);
FURI_LOG_D(TAG, "Free memory %ld", mem_before);
furi_hal_usb_lock();
RpcSession* rpc_session = rpc_session_open(rpc);

4
applications/services/rpc/rpc_debug.c
View File

@ -158,9 +158,9 @@ void rpc_debug_print_message(const PB_Main* message) {
case PB_Main_storage_info_response_tag: {
furi_string_cat_printf(str, "\tinfo_response {\r\n");
furi_string_cat_printf(
str, "\t\ttotal_space: %lu\r\n", message->content.storage_info_response.total_space);
str, "\t\ttotal_space: %llu\r\n", message->content.storage_info_response.total_space);
furi_string_cat_printf(
str, "\t\tfree_space: %lu\r\n", message->content.storage_info_response.free_space);
str, "\t\tfree_space: %llu\r\n", message->content.storage_info_response.free_space);
break;
}
case PB_Main_storage_stat_request_tag: {

28
applications/services/storage/storage_external_api.c
View File

@ -119,7 +119,11 @@ bool storage_file_open(
furi_event_flag_free(event);
FURI_LOG_T(
TAG, "File %p - %p open (%s)", (uint32_t)file - SRAM_BASE, file->file_id - SRAM_BASE, path);
TAG,
"File %p - %p open (%s)",
(void*)((uint32_t)file - SRAM_BASE),
(void*)(file->file_id - SRAM_BASE),
path);
return result;
}
@ -132,7 +136,11 @@ bool storage_file_close(File* file) {
S_API_MESSAGE(StorageCommandFileClose);
S_API_EPILOGUE;
FURI_LOG_T(TAG, "File %p - %p closed", (uint32_t)file - SRAM_BASE, file->file_id - SRAM_BASE);
FURI_LOG_T(
TAG,
"File %p - %p closed",
(void*)((uint32_t)file - SRAM_BASE),
(void*)(file->file_id - SRAM_BASE));
file->type = FileTypeClosed;
return S_RETURN_BOOL;
@ -291,7 +299,11 @@ bool storage_dir_open(File* file, const char* path) {
furi_event_flag_free(event);
FURI_LOG_T(
TAG, "Dir %p - %p open (%s)", (uint32_t)file - SRAM_BASE, file->file_id - SRAM_BASE, path);
TAG,
"Dir %p - %p open (%s)",
(void*)((uint32_t)file - SRAM_BASE),
(void*)(file->file_id - SRAM_BASE),
path);
return result;
}
@ -303,7 +315,11 @@ bool storage_dir_close(File* file) {
S_API_MESSAGE(StorageCommandDirClose);
S_API_EPILOGUE;
FURI_LOG_T(TAG, "Dir %p - %p closed", (uint32_t)file - SRAM_BASE, file->file_id - SRAM_BASE);
FURI_LOG_T(
TAG,
"Dir %p - %p closed",
(void*)((uint32_t)file - SRAM_BASE),
(void*)(file->file_id - SRAM_BASE));
file->type = FileTypeClosed;
@ -675,7 +691,7 @@ File* storage_file_alloc(Storage* storage) {
file->type = FileTypeClosed;
file->storage = storage;
FURI_LOG_T(TAG, "File/Dir %p alloc", (uint32_t)file - SRAM_BASE);
FURI_LOG_T(TAG, "File/Dir %p alloc", (void*)((uint32_t)file - SRAM_BASE));
return file;
}
@ -697,7 +713,7 @@ void storage_file_free(File* file) {
}
}
FURI_LOG_T(TAG, "File/Dir %p free", (uint32_t)file - SRAM_BASE);
FURI_LOG_T(TAG, "File/Dir %p free", (void*)((uint32_t)file - SRAM_BASE));
free(file);
}

14
applications/services/storage/storages/storage_int.c
View File

@ -77,12 +77,12 @@ static int storage_int_device_read(
FURI_LOG_T(
TAG,
"Device read: block %d, off %d, buffer: %p, size %d, translated address: %p",
"Device read: block %ld, off %ld, buffer: %p, size %ld, translated address: %p",
block,
off,
buffer,
size,
address);
(void*)address);
memcpy(buffer, (void*)address, size);
@ -100,12 +100,12 @@ static int storage_int_device_prog(
FURI_LOG_T(
TAG,
"Device prog: block %d, off %d, buffer: %p, size %d, translated address: %p",
"Device prog: block %ld, off %ld, buffer: %p, size %ld, translated address: %p",
block,
off,
buffer,
size,
address);
(void*)address);
int ret = 0;
while(size > 0) {
@ -122,7 +122,7 @@ static int storage_int_device_erase(const struct lfs_config* c, lfs_block_t bloc
LFSData* lfs_data = c->context;
size_t page = lfs_data->start_page + block;
FURI_LOG_D(TAG, "Device erase: page %d, translated page: %x", block, page);
FURI_LOG_D(TAG, "Device erase: page %ld, translated page: %x", block, page);
furi_hal_flash_erase(page);
return 0;
@ -740,8 +740,8 @@ void storage_int_init(StorageData* storage) {
LFSData* lfs_data = storage_int_lfs_data_alloc();
FURI_LOG_I(
TAG,
"Config: start %p, read %d, write %d, page size: %d, page count: %d, cycles: %d",
lfs_data->start_address,
"Config: start %p, read %ld, write %ld, page size: %ld, page count: %ld, cycles: %ld",
(void*)lfs_data->start_address,
lfs_data->config.read_size,
lfs_data->config.prog_size,
lfs_data->config.block_size,

8
applications/system/updater/util/update_task_worker_flasher.c
View File

@ -271,7 +271,7 @@ bool update_task_validate_optionbytes(UpdateTask* update_task) {
match = false;
FURI_LOG_E(
TAG,
"OB MISMATCH: #%d: real %08X != %08X (exp.), full %08X",
"OB MISMATCH: #%d: real %08lX != %08lX (exp.), full %08lX",
idx,
device_ob_value_masked,
ref_value,
@ -289,7 +289,7 @@ bool update_task_validate_optionbytes(UpdateTask* update_task) {
(manifest->ob_reference.obs[idx].values.base &
manifest->ob_write_mask.obs[idx].values.base);
FURI_LOG_W(TAG, "Fixing up OB byte #%d to %08X", idx, patched_value);
FURI_LOG_W(TAG, "Fixing up OB byte #%d to %08lX", idx, patched_value);
ob_dirty = true;
bool is_fixed = furi_hal_flash_ob_set_word(idx, patched_value) &&
@ -301,7 +301,7 @@ bool update_task_validate_optionbytes(UpdateTask* update_task) {
* reference value */
FURI_LOG_W(
TAG,
"OB #%d is FUBAR (fixed&masked %08X, not %08X)",
"OB #%d is FUBAR (fixed&masked %08lX, not %08lX)",
idx,
patched_value,
ref_value);
@ -310,7 +310,7 @@ bool update_task_validate_optionbytes(UpdateTask* update_task) {
} else {
FURI_LOG_D(
TAG,
"OB MATCH: #%d: real %08X == %08X (exp.)",
"OB MATCH: #%d: real %08lX == %08lX (exp.)",
idx,
device_ob_value_masked,
ref_value);

2
documentation/AppManifests.md
View File

@ -47,7 +47,7 @@ Only 2 parameters are mandatory: ***appid*** and ***apptype***, others are optio
The following parameters are used only for [FAPs](./AppsOnSDCard.md):
* **sources**: list of strings, file name masks, used for gathering sources within app folder. Default value of `["*.c*"]` includes C and C++ source files. Application cannot use `"lib"` folder for their own source code, as it is reserved for **fap_private_libs**.
* **fap_version**: tuple, 2 numbers in form of (x,y): application version to be embedded within .fap file. Default value is (0,1), meanig version "0.1".
* **fap_version**: tuple, 2 numbers in form of (x,y): application version to be embedded within .fap file. Default value is (0,1), meaning version "0.1".
* **fap_icon**: name of a .png file, 1-bit color depth, 10x10px, to be embedded within .fap file.
* **fap_libs**: list of extra libraries to link application against. Provides access to extra functions that are not exported as a part of main firmware at expense of increased .fap file size and RAM consumption.
* **fap_category**: string, may be empty. App subcategory, also works as path of FAP within apps folder in the file system.

10
firmware/targets/f7/api_symbols.csv
View File

@ -1358,6 +1358,16 @@ Function,+,furi_semaphore_alloc,FuriSemaphore*,"uint32_t, uint32_t"
Function,+,furi_semaphore_free,void,FuriSemaphore*
Function,+,furi_semaphore_get_count,uint32_t,FuriSemaphore*
Function,+,furi_semaphore_release,FuriStatus,FuriSemaphore*
Function,+,furi_stream_buffer_alloc,FuriStreamBuffer*,"size_t, size_t"
Function,+,furi_stream_buffer_bytes_available,size_t,FuriStreamBuffer*
Function,+,furi_stream_buffer_free,void,FuriStreamBuffer*
Function,+,furi_stream_buffer_is_empty,_Bool,FuriStreamBuffer*
Function,+,furi_stream_buffer_is_full,_Bool,FuriStreamBuffer*
Function,+,furi_stream_buffer_receive,size_t,"FuriStreamBuffer*, void*, size_t, uint32_t"
Function,+,furi_stream_buffer_reset,FuriStatus,FuriStreamBuffer*
Function,+,furi_stream_buffer_send,size_t,"FuriStreamBuffer*, const void*, size_t, uint32_t"
Function,+,furi_stream_buffer_spaces_available,size_t,FuriStreamBuffer*
Function,+,furi_stream_set_trigger_level,_Bool,"FuriStreamBuffer*, size_t"
Function,+,furi_string_alloc,FuriString*,
Function,+,furi_string_alloc_move,FuriString*,FuriString*
Function,+,furi_string_alloc_printf,FuriString*,"const char[], ..."

1 entry status name type params
1358 Function + furi_semaphore_free void FuriSemaphore*
1359 Function + furi_semaphore_get_count uint32_t FuriSemaphore*
1360 Function + furi_semaphore_release FuriStatus FuriSemaphore*
1361 Function + furi_stream_buffer_alloc FuriStreamBuffer* size_t, size_t
1362 Function + furi_stream_buffer_bytes_available size_t FuriStreamBuffer*
1363 Function + furi_stream_buffer_free void FuriStreamBuffer*
1364 Function + furi_stream_buffer_is_empty _Bool FuriStreamBuffer*
1365 Function + furi_stream_buffer_is_full _Bool FuriStreamBuffer*
1366 Function + furi_stream_buffer_receive size_t FuriStreamBuffer*, void*, size_t, uint32_t
1367 Function + furi_stream_buffer_reset FuriStatus FuriStreamBuffer*
1368 Function + furi_stream_buffer_send size_t FuriStreamBuffer*, const void*, size_t, uint32_t
1369 Function + furi_stream_buffer_spaces_available size_t FuriStreamBuffer*
1370 Function + furi_stream_set_trigger_level _Bool FuriStreamBuffer*, size_t
1371 Function + furi_string_alloc FuriString*
1372 Function + furi_string_alloc_move FuriString* FuriString*
1373 Function + furi_string_alloc_printf FuriString* const char[], ...

4
firmware/targets/f7/ble_glue/gap.c
View File

@ -184,7 +184,7 @@ SVCCTL_UserEvtFlowStatus_t SVCCTL_App_Notification(void* pckt) {
if(furi_hal_rtc_is_flag_set(FuriHalRtcFlagLock)) {
FURI_LOG_I(TAG, "Pass key request event. Pin: ******");
} else {
FURI_LOG_I(TAG, "Pass key request event. Pin: %06d", pin);
FURI_LOG_I(TAG, "Pass key request event. Pin: %06ld", pin);
}
GapEvent event = {.type = GapEventTypePinCodeShow, .data.pin_code = pin};
gap->on_event_cb(event, gap->context);
@ -227,7 +227,7 @@ SVCCTL_UserEvtFlowStatus_t SVCCTL_App_Notification(void* pckt) {
case EVT_BLUE_GAP_NUMERIC_COMPARISON_VALUE: {
uint32_t pin =
((aci_gap_numeric_comparison_value_event_rp0*)(blue_evt->data))->Numeric_Value;
FURI_LOG_I(TAG, "Verify numeric comparison: %06d", pin);
FURI_LOG_I(TAG, "Verify numeric comparison: %06ld", pin);
GapEvent event = {.type = GapEventTypePinCodeVerify, .data.pin_code = pin};
bool result = gap->on_event_cb(event, gap->context);
aci_gap_numeric_comparison_value_confirm_yesno(gap->service.connection_handle, result);

4
firmware/targets/f7/ble_glue/serial_service.c
View File

@ -63,13 +63,13 @@ static SVCCTL_EvtAckStatus_t serial_svc_event_handler(void* event) {
.size = attribute_modified->Attr_Data_Length,
}};
uint32_t buff_free_size = serial_svc->callback(event, serial_svc->context);
FURI_LOG_D(TAG, "Available buff size: %d", buff_free_size);
FURI_LOG_D(TAG, "Available buff size: %ld", buff_free_size);
furi_check(furi_mutex_release(serial_svc->buff_size_mtx) == FuriStatusOk);
}
ret = SVCCTL_EvtAckFlowEnable;
}
} else if(blecore_evt->ecode == ACI_GATT_SERVER_CONFIRMATION_VSEVT_CODE) {
FURI_LOG_T(TAG, "Ack received", blecore_evt->ecode);
FURI_LOG_T(TAG, "Ack received");
if(serial_svc->callback) {
SerialServiceEvent event = {
.event = SerialServiceEventTypeDataSent,

3
firmware/targets/f7/furi_hal/furi_hal_console.h
View File

@ -2,6 +2,7 @@
#include <stddef.h>
#include <stdint.h>
#include <stdio.h>
#ifdef __cplusplus
extern "C" {
@ -27,7 +28,7 @@ void furi_hal_console_tx_with_new_line(const uint8_t* buffer, size_t buffer_size
* @param format
* @param ...
*/
void furi_hal_console_printf(const char format[], ...);
void furi_hal_console_printf(const char format[], ...) _ATTRIBUTE((__format__(__printf__, 1, 2)));
void furi_hal_console_puts(const char* data);

6
firmware/targets/f7/furi_hal/furi_hal_flash.c
View File

@ -83,7 +83,7 @@ void furi_hal_flash_init() {
// WRITE_REG(FLASH->SR, FLASH_SR_OPTVERR);
/* Actually, reset all error flags on start */
if(READ_BIT(FLASH->SR, FURI_HAL_FLASH_SR_ERRORS)) {
FURI_LOG_E(TAG, "FLASH->SR 0x%08X", FLASH->SR);
FURI_LOG_E(TAG, "FLASH->SR 0x%08lX", FLASH->SR);
WRITE_REG(FLASH->SR, FURI_HAL_FLASH_SR_ERRORS);
}
}
@ -514,10 +514,10 @@ bool furi_hal_flash_ob_set_word(size_t word_idx, const uint32_t value) {
FURI_LOG_W(
TAG,
"Setting OB reg %d for word %d (addr 0x%08X) to 0x%08X",
"Setting OB reg %d for word %d (addr 0x%08lX) to 0x%08lX",
reg_def->ob_reg,
word_idx,
reg_def->ob_register_address,
(uint32_t)reg_def->ob_register_address,
value);
/* 1. Clear OPTLOCK option lock bit with the clearing sequence */

4
firmware/targets/f7/furi_hal/furi_hal_memory.c
View File

@ -55,9 +55,9 @@ void furi_hal_memory_init() {
memory->region[SRAM_B].size = sram2b_unprotected_size;
FURI_LOG_I(
TAG, "SRAM2A: 0x%p, %d", memory->region[SRAM_A].start, memory->region[SRAM_A].size);
TAG, "SRAM2A: 0x%p, %ld", memory->region[SRAM_A].start, memory->region[SRAM_A].size);
FURI_LOG_I(
TAG, "SRAM2B: 0x%p, %d", memory->region[SRAM_B].start, memory->region[SRAM_B].size);
TAG, "SRAM2B: 0x%p, %ld", memory->region[SRAM_B].start, memory->region[SRAM_B].size);
if((memory->region[SRAM_A].size > 0) || (memory->region[SRAM_B].size > 0)) {
if((memory->region[SRAM_A].size > 0)) {

6
firmware/targets/f7/furi_hal/furi_hal_power.c
View File

@ -569,13 +569,13 @@ void furi_hal_power_info_get(FuriHalPowerInfoCallback out, void* context) {
furi_string_printf(value, "%u", furi_hal_power_get_bat_health_pct());
out("battery_health", furi_string_get_cstr(value), false, context);
furi_string_printf(value, "%u", furi_hal_power_get_battery_remaining_capacity());
furi_string_printf(value, "%lu", furi_hal_power_get_battery_remaining_capacity());
out("capacity_remain", furi_string_get_cstr(value), false, context);
furi_string_printf(value, "%u", furi_hal_power_get_battery_full_capacity());
furi_string_printf(value, "%lu", furi_hal_power_get_battery_full_capacity());
out("capacity_full", furi_string_get_cstr(value), false, context);
furi_string_printf(value, "%u", furi_hal_power_get_battery_design_capacity());
furi_string_printf(value, "%lu", furi_hal_power_get_battery_design_capacity());
out("capacity_design", furi_string_get_cstr(value), true, context);
furi_string_free(value);

2
firmware/targets/f7/furi_hal/furi_hal_subghz.c
View File

@ -174,7 +174,7 @@ void furi_hal_subghz_load_custom_preset(uint8_t* preset_data) {
i += 2;
}
for(uint8_t y = i; y < i + 10; y++) {
FURI_LOG_D(TAG, "PA[%lu]: %02X", y, preset_data[y]);
FURI_LOG_D(TAG, "PA[%u]: %02X", y, preset_data[y]);
}
}
}

3
furi/core/log.h
View File

@ -51,7 +51,8 @@ void furi_log_init();
* @param format
* @param ...
*/
void furi_log_print_format(FuriLogLevel level, const char* tag, const char* format, ...);
void furi_log_print_format(FuriLogLevel level, const char* tag, const char* format, ...)
_ATTRIBUTE((__format__(__printf__, 3, 4)));
/** Set log level
*

77
furi/core/stream_buffer.c Normal file
View File

@ -0,0 +1,77 @@
#include "base.h"
#include "stream_buffer.h"
#include "common_defines.h"
#include <FreeRTOS.h>
#include <FreeRTOS-Kernel/include/stream_buffer.h>
FuriStreamBuffer* furi_stream_buffer_alloc(size_t size, size_t trigger_level) {
return xStreamBufferCreate(size, trigger_level);
};
void furi_stream_buffer_free(FuriStreamBuffer* stream_buffer) {
vStreamBufferDelete(stream_buffer);
};
bool furi_stream_set_trigger_level(FuriStreamBuffer* stream_buffer, size_t trigger_level) {
return xStreamBufferSetTriggerLevel(stream_buffer, trigger_level) == pdTRUE;
};
size_t furi_stream_buffer_send(
FuriStreamBuffer* stream_buffer,
const void* data,
size_t length,
uint32_t timeout) {
size_t ret;
if(FURI_IS_IRQ_MODE() != 0U) {
BaseType_t yield;
ret = xStreamBufferSendFromISR(stream_buffer, data, length, &yield);
portYIELD_FROM_ISR(yield);
} else {
ret = xStreamBufferSend(stream_buffer, data, length, timeout);
}
return ret;
};
size_t furi_stream_buffer_receive(
FuriStreamBuffer* stream_buffer,
void* data,
size_t length,
uint32_t timeout) {
size_t ret;
if(FURI_IS_IRQ_MODE() != 0U) {
BaseType_t yield;
ret = xStreamBufferReceiveFromISR(stream_buffer, data, length, &yield);
portYIELD_FROM_ISR(yield);
} else {
ret = xStreamBufferReceive(stream_buffer, data, length, timeout);
}
return ret;
}
size_t furi_stream_buffer_bytes_available(FuriStreamBuffer* stream_buffer) {
return xStreamBufferBytesAvailable(stream_buffer);
};
size_t furi_stream_buffer_spaces_available(FuriStreamBuffer* stream_buffer) {
return xStreamBufferSpacesAvailable(stream_buffer);
};
bool furi_stream_buffer_is_full(FuriStreamBuffer* stream_buffer) {
return xStreamBufferIsFull(stream_buffer) == pdTRUE;
};
bool furi_stream_buffer_is_empty(FuriStreamBuffer* stream_buffer) {
return (xStreamBufferIsEmpty(stream_buffer) == pdTRUE);
};
FuriStatus furi_stream_buffer_reset(FuriStreamBuffer* stream_buffer) {
if(xStreamBufferReset(stream_buffer) == pdPASS) {
return FuriStatusOk;
} else {
return FuriStatusError;
}
}

152
furi/core/stream_buffer.h Normal file
View File

@ -0,0 +1,152 @@
/**
* @file stream_buffer.h
* Furi stream buffer primitive.
*
* Stream buffers are used to send a continuous stream of data from one task or
* interrupt to another. Their implementation is light weight, making them
* particularly suited for interrupt to task and core to core communication
* scenarios.
*
* ***NOTE***: Stream buffer implementation assumes there is only one task or
* interrupt that will write to the buffer (the writer), and only one task or
* interrupt that will read from the buffer (the reader).
*/
#pragma once
#include <stdint.h>
#include <stddef.h>
#ifdef __cplusplus
extern "C" {
#endif
typedef void FuriStreamBuffer;
/**
* @brief Allocate stream buffer instance.
* Stream buffer implementation assumes there is only one task or
* interrupt that will write to the buffer (the writer), and only one task or
* interrupt that will read from the buffer (the reader).
*
* @param size The total number of bytes the stream buffer will be able to hold at any one time.
* @param trigger_level The number of bytes that must be in the stream buffer
* before a task that is blocked on the stream buffer to wait for data is moved out of the blocked state.
* @return The stream buffer instance.
*/
FuriStreamBuffer* furi_stream_buffer_alloc(size_t size, size_t trigger_level);
/**
* @brief Free stream buffer instance
*
* @param stream_buffer The stream buffer instance.
*/
void furi_stream_buffer_free(FuriStreamBuffer* stream_buffer);
/**
* @brief Set trigger level for stream buffer.
* A stream buffer's trigger level is the number of bytes that must be in the
* stream buffer before a task that is blocked on the stream buffer to
* wait for data is moved out of the blocked state.
*
* @param stream_buffer The stream buffer instance
* @param trigger_level The new trigger level for the stream buffer.
* @return true if trigger level can be be updated (new trigger level was less than or equal to the stream buffer's length).
* @return false if trigger level can't be be updated (new trigger level was greater than the stream buffer's length).
*/
bool furi_stream_set_trigger_level(FuriStreamBuffer* stream_buffer, size_t trigger_level);
/**
* @brief Sends bytes to a stream buffer. The bytes are copied into the stream buffer.
* Wakes up task waiting for data to become available if called from ISR.
*
* @param stream_buffer The stream buffer instance.
* @param data A pointer to the data that is to be copied into the stream buffer.
* @param length The maximum number of bytes to copy from data into the stream buffer.
* @param timeout The maximum amount of time the task should remain in the
* Blocked state to wait for space to become available if the stream buffer is full.
* Will return immediately if timeout is zero.
* Setting timeout to FuriWaitForever will cause the task to wait indefinitely.
* Ignored if called from ISR.
* @return The number of bytes actually written to the stream buffer.
*/
size_t furi_stream_buffer_send(
FuriStreamBuffer* stream_buffer,
const void* data,
size_t length,
uint32_t timeout);
/**
* @brief Receives bytes from a stream buffer.
* Wakes up task waiting for space to become available if called from ISR.
*
* @param stream_buffer The stream buffer instance.
* @param data A pointer to the buffer into which the received bytes will be
* copied.
* @param length The length of the buffer pointed to by the data parameter.
* @param timeout The maximum amount of time the task should remain in the
* Blocked state to wait for data to become available if the stream buffer is empty.
* Will return immediately if timeout is zero.
* Setting timeout to FuriWaitForever will cause the task to wait indefinitely.
* Ignored if called from ISR.
* @return The number of bytes read from the stream buffer, if any.
*/
size_t furi_stream_buffer_receive(
FuriStreamBuffer* stream_buffer,
void* data,
size_t length,
uint32_t timeout);
/**
* @brief Queries a stream buffer to see how much data it contains, which is equal to
* the number of bytes that can be read from the stream buffer before the stream
* buffer would be empty.
*
* @param stream_buffer The stream buffer instance.
* @return The number of bytes that can be read from the stream buffer before
* the stream buffer would be empty.
*/
size_t furi_stream_buffer_bytes_available(FuriStreamBuffer* stream_buffer);
/**
* @brief Queries a stream buffer to see how much free space it contains, which is
* equal to the amount of data that can be sent to the stream buffer before it
* is full.
*
* @param stream_buffer The stream buffer instance.
* @return The number of bytes that can be written to the stream buffer before
* the stream buffer would be full.
*/
size_t furi_stream_buffer_spaces_available(FuriStreamBuffer* stream_buffer);
/**
* @brief Queries a stream buffer to see if it is full.
*
* @param stream_buffer stream buffer instance.
* @return true if the stream buffer is full.
* @return false if the stream buffer is not full.
*/
bool furi_stream_buffer_is_full(FuriStreamBuffer* stream_buffer);
/**
* @brief Queries a stream buffer to see if it is empty.
*
* @param stream_buffer The stream buffer instance.
* @return true if the stream buffer is empty.
* @return false if the stream buffer is not empty.
*/
bool furi_stream_buffer_is_empty(FuriStreamBuffer* stream_buffer);
/**
* @brief Resets a stream buffer to its initial, empty, state. Any data that was
* in the stream buffer is discarded. A stream buffer can only be reset if there
* are no tasks blocked waiting to either send to or receive from the stream buffer.
*
* @param stream_buffer The stream buffer instance.
* @return FuriStatusOk if the stream buffer is reset.
* @return FuriStatusError if there was a task blocked waiting to send to or read
* from the stream buffer then the stream buffer is not reset.
*/
FuriStatus furi_stream_buffer_reset(FuriStreamBuffer* stream_buffer);
#ifdef __cplusplus
}
#endif

9
furi/core/string.h
View File

@ -57,7 +57,8 @@ FuriString* furi_string_alloc_set_str(const char cstr_source[]);
* @param ...
* @return FuriString*
*/
FuriString* furi_string_alloc_printf(const char format[], ...);
FuriString* furi_string_alloc_printf(const char format[], ...)
_ATTRIBUTE((__format__(__printf__, 1, 2)));
/**
* @brief Allocate new FuriString and printf to it.
@ -214,7 +215,8 @@ void furi_string_set_n(FuriString* string, const FuriString* source, size_t offs
* @param ...
* @return int
*/
int furi_string_printf(FuriString* string, const char format[], ...);
int furi_string_printf(FuriString* string, const char format[], ...)
_ATTRIBUTE((__format__(__printf__, 2, 3)));
/**
* @brief Format in the string the given printf format
@ -259,7 +261,8 @@ void furi_string_cat_str(FuriString* string_1, const char cstring_2[]);
* @param ...
* @return int
*/
int furi_string_cat_printf(FuriString* string, const char format[], ...);
int furi_string_cat_printf(FuriString* string, const char format[], ...)
_ATTRIBUTE((__format__(__printf__, 2, 3)));
/**
* @brief Append to the string the formatted string of the given printf format.

33
furi/furi.h
View File

@ -2,22 +2,23 @@
#include <stdlib.h>
#include <core/check.h>
#include <core/common_defines.h>
#include <core/event_flag.h>
#include <core/kernel.h>
#include <core/log.h>
#include <core/memmgr.h>
#include <core/memmgr_heap.h>
#include <core/message_queue.h>
#include <core/mutex.h>
#include <core/pubsub.h>
#include <core/record.h>
#include <core/semaphore.h>
#include <core/thread.h>
#include <core/timer.h>
#include <core/valuemutex.h>
#include <core/string.h>
#include "core/check.h"
#include "core/common_defines.h"
#include "core/event_flag.h"
#include "core/kernel.h"
#include "core/log.h"
#include "core/memmgr.h"
#include "core/memmgr_heap.h"
#include "core/message_queue.h"
#include "core/mutex.h"
#include "core/pubsub.h"
#include "core/record.h"
#include "core/semaphore.h"
#include "core/thread.h"
#include "core/timer.h"
#include "core/valuemutex.h"
#include "core/string.h"
#include "core/stream_buffer.h"
#include <furi_hal_gpio.h>

38
lib/infrared/worker/infrared_worker.c
View File

@ -9,7 +9,6 @@
#include <furi.h>
#include <notification/notification_messages.h>
#include <stream_buffer.h>
#define INFRARED_WORKER_RX_TIMEOUT INFRARED_RAW_RX_TIMING_DELAY_US
@ -50,7 +49,7 @@ struct InfraredWorkerSignal {
struct InfraredWorker {
FuriThread* thread;
StreamBufferHandle_t stream;
FuriStreamBuffer* stream;
InfraredWorkerSignal signal;
InfraredWorkerState state;
@ -100,15 +99,13 @@ static void infrared_worker_rx_timeout_callback(void* context) {
static void infrared_worker_rx_callback(void* context, bool level, uint32_t duration) {
InfraredWorker* instance = context;
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
furi_assert(duration != 0);
LevelDuration level_duration = level_duration_make(level, duration);
size_t ret = xStreamBufferSendFromISR(
instance->stream, &level_duration, sizeof(LevelDuration), &xHigherPriorityTaskWoken);
size_t ret =
furi_stream_buffer_send(instance->stream, &level_duration, sizeof(LevelDuration), 0);
uint32_t events = (ret == sizeof(LevelDuration)) ? INFRARED_WORKER_RX_RECEIVED :
INFRARED_WORKER_OVERRUN;
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
uint32_t flags_set = furi_thread_flags_set(furi_thread_get_id(instance->thread), events);
furi_check(flags_set & events);
@ -179,7 +176,7 @@ static int32_t infrared_worker_rx_thread(void* thread_context) {
if(instance->signal.timings_cnt == 0)
notification_message(instance->notification, &sequence_display_backlight_on);
while(sizeof(LevelDuration) ==
xStreamBufferReceive(
furi_stream_buffer_receive(
instance->stream, &level_duration, sizeof(LevelDuration), 0)) {
if(!instance->rx.overrun) {
bool level = level_duration_get_level(level_duration);
@ -232,7 +229,7 @@ InfraredWorker* infrared_worker_alloc() {
size_t buffer_size =
MAX(sizeof(InfraredWorkerTiming) * (MAX_TIMINGS_AMOUNT + 1),
sizeof(LevelDuration) * MAX_TIMINGS_AMOUNT);
instance->stream = xStreamBufferCreate(buffer_size, sizeof(InfraredWorkerTiming));
instance->stream = furi_stream_buffer_alloc(buffer_size, sizeof(InfraredWorkerTiming));
instance->infrared_decoder = infrared_alloc_decoder();
instance->infrared_encoder = infrared_alloc_encoder();
instance->blink_enable = false;
@ -249,7 +246,7 @@ void infrared_worker_free(InfraredWorker* instance) {
furi_record_close(RECORD_NOTIFICATION);
infrared_free_decoder(instance->infrared_decoder);
infrared_free_encoder(instance->infrared_encoder);
vStreamBufferDelete(instance->stream);
furi_stream_buffer_free(instance->stream);
furi_thread_free(instance->thread);
free(instance);
@ -259,7 +256,7 @@ void infrared_worker_rx_start(InfraredWorker* instance) {
furi_assert(instance);
furi_assert(instance->state == InfraredWorkerStateIdle);
xStreamBufferSetTriggerLevel(instance->stream, sizeof(LevelDuration));
furi_stream_set_trigger_level(instance->stream, sizeof(LevelDuration));
furi_thread_set_callback(instance->thread, infrared_worker_rx_thread);
furi_thread_start(instance->thread);
@ -285,9 +282,9 @@ void infrared_worker_rx_stop(InfraredWorker* instance) {
furi_thread_flags_set(furi_thread_get_id(instance->thread), INFRARED_WORKER_EXIT);
furi_thread_join(instance->thread);
BaseType_t xReturn = xStreamBufferReset(instance->stream);
furi_assert(xReturn == pdPASS);
(void)xReturn;
FuriStatus status = furi_stream_buffer_reset(instance->stream);
furi_assert(status == FuriStatusOk);
(void)status;
instance->state = InfraredWorkerStateIdle;
}
@ -325,7 +322,7 @@ void infrared_worker_tx_start(InfraredWorker* instance) {
furi_assert(instance->tx.get_signal_callback);
// size have to be greater than api hal infrared async tx buffer size
xStreamBufferSetTriggerLevel(instance->stream, sizeof(InfraredWorkerTiming));
furi_stream_set_trigger_level(instance->stream, sizeof(InfraredWorkerTiming));
furi_thread_set_callback(instance->thread, infrared_worker_tx_thread);
@ -358,7 +355,7 @@ static FuriHalInfraredTxGetDataState
FuriHalInfraredTxGetDataState state;
if(sizeof(InfraredWorkerTiming) ==
xStreamBufferReceiveFromISR(instance->stream, &timing, sizeof(InfraredWorkerTiming), 0)) {
furi_stream_buffer_receive(instance->stream, &timing, sizeof(InfraredWorkerTiming), 0)) {
*level = timing.level;
*duration = timing.duration;
state = timing.state;
@ -420,7 +417,7 @@ static bool infrared_worker_tx_fill_buffer(InfraredWorker* instance) {
InfraredWorkerTiming timing;
InfraredStatus status = InfraredStatusError;
while(!xStreamBufferIsFull(instance->stream) && !instance->tx.need_reinitialization &&
while(!furi_stream_buffer_is_full(instance->stream) && !instance->tx.need_reinitialization &&
new_data_available) {
if(instance->signal.decoded) {
status = infrared_encode(instance->infrared_encoder, &timing.duration, &timing.level);
@ -454,7 +451,7 @@ static bool infrared_worker_tx_fill_buffer(InfraredWorker* instance) {
furi_assert(0);
}
uint32_t written_size =
xStreamBufferSend(instance->stream, &timing, sizeof(InfraredWorkerTiming), 0);
furi_stream_buffer_send(instance->stream, &timing, sizeof(InfraredWorkerTiming), 0);
furi_assert(sizeof(InfraredWorkerTiming) == written_size);
(void)written_size;
}
@ -564,10 +561,9 @@ void infrared_worker_tx_stop(InfraredWorker* instance) {
furi_hal_infrared_async_tx_set_signal_sent_isr_callback(NULL, NULL);
instance->signal.timings_cnt = 0;
BaseType_t xReturn = pdFAIL;
xReturn = xStreamBufferReset(instance->stream);
furi_assert(xReturn == pdPASS);
(void)xReturn;
FuriStatus status = furi_stream_buffer_reset(instance->stream);
furi_assert(status == FuriStatusOk);
(void)status;
instance->state = InfraredWorkerStateIdle;
}

23
lib/lfrfid/lfrfid_raw_worker.c
View File

@ -2,7 +2,6 @@
#include <toolbox/stream/file_stream.h>
#include <toolbox/buffer_stream.h>
#include <toolbox/varint.h>
#include <stream_buffer.h>
#include "lfrfid_raw_worker.h"
#include "lfrfid_raw_file.h"
#include "tools/varint_pair.h"
@ -16,7 +15,7 @@
// emulate mode
typedef struct {
size_t overrun_count;
StreamBufferHandle_t stream;
FuriStreamBuffer* stream;
} RfidEmulateCtx;
typedef struct {
@ -126,20 +125,13 @@ void lfrfid_raw_worker_stop(LFRFIDRawWorker* worker) {
static void lfrfid_raw_worker_capture(bool level, uint32_t duration, void* context) {
LFRFIDRawWorkerReadData* ctx = context;
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
bool need_to_send = varint_pair_pack(ctx->pair, level, duration);
if(need_to_send) {
buffer_stream_send_from_isr(
ctx->stream,
varint_pair_get_data(ctx->pair),
varint_pair_get_size(ctx->pair),
&xHigherPriorityTaskWoken);
ctx->stream, varint_pair_get_data(ctx->pair), varint_pair_get_size(ctx->pair));
varint_pair_reset(ctx->pair);
}
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
static int32_t lfrfid_raw_read_worker_thread(void* thread_context) {
@ -236,7 +228,7 @@ static void rfid_emulate_dma_isr(bool half, void* context) {
RfidEmulateCtx* ctx = context;
uint32_t flag = half ? HalfTransfer : TransferComplete;
size_t len = xStreamBufferSendFromISR(ctx->stream, &flag, sizeof(uint32_t), pdFALSE);
size_t len = furi_stream_buffer_send(ctx->stream, &flag, sizeof(uint32_t), 0);
if(len != sizeof(uint32_t)) {
ctx->overrun_count++;
}
@ -251,7 +243,7 @@ static int32_t lfrfid_raw_emulate_worker_thread(void* thread_context) {
Storage* storage = furi_record_open(RECORD_STORAGE);
data->ctx.overrun_count = 0;
data->ctx.stream = xStreamBufferCreate(sizeof(uint32_t), sizeof(uint32_t));
data->ctx.stream = furi_stream_buffer_alloc(sizeof(uint32_t), sizeof(uint32_t));
LFRFIDRawFile* file = lfrfid_raw_file_alloc(storage);
@ -287,7 +279,8 @@ static int32_t lfrfid_raw_emulate_worker_thread(void* thread_context) {
uint32_t flag = 0;
while(true) {
size_t size = xStreamBufferReceive(data->ctx.stream, &flag, sizeof(uint32_t), 100);
size_t size =
furi_stream_buffer_receive(data->ctx.stream, &flag, sizeof(uint32_t), 100);
if(size == sizeof(uint32_t)) {
size_t start = 0;
@ -345,10 +338,10 @@ static int32_t lfrfid_raw_emulate_worker_thread(void* thread_context) {
}
if(data->ctx.overrun_count) {
FURI_LOG_E(TAG_EMULATE, "overruns: %lu", data->ctx.overrun_count);
FURI_LOG_E(TAG_EMULATE, "overruns: %u", data->ctx.overrun_count);
}
vStreamBufferDelete(data->ctx.stream);
furi_stream_buffer_free(data->ctx.stream);
lfrfid_raw_file_free(file);
furi_record_close(RECORD_STORAGE);
free(data);

18
lib/lfrfid/lfrfid_worker_modes.c
View File

@ -2,7 +2,6 @@
#include <furi_hal.h>
#include "lfrfid_worker_i.h"
#include "tools/t5577.h"
#include <stream_buffer.h>
#include <toolbox/pulse_protocols/pulse_glue.h>
#include <toolbox/buffer_stream.h>
#include "tools/varint_pair.h"
@ -81,17 +80,12 @@ static void lfrfid_worker_read_capture(bool level, uint32_t duration, void* cont
furi_hal_gpio_write(LFRFID_WORKER_READ_DEBUG_GPIO_VALUE, level);
#endif
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
bool need_to_send = varint_pair_pack(ctx->pair, level, duration);
if(need_to_send) {
buffer_stream_send_from_isr(
ctx->stream,
varint_pair_get_data(ctx->pair),
varint_pair_get_size(ctx->pair),
&xHigherPriorityTaskWoken);
ctx->stream, varint_pair_get_data(ctx->pair), varint_pair_get_size(ctx->pair));
varint_pair_reset(ctx->pair);
}
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
typedef enum {
@ -407,14 +401,14 @@ typedef enum {
} LFRFIDWorkerEmulateDMAEvent;
static void lfrfid_worker_emulate_dma_isr(bool half, void* context) {
StreamBufferHandle_t stream = context;
FuriStreamBuffer* stream = context;
uint32_t flag = half ? HalfTransfer : TransferComplete;
xStreamBufferSendFromISR(stream, &flag, sizeof(uint32_t), pdFALSE);
furi_stream_buffer_send(stream, &flag, sizeof(uint32_t), 0);
}
static void lfrfid_worker_mode_emulate_process(LFRFIDWorker* worker) {
LFRFIDWorkerEmulateBuffer* buffer = malloc(sizeof(LFRFIDWorkerEmulateBuffer));
StreamBufferHandle_t stream = xStreamBufferCreate(sizeof(uint32_t), sizeof(uint32_t));
FuriStreamBuffer* stream = furi_stream_buffer_alloc(sizeof(uint32_t), sizeof(uint32_t));
LFRFIDProtocol protocol = worker->protocol;
PulseGlue* pulse_glue = pulse_glue_alloc();
@ -449,7 +443,7 @@ static void lfrfid_worker_mode_emulate_process(LFRFIDWorker* worker) {
while(true) {
uint32_t flag = 0;
size_t size = xStreamBufferReceive(stream, &flag, sizeof(uint32_t), 100);
size_t size = furi_stream_buffer_receive(stream, &flag, sizeof(uint32_t), 100);
#ifdef LFRFID_WORKER_READ_DEBUG_GPIO
furi_hal_gpio_write(LFRFID_WORKER_READ_DEBUG_GPIO_LOAD, true);
@ -497,7 +491,7 @@ static void lfrfid_worker_mode_emulate_process(LFRFIDWorker* worker) {
#endif
free(buffer);
vStreamBufferDelete(stream);
furi_stream_buffer_free(stream);
pulse_glue_free(pulse_glue);
}

2
lib/lfrfid/protocols/protocol_gallagher.c
View File

@ -276,7 +276,7 @@ void protocol_gallagher_render_data(ProtocolGallagher* protocol, FuriString* res
uint32_t card_id = bit_lib_get_bits_32(protocol->data, 32, 32);
furi_string_cat_printf(result, "Region: %u, Issue Level: %u\r\n", rc, il);
furi_string_cat_printf(result, "FC: %u, C: %lu\r\n", fc, card_id);
furi_string_cat_printf(result, "FC: %lu, C: %lu\r\n", fc, card_id);
};
const ProtocolBase protocol_gallagher = {

2
lib/lfrfid/protocols/protocol_keri.c
View File

@ -218,7 +218,7 @@ void protocol_keri_render_data(ProtocolKeri* protocol, FuriString* result) {
uint32_t fc = 0;
uint32_t cn = 0;
protocol_keri_descramble(&fc, &cn, &data);
furi_string_printf(result, "Internal ID: %u\r\nFC: %u, Card: %u\r\n", internal_id, fc, cn);
furi_string_printf(result, "Internal ID: %lu\r\nFC: %lu, Card: %lu\r\n", internal_id, fc, cn);
}
bool protocol_keri_write_data(ProtocolKeri* protocol, void* data) {

2
lib/lfrfid/protocols/protocol_paradox.c
View File

@ -142,7 +142,7 @@ void protocol_paradox_render_data(ProtocolParadox* protocol, FuriString* result)
uint16_t card_id = bit_lib_get_bits_16(decoded_data, 18, 16);
furi_string_cat_printf(result, "Facility: %u\r\n", fc);
furi_string_cat_printf(result, "Card: %lu\r\n", card_id);
furi_string_cat_printf(result, "Card: %u\r\n", card_id);
furi_string_cat_printf(result, "Data: ");
for(size_t i = 0; i < PARADOX_DECODED_DATA_SIZE; i++) {
furi_string_cat_printf(result, "%02X", decoded_data[i]);

2
lib/lfrfid/protocols/protocol_pyramid.c
View File

@ -243,7 +243,7 @@ void protocol_pyramid_render_data(ProtocolPyramid* protocol, FuriString* result)
uint8_t* decoded_data = protocol->data;
uint8_t format_length = decoded_data[0];
furi_string_cat_printf(result, "Format: 26\r\n", format_length);
furi_string_cat_printf(result, "Format: %d\r\n", format_length);
if(format_length == 26) {
uint8_t facility;
bit_lib_copy_bits(&facility, 0, 8, decoded_data, 8);

2
lib/nfc/helpers/mf_classic_dict.c
View File

@ -78,7 +78,7 @@ MfClassicDict* mf_classic_dict_alloc(MfClassicDictType dict_type) {
stream_rewind(dict->stream);
dict_loaded = true;
FURI_LOG_I(TAG, "Loaded dictionary with %d keys", dict->total_keys);
FURI_LOG_I(TAG, "Loaded dictionary with %ld keys", dict->total_keys);
} while(false);
if(!dict_loaded) {

2
lib/nfc/helpers/mfkey32.c
View File

@ -92,7 +92,7 @@ void mfkey32_set_callback(Mfkey32* instance, Mfkey32ParseDataCallback callback,
static bool mfkey32_write_params(Mfkey32* instance, Mfkey32Params* params) {
FuriString* str = furi_string_alloc_printf(
"Sec %d key %c cuid %08x nt0 %08x nr0 %08x ar0 %08x nt1 %08x nr1 %08x ar1 %08x\n",
"Sec %d key %c cuid %08lx nt0 %08lx nr0 %08lx ar0 %08lx nt1 %08lx nr1 %08lx ar1 %08lx\n",
params->sector,
params->key == MfClassicKeyA ? 'A' : 'B',
params->cuid,

17
lib/nfc/helpers/reader_analyzer.c
View File

@ -1,5 +1,4 @@
#include "reader_analyzer.h"
#include <stream_buffer.h>
#include <lib/nfc/protocols/nfc_util.h>
#include <lib/nfc/protocols/mifare_classic.h>
#include <m-array.h>
@ -27,7 +26,7 @@ struct ReaderAnalyzer {
FuriHalNfcDevData nfc_data;
bool alive;
StreamBufferHandle_t stream;
FuriStreamBuffer* stream;
FuriThread* thread;
ReaderAnalyzerParseDataCallback callback;
@ -88,8 +87,8 @@ int32_t reader_analyzer_thread(void* context) {
ReaderAnalyzer* reader_analyzer = context;
uint8_t buffer[READER_ANALYZER_MAX_BUFF_SIZE] = {};
while(reader_analyzer->alive || !xStreamBufferIsEmpty(reader_analyzer->stream)) {
size_t ret = xStreamBufferReceive(
while(reader_analyzer->alive || !furi_stream_buffer_is_empty(reader_analyzer->stream)) {
size_t ret = furi_stream_buffer_receive(
reader_analyzer->stream, buffer, READER_ANALYZER_MAX_BUFF_SIZE, 50);
if(ret) {
reader_analyzer_parse(reader_analyzer, buffer, ret);
@ -107,7 +106,7 @@ ReaderAnalyzer* reader_analyzer_alloc() {
instance->nfc_data = reader_analyzer_nfc_data[ReaderAnalyzerNfcDataMfClassic];
instance->alive = false;
instance->stream =
xStreamBufferCreate(READER_ANALYZER_MAX_BUFF_SIZE, sizeof(ReaderAnalyzerHeader));
furi_stream_buffer_alloc(READER_ANALYZER_MAX_BUFF_SIZE, sizeof(ReaderAnalyzerHeader));
instance->thread = furi_thread_alloc();
furi_thread_set_name(instance->thread, "ReaderAnalyzerWorker");
@ -133,7 +132,7 @@ static void reader_analyzer_mfkey_callback(Mfkey32Event event, void* context) {
void reader_analyzer_start(ReaderAnalyzer* instance, ReaderAnalyzerMode mode) {
furi_assert(instance);
xStreamBufferReset(instance->stream);
furi_stream_buffer_reset(instance->stream);
if(mode & ReaderAnalyzerModeDebugLog) {
instance->debug_log = nfc_debug_log_alloc();
}
@ -175,7 +174,7 @@ void reader_analyzer_free(ReaderAnalyzer* instance) {
reader_analyzer_stop(instance);
furi_thread_free(instance->thread);
vStreamBufferDelete(instance->stream);
furi_stream_buffer_free(instance->stream);
free(instance);
}
@ -219,12 +218,12 @@ static void reader_analyzer_write(
ReaderAnalyzerHeader header = {
.reader_to_tag = reader_to_tag, .crc_dropped = crc_dropped, .len = len};
size_t data_sent = 0;
data_sent = xStreamBufferSend(
data_sent = furi_stream_buffer_send(
instance->stream, &header, sizeof(ReaderAnalyzerHeader), FuriWaitForever);
if(data_sent != sizeof(ReaderAnalyzerHeader)) {
FURI_LOG_W(TAG, "Sent %d out of %d bytes", data_sent, sizeof(ReaderAnalyzerHeader));
}
data_sent = xStreamBufferSend(instance->stream, data, len, FuriWaitForever);
data_sent = furi_stream_buffer_send(instance->stream, data, len, FuriWaitForever);
if(data_sent != len) {
FURI_LOG_W(TAG, "Sent %d out of %d bytes", data_sent, len);
}

3
lib/nfc/nfc_worker.c
View File

@ -474,7 +474,8 @@ void nfc_worker_mf_classic_dict_attack(NfcWorker* nfc_worker) {
return;
}
FURI_LOG_D(TAG, "Start Dictionary attack, Key Count %d", mf_classic_dict_get_total_keys(dict));
FURI_LOG_D(
TAG, "Start Dictionary attack, Key Count %ld", mf_classic_dict_get_total_keys(dict));
for(size_t i = 0; i < total_sectors; i++) {
FURI_LOG_I(TAG, "Sector %d", i);
nfc_worker->callback(NfcWorkerEventNewSector, nfc_worker->context);

2
lib/nfc/parsers/all_in_one.c
View File

@ -108,6 +108,6 @@ bool all_in_one_parser_parse(NfcDeviceData* dev_data) {
// Format string for rides count
furi_string_printf(
dev_data->parsed_data, "\e#All-In-One\nNumber: %u\nRides left: %u", serial, ride_count);
dev_data->parsed_data, "\e#All-In-One\nNumber: %lu\nRides left: %u", serial, ride_count);
return true;
}

2
lib/nfc/parsers/plantain_4k_parser.c
View File

@ -132,7 +132,7 @@ bool plantain_4k_parser_parse(NfcDeviceData* dev_data) {
furi_string_printf(
dev_data->parsed_data,
"\e#Plantain\nN:%s\nBalance:%d\n",
"\e#Plantain\nN:%s\nBalance:%ld\n",
furi_string_get_cstr(card_number_str),
balance);
furi_string_free(card_number_str);

2
lib/nfc/parsers/plantain_parser.c
View File

@ -105,7 +105,7 @@ bool plantain_parser_parse(NfcDeviceData* dev_data) {
furi_string_printf(
dev_data->parsed_data,
"\e#Plantain\nN:%s\nBalance:%d\n",
"\e#Plantain\nN:%s\nBalance:%ld\n",
furi_string_get_cstr(card_number_str),
balance);
furi_string_free(card_number_str);

2
lib/nfc/parsers/two_cities.c
View File

@ -149,7 +149,7 @@ bool two_cities_parser_parse(NfcDeviceData* dev_data) {
furi_string_printf(
dev_data->parsed_data,
"\e#Troika+Plantain\nPN: %s\nPB: %d rur.\nTN: %d\nTB: %d rur.\n",
"\e#Troika+Plantain\nPN: %s\nPB: %ld rur.\nTN: %ld\nTB: %d rur.\n",
furi_string_get_cstr(card_number_str),
balance,
troika_number,

4
lib/nfc/protocols/mifare_classic.c
View File

@ -847,7 +847,7 @@ bool mf_classic_emulator(MfClassicEmulator* emulator, FuriHalNfcTxRxContext* tx_
FURI_LOG_D(
TAG,
"%08x key%c block %d nt/nr/ar: %08x %08x %08x",
"%08lx key%c block %d nt/nr/ar: %08lx %08lx %08lx",
emulator->cuid,
access_key == MfClassicKeyA ? 'A' : 'B',
sector_trailer_block,
@ -858,7 +858,7 @@ bool mf_classic_emulator(MfClassicEmulator* emulator, FuriHalNfcTxRxContext* tx_
crypto1_word(&emulator->crypto, nr, 1);
uint32_t cardRr = ar ^ crypto1_word(&emulator->crypto, 0, 0);
if(cardRr != prng_successor(nonce, 64)) {
FURI_LOG_T(TAG, "Wrong AUTH! %08X != %08X", cardRr, prng_successor(nonce, 64));
FURI_LOG_T(TAG, "Wrong AUTH! %08lX != %08lX", cardRr, prng_successor(nonce, 64));
// Don't send NACK, as the tag doesn't send it
command_processed = true;
break;

8
lib/nfc/protocols/mifare_desfire.c
View File

@ -108,7 +108,7 @@ void mf_df_cat_version(MifareDesfireVersion* version, FuriString* out) {
}
void mf_df_cat_free_mem(MifareDesfireFreeMemory* free_mem, FuriString* out) {
furi_string_cat_printf(out, "freeMem %d\n", free_mem->bytes);
furi_string_cat_printf(out, "freeMem %ld\n", free_mem->bytes);
}
void mf_df_cat_key_settings(MifareDesfireKeySettings* ks, FuriString* out) {
@ -191,10 +191,10 @@ void mf_df_cat_file(MifareDesfireFile* file, FuriString* out) {
case MifareDesfireFileTypeValue:
size = 4;
furi_string_cat_printf(
out, "lo %d hi %d\n", file->settings.value.lo_limit, file->settings.value.hi_limit);
out, "lo %ld hi %ld\n", file->settings.value.lo_limit, file->settings.value.hi_limit);
furi_string_cat_printf(
out,
"limit %d enabled %d\n",
"limit %ld enabled %d\n",
file->settings.value.limited_credit_value,
file->settings.value.limited_credit_enabled);
break;
@ -203,7 +203,7 @@ void mf_df_cat_file(MifareDesfireFile* file, FuriString* out) {
size = file->settings.record.size;
num = file->settings.record.cur;
furi_string_cat_printf(out, "size %d\n", size);
furi_string_cat_printf(out, "num %d max %d\n", num, file->settings.record.max);
furi_string_cat_printf(out, "num %d max %ld\n", num, file->settings.record.max);
break;
}
uint8_t* data = file->contents;

4
lib/nfc/protocols/mifare_ultralight.c
View File

@ -193,7 +193,7 @@ bool mf_ultralight_authenticate(FuriHalNfcTxRxContext* tx_rx, uint32_t key, uint
*pack = (tx_rx->rx_data[1] << 8) | tx_rx->rx_data[0];
}
FURI_LOG_I(TAG, "Auth success. Password: %08X. PACK: %04X", key, *pack);
FURI_LOG_I(TAG, "Auth success. Password: %08lX. PACK: %04X", key, *pack);
authenticated = true;
} while(false);
@ -1050,7 +1050,7 @@ static void mf_ul_make_ascii_mirror(MfUltralightEmulator* emulator, FuriString*
if(mirror_conf == MfUltralightMirrorUidCounter)
furi_string_cat(str, uid_printed ? "x" : " ");
furi_string_cat_printf(str, "%06X", emulator->data.counter[2]);
furi_string_cat_printf(str, "%06lX", emulator->data.counter[2]);
}
}
}

12
lib/one_wire/ibutton/ibutton_worker_modes.c
View File

@ -2,7 +2,6 @@
#include <furi_hal.h>
#include "ibutton_worker_i.h"
#include "ibutton_key_command.h"
#include <stream_buffer.h>
void ibutton_worker_mode_idle_start(iButtonWorker* worker);
void ibutton_worker_mode_idle_tick(iButtonWorker* worker);
@ -65,7 +64,7 @@ void ibutton_worker_mode_idle_stop(iButtonWorker* worker) {
typedef struct {
uint32_t last_dwt_value;
StreamBufferHandle_t stream;
FuriStreamBuffer* stream;
} iButtonReadContext;
void ibutton_worker_comparator_callback(bool level, void* context) {
@ -75,7 +74,7 @@ void ibutton_worker_comparator_callback(bool level, void* context) {
LevelDuration data =
level_duration_make(level, current_dwt_value - read_context->last_dwt_value);
xStreamBufferSend(read_context->stream, &data, sizeof(LevelDuration), 0);
furi_stream_buffer_send(read_context->stream, &data, sizeof(LevelDuration), 0);
read_context->last_dwt_value = current_dwt_value;
}
@ -91,7 +90,7 @@ bool ibutton_worker_read_comparator(iButtonWorker* worker) {
iButtonReadContext read_context = {
.last_dwt_value = DWT->CYCCNT,
.stream = xStreamBufferCreate(sizeof(LevelDuration) * 512, 1),
.stream = furi_stream_buffer_alloc(sizeof(LevelDuration) * 512, 1),
};
furi_hal_rfid_comp_set_callback(ibutton_worker_comparator_callback, &read_context);
@ -100,7 +99,8 @@ bool ibutton_worker_read_comparator(iButtonWorker* worker) {
uint32_t tick_start = furi_get_tick();
while(true) {
LevelDuration level;
size_t ret = xStreamBufferReceive(read_context.stream, &level, sizeof(LevelDuration), 100);
size_t ret =
furi_stream_buffer_receive(read_context.stream, &level, sizeof(LevelDuration), 100);
if((furi_get_tick() - tick_start) > 100) {
break;
@ -141,7 +141,7 @@ bool ibutton_worker_read_comparator(iButtonWorker* worker) {
furi_hal_rfid_comp_set_callback(NULL, NULL);
furi_hal_rfid_pins_reset();
vStreamBufferDelete(read_context.stream);
furi_stream_buffer_free(read_context.stream);
return result;
}

11
lib/print/printf_tiny.h
View File

@ -34,6 +34,7 @@
#include <stdarg.h>
#include <stddef.h>
#include <stdio.h>
#ifdef __cplusplus
extern "C" {
@ -54,7 +55,7 @@ void _putchar(char character);
* \param format A string that specifies the format of the output
* \return The number of characters that are written into the array, not counting the terminating null character
*/
int printf_(const char* format, ...);
int printf_(const char* format, ...) _ATTRIBUTE((__format__(__printf__, 1, 2)));
/**
* Tiny sprintf implementation
@ -63,7 +64,7 @@ int printf_(const char* format, ...);
* \param format A string that specifies the format of the output
* \return The number of characters that are WRITTEN into the buffer, not counting the terminating null character
*/
int sprintf_(char* buffer, const char* format, ...);
int sprintf_(char* buffer, const char* format, ...) _ATTRIBUTE((__format__(__printf__, 2, 3)));
/**
* Tiny snprintf/vsnprintf implementation
@ -75,7 +76,8 @@ int sprintf_(char* buffer, const char* format, ...);
* null character. A value equal or larger than count indicates truncation. Only when the returned value
* is non-negative and less than count, the string has been completely written.
*/
int snprintf_(char* buffer, size_t count, const char* format, ...);
int snprintf_(char* buffer, size_t count, const char* format, ...)
_ATTRIBUTE((__format__(__printf__, 3, 4)));
int vsnprintf_(char* buffer, size_t count, const char* format, va_list va);
/**
@ -94,7 +96,8 @@ int vprintf_(const char* format, va_list va);
* \param format A string that specifies the format of the output
* \return The number of characters that are sent to the output function, not counting the terminating null character
*/
int fctprintf(void (*out)(char character, void* arg), void* arg, const char* format, ...);
int fctprintf(void (*out)(char character, void* arg), void* arg, const char* format, ...)
_ATTRIBUTE((__format__(__printf__, 3, 4)));
#ifdef __cplusplus
}

2
lib/subghz/protocols/came_twee.c
View File

@ -457,7 +457,7 @@ void subghz_protocol_decoder_came_twee_get_string(void* context, FuriString* out
output,
"%s %db\r\n"
"Key:0x%lX%08lX\r\n"
"Btn:%lX\r\n"
"Btn:%X\r\n"
"DIP:" DIP_PATTERN "\r\n",
instance->generic.protocol_name,
instance->generic.data_count_bit,

2
lib/subghz/protocols/doitrand.c
View File

@ -345,7 +345,7 @@ void subghz_protocol_decoder_doitrand_get_string(void* context, FuriString* outp
output,
"%s %dbit\r\n"
"Key:%02lX%08lX\r\n"
"Btn:%lX\r\n"
"Btn:%X\r\n"
"DIP:" DIP_PATTERN "\r\n",
instance->generic.protocol_name,
instance->generic.data_count_bit,

2
lib/subghz/protocols/gate_tx.c
View File

@ -325,7 +325,7 @@ void subghz_protocol_decoder_gate_tx_get_string(void* context, FuriString* outpu
output,
"%s %dbit\r\n"
"Key:%06lX\r\n"
"Sn:%05lX Btn:%lX\r\n",
"Sn:%05lX Btn:%X\r\n",
instance->generic.protocol_name,
instance->generic.data_count_bit,
(uint32_t)(instance->generic.data & 0xFFFFFF),

2
lib/subghz/protocols/honeywell_wdb.c
View File

@ -385,7 +385,7 @@ void subghz_protocol_decoder_honeywell_wdb_get_string(void* context, FuriString*
"Key:0x%lX%08lX\r\n"
"Sn:0x%05lX\r\n"
"DT:%s Al:%s\r\n"
"SK:%01lX R:%01lX LBat:%01lX\r\n",
"SK:%01X R:%01X LBat:%01X\r\n",
instance->generic.protocol_name,
instance->generic.data_count_bit,
(uint32_t)((instance->generic.data >> 32) & 0xFFFFFFFF),

2
lib/subghz/protocols/ido.c
View File

@ -222,7 +222,7 @@ void subghz_protocol_decoder_ido_get_string(void* context, FuriString* output) {
"Key:0x%lX%08lX\r\n"
"Fix:%06lX \r\n"
"Hop:%06lX \r\n"
"Sn:%05lX Btn:%lX\r\n",
"Sn:%05lX Btn:%X\r\n",
instance->generic.protocol_name,
instance->generic.data_count_bit,
(uint32_t)(instance->generic.data >> 32),

2
lib/subghz/protocols/kia.c
View File

@ -268,7 +268,7 @@ void subghz_protocol_decoder_kia_get_string(void* context, FuriString* output) {
output,
"%s %dbit\r\n"
"Key:%08lX%08lX\r\n"
"Sn:%07lX Btn:%lX Cnt:%04X\r\n",
"Sn:%07lX Btn:%X Cnt:%04lX\r\n",
instance->generic.protocol_name,
instance->generic.data_count_bit,
code_found_hi,

2
lib/subghz/protocols/magellen.c
View File

@ -432,7 +432,7 @@ void subghz_protocol_decoder_magellen_get_string(void* context, FuriString* outp
output,
"%s %dbit\r\n"
"Key:0x%08lX\r\n"
"Sn:%03d%03d, Event:0x%02X\r\n"
"Sn:%03ld%03ld, Event:0x%02X\r\n"
"Stat:",
instance->generic.protocol_name,
instance->generic.data_count_bit,

2
lib/subghz/protocols/marantec.c
View File

@ -383,7 +383,7 @@ void subghz_protocol_decoder_marantec_get_string(void* context, FuriString* outp
"%s %db\r\n"
"Key:0x%lX%08lX\r\n"
"Sn:0x%07lX \r\n"
"Btn:%lX\r\n",
"Btn:%X\r\n",
instance->generic.protocol_name,
instance->generic.data_count_bit,
(uint32_t)(instance->generic.data >> 32),

4
lib/subghz/protocols/megacode.c
View File

@ -417,8 +417,8 @@ void subghz_protocol_decoder_megacode_get_string(void* context, FuriString* outp
output,
"%s %dbit\r\n"
"Key:0x%06lX\r\n"
"Sn:0x%04lX - %d\r\n"
"Facility:%X Btn:%X\r\n",
"Sn:0x%04lX - %ld\r\n"
"Facility:%lX Btn:%X\r\n",
instance->generic.protocol_name,
instance->generic.data_count_bit,
(uint32_t)instance->generic.data,

2
lib/subghz/protocols/nice_flor_s.c
View File

@ -531,7 +531,7 @@ void subghz_protocol_decoder_nice_flor_s_get_string(void* context, FuriString* o
"%s %dbit\r\n"
"Key:0x%lX%08lX\r\n"
"Sn:%05lX\r\n"
"Cnt:%04X Btn:%02lX\r\n",
"Cnt:%04lX Btn:%02X\r\n",
instance->generic.protocol_name,
instance->generic.data_count_bit,
code_found_hi,

4
lib/subghz/protocols/oregon2.c
View File

@ -253,7 +253,7 @@ static void
val = ((var_data >> 4) & 0xF) * 10 + ((var_data >> 8) & 0xF);
furi_string_cat_printf(
output,
"Temp: %s%d.%d C\r\n",
"Temp: %s%ld.%ld C\r\n",
(var_data & 0xF) ? "-" : "+",
val,
(uint32_t)(var_data >> 12) & 0xF);
@ -286,7 +286,7 @@ void subghz_protocol_decoder_oregon2_get_string(void* context, FuriString* outpu
furi_string_cat_printf(
output,
"%s\r\n"
"ID: 0x%04lX, ch: %d%s, rc: 0x%02lX\r\n",
"ID: 0x%04lX, ch: %ld%s, rc: 0x%02lX\r\n",
instance->generic.protocol_name,
(uint32_t)sensor_id,
(uint32_t)(instance->generic.data >> 12) & 0xF,

2
lib/subghz/protocols/phoenix_v2.c
View File

@ -329,7 +329,7 @@ void subghz_protocol_decoder_phoenix_v2_get_string(void* context, FuriString* ou
"%s %dbit\r\n"
"Key:%02lX%08lX\r\n"
"Sn:0x%07lX \r\n"
"Btn:%lX\r\n",
"Btn:%X\r\n",
instance->generic.protocol_name,
instance->generic.data_count_bit,
(uint32_t)(instance->generic.data >> 32) & 0xFFFFFFFF,

2
lib/subghz/protocols/princeton.c
View File

@ -364,7 +364,7 @@ void subghz_protocol_decoder_princeton_get_string(void* context, FuriString* out
"Key:0x%08lX\r\n"
"Yek:0x%08lX\r\n"
"Sn:0x%05lX Btn:%01X\r\n"
"Te:%dus\r\n",
"Te:%ldus\r\n",
instance->generic.protocol_name,
instance->generic.data_count_bit,
(uint32_t)(instance->generic.data & 0xFFFFFF),

2
lib/subghz/protocols/princeton_for_testing.c
View File

@ -94,7 +94,7 @@ void subghz_encoder_princeton_for_testing_print_log(void* context) {
((float)instance->time_high / (instance->time_high + instance->time_low)) * 100;
FURI_LOG_I(
TAG "Encoder",
"Radio tx_time=%dus ON=%dus, OFF=%dus, DutyCycle=%d,%d%%",
"Radio tx_time=%ldus ON=%ldus, OFF=%ldus, DutyCycle=%ld,%ld%%",
instance->time_high + instance->time_low,
instance->time_high,
instance->time_low,

2
lib/subghz/protocols/raw.c
View File

@ -126,7 +126,7 @@ bool subghz_protocol_raw_save_to_file_init(
// Open file
if(!flipper_format_file_open_always(
instance->flipper_file, furi_string_get_cstr(temp_str))) {
FURI_LOG_E(TAG, "Unable to open file for write: %s", temp_str);
FURI_LOG_E(TAG, "Unable to open file for write: %s", furi_string_get_cstr(temp_str));
break;
}

2
lib/subghz/protocols/scher_khan.c
View File

@ -275,7 +275,7 @@ void subghz_protocol_decoder_scher_khan_get_string(void* context, FuriString* ou
output,
"%s %dbit\r\n"
"Key:0x%lX%08lX\r\n"
"Sn:%07lX Btn:%lX Cnt:%04X\r\n"
"Sn:%07lX Btn:%X Cnt:%04lX\r\n"
"Pt: %s\r\n",
instance->generic.protocol_name,
instance->generic.data_count_bit,

4
lib/subghz/protocols/secplus_v1.c
View File

@ -606,7 +606,7 @@ void subghz_protocol_decoder_secplus_v1_get_string(void* context, FuriString* ou
furi_string_cat_printf(
output,
"Sn:0x%08lX\r\n"
"Cnt:0x%03X\r\n"
"Cnt:0x%03lX\r\n"
"Sw_id:0x%X\r\n",
instance->generic.serial,
instance->generic.cnt,
@ -625,7 +625,7 @@ void subghz_protocol_decoder_secplus_v1_get_string(void* context, FuriString* ou
furi_string_cat_printf(
output,
"Sn:0x%08lX\r\n"
"Cnt:0x%03X\r\n"
"Cnt:0x%03lX\r\n"
"Sw_id:0x%X\r\n",
instance->generic.serial,
instance->generic.cnt,

2
lib/subghz/protocols/secplus_v2.c
View File

@ -821,7 +821,7 @@ void subghz_protocol_decoder_secplus_v2_get_string(void* context, FuriString* ou
"Pk1:0x%lX%08lX\r\n"
"Pk2:0x%lX%08lX\r\n"
"Sn:0x%08lX Btn:0x%01X\r\n"
"Cnt:0x%03X\r\n",
"Cnt:0x%03lX\r\n",
instance->generic.protocol_name,
instance->generic.data_count_bit,

2
lib/subghz/protocols/somfy_keytis.c
View File

@ -437,7 +437,7 @@ void subghz_protocol_decoder_somfy_keytis_get_string(void* context, FuriString*
"%s %db\r\n"
"%lX%08lX%06lX\r\n"
"Sn:0x%06lX \r\n"
"Cnt:0x%04X\r\n"
"Cnt:0x%04lX\r\n"
"Btn:%s\r\n",
instance->generic.protocol_name,

2
lib/subghz/protocols/somfy_telis.c
View File

@ -374,7 +374,7 @@ void subghz_protocol_decoder_somfy_telis_get_string(void* context, FuriString* o
"%s %db\r\n"
"Key:0x%lX%08lX\r\n"
"Sn:0x%06lX \r\n"
"Cnt:0x%04X\r\n"
"Cnt:0x%04lX\r\n"
"Btn:%s\r\n",
instance->generic.protocol_name,

4
lib/subghz/protocols/star_line.c
View File

@ -730,8 +730,8 @@ void subghz_protocol_decoder_star_line_get_string(void* context, FuriString* out
output,
"%s %dbit\r\n"
"Key:%08lX%08lX\r\n"
"Fix:0x%08lX Cnt:%04X\r\n"
"Hop:0x%08lX Btn:%02lX\r\n"
"Fix:0x%08lX Cnt:%04lX\r\n"
"Hop:0x%08lX Btn:%02X\r\n"
"MF:%s\r\n"
"Sn:0x%07lX \r\n",
instance->generic.protocol_name,

18
lib/subghz/subghz_file_encoder_worker.c
View File

@ -1,5 +1,4 @@
#include "subghz_file_encoder_worker.h"
#include <stream_buffer.h>
#include <toolbox/stream/stream.h>
#include <flipper_format/flipper_format.h>
@ -11,7 +10,7 @@
struct SubGhzFileEncoderWorker {
FuriThread* thread;
StreamBufferHandle_t stream;
FuriStreamBuffer* stream;
Storage* storage;
FlipperFormat* flipper_format;
@ -48,7 +47,7 @@ void subghz_file_encoder_worker_add_level_duration(
if(res) {
instance->level = !instance->level;
xStreamBufferSend(instance->stream, &duration, sizeof(int32_t), 100);
furi_stream_buffer_send(instance->stream, &duration, sizeof(int32_t), 100);
} else {
FURI_LOG_E(TAG, "Invalid level in the stream");
}
@ -95,10 +94,7 @@ LevelDuration subghz_file_encoder_worker_get_level_duration(void* context) {
furi_assert(context);
SubGhzFileEncoderWorker* instance = context;
int32_t duration;
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
int ret = xStreamBufferReceiveFromISR(
instance->stream, &duration, sizeof(int32_t), &xHigherPriorityTaskWoken);
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
int ret = furi_stream_buffer_receive(instance->stream, &duration, sizeof(int32_t), 0);
if(ret == sizeof(int32_t)) {
LevelDuration level_duration = {.level = LEVEL_DURATION_RESET};
if(duration < 0) {
@ -149,7 +145,7 @@ static int32_t subghz_file_encoder_worker_thread(void* context) {
} while(0);
while(res && instance->worker_running) {
size_t stream_free_byte = xStreamBufferSpacesAvailable(instance->stream);
size_t stream_free_byte = furi_stream_buffer_spaces_available(instance->stream);
if((stream_free_byte / sizeof(int32_t)) >= SUBGHZ_FILE_ENCODER_LOAD) {
if(stream_read_line(stream, instance->str_data)) {
furi_string_trim(instance->str_data);
@ -195,7 +191,7 @@ SubGhzFileEncoderWorker* subghz_file_encoder_worker_alloc() {
furi_thread_set_stack_size(instance->thread, 2048);
furi_thread_set_context(instance->thread, instance);
furi_thread_set_callback(instance->thread, subghz_file_encoder_worker_thread);
instance->stream = xStreamBufferCreate(sizeof(int32_t) * 2048, sizeof(int32_t));
instance->stream = furi_stream_buffer_alloc(sizeof(int32_t) * 2048, sizeof(int32_t));
instance->storage = furi_record_open(RECORD_STORAGE);
instance->flipper_format = flipper_format_file_alloc(instance->storage);
@ -211,7 +207,7 @@ SubGhzFileEncoderWorker* subghz_file_encoder_worker_alloc() {
void subghz_file_encoder_worker_free(SubGhzFileEncoderWorker* instance) {
furi_assert(instance);
vStreamBufferDelete(instance->stream);
furi_stream_buffer_free(instance->stream);
furi_thread_free(instance->thread);
furi_string_free(instance->str_data);
@ -227,7 +223,7 @@ bool subghz_file_encoder_worker_start(SubGhzFileEncoderWorker* instance, const c
furi_assert(instance);
furi_assert(!instance->worker_running);
xStreamBufferReset(instance->stream);
furi_stream_buffer_reset(instance->stream);
furi_string_set(instance->file_path, file_path);
instance->worker_running = true;
furi_thread_start(instance->thread);

37
lib/subghz/subghz_tx_rx_worker.c
View File

@ -1,6 +1,5 @@
#include "subghz_tx_rx_worker.h"
#include <stream_buffer.h>
#include <furi.h>
#define TAG "SubGhzTxRxWorker"
@ -13,8 +12,8 @@
struct SubGhzTxRxWorker {
FuriThread* thread;
StreamBufferHandle_t stream_tx;
StreamBufferHandle_t stream_rx;
FuriStreamBuffer* stream_tx;
FuriStreamBuffer* stream_rx;
volatile bool worker_running;
volatile bool worker_stoping;
@ -30,9 +29,9 @@ struct SubGhzTxRxWorker {
bool subghz_tx_rx_worker_write(SubGhzTxRxWorker* instance, uint8_t* data, size_t size) {
furi_assert(instance);
bool ret = false;
size_t stream_tx_free_byte = xStreamBufferSpacesAvailable(instance->stream_tx);
size_t stream_tx_free_byte = furi_stream_buffer_spaces_available(instance->stream_tx);
if(size && (stream_tx_free_byte >= size)) {
if(xStreamBufferSend(
if(furi_stream_buffer_send(
instance->stream_tx, data, size, SUBGHZ_TXRX_WORKER_TIMEOUT_READ_WRITE_BUF) ==
size) {
ret = true;
@ -43,12 +42,12 @@ bool subghz_tx_rx_worker_write(SubGhzTxRxWorker* instance, uint8_t* data, size_t
size_t subghz_tx_rx_worker_available(SubGhzTxRxWorker* instance) {
furi_assert(instance);
return xStreamBufferBytesAvailable(instance->stream_rx);
return furi_stream_buffer_bytes_available(instance->stream_rx);
}
size_t subghz_tx_rx_worker_read(SubGhzTxRxWorker* instance, uint8_t* data, size_t size) {
furi_assert(instance);
return xStreamBufferReceive(instance->stream_rx, data, size, 0);
return furi_stream_buffer_receive(instance->stream_rx, data, size, 0);
}
void subghz_tx_rx_worker_set_callback_have_read(
@ -148,11 +147,11 @@ static int32_t subghz_tx_rx_worker_thread(void* context) {
while(instance->worker_running) {
//transmit
size_tx = xStreamBufferBytesAvailable(instance->stream_tx);
size_tx = furi_stream_buffer_bytes_available(instance->stream_tx);
if(size_tx > 0 && !timeout_tx) {
timeout_tx = 10; //20ms
if(size_tx > SUBGHZ_TXRX_WORKER_MAX_TXRX_SIZE) {
xStreamBufferReceive(
furi_stream_buffer_receive(
instance->stream_tx,
&data,
SUBGHZ_TXRX_WORKER_MAX_TXRX_SIZE,
@ -160,20 +159,20 @@ static int32_t subghz_tx_rx_worker_thread(void* context) {
subghz_tx_rx_worker_tx(instance, data, SUBGHZ_TXRX_WORKER_MAX_TXRX_SIZE);
} else {
//todo checking that he managed to write all the data to the TX buffer
xStreamBufferReceive(
furi_stream_buffer_receive(
instance->stream_tx, &data, size_tx, SUBGHZ_TXRX_WORKER_TIMEOUT_READ_WRITE_BUF);
subghz_tx_rx_worker_tx(instance, data, size_tx);
}
} else {
//recive
if(subghz_tx_rx_worker_rx(instance, data, size_rx)) {
if(xStreamBufferSpacesAvailable(instance->stream_rx) >= size_rx[0]) {
if(furi_stream_buffer_spaces_available(instance->stream_rx) >= size_rx[0]) {
if(instance->callback_have_read &&
xStreamBufferBytesAvailable(instance->stream_rx) == 0) {
furi_stream_buffer_bytes_available(instance->stream_rx) == 0) {
callback_rx = true;
}
//todo checking that he managed to write all the data to the RX buffer
xStreamBufferSend(
furi_stream_buffer_send(
instance->stream_rx,
&data,
size_rx[0],
@ -208,9 +207,9 @@ SubGhzTxRxWorker* subghz_tx_rx_worker_alloc() {
furi_thread_set_context(instance->thread, instance);
furi_thread_set_callback(instance->thread, subghz_tx_rx_worker_thread);
instance->stream_tx =
xStreamBufferCreate(sizeof(uint8_t) * SUBGHZ_TXRX_WORKER_BUF_SIZE, sizeof(uint8_t));
furi_stream_buffer_alloc(sizeof(uint8_t) * SUBGHZ_TXRX_WORKER_BUF_SIZE, sizeof(uint8_t));
instance->stream_rx =
xStreamBufferCreate(sizeof(uint8_t) * SUBGHZ_TXRX_WORKER_BUF_SIZE, sizeof(uint8_t));
furi_stream_buffer_alloc(sizeof(uint8_t) * SUBGHZ_TXRX_WORKER_BUF_SIZE, sizeof(uint8_t));
instance->status = SubGhzTxRxWorkerStatusIDLE;
instance->worker_stoping = true;
@ -221,8 +220,8 @@ SubGhzTxRxWorker* subghz_tx_rx_worker_alloc() {
void subghz_tx_rx_worker_free(SubGhzTxRxWorker* instance) {
furi_assert(instance);
furi_assert(!instance->worker_running);
vStreamBufferDelete(instance->stream_tx);
vStreamBufferDelete(instance->stream_rx);
furi_stream_buffer_free(instance->stream_tx);
furi_stream_buffer_free(instance->stream_rx);
furi_thread_free(instance->thread);
free(instance);
@ -232,8 +231,8 @@ bool subghz_tx_rx_worker_start(SubGhzTxRxWorker* instance, uint32_t frequency) {
furi_assert(instance);
furi_assert(!instance->worker_running);
bool res = false;
xStreamBufferReset(instance->stream_tx);
xStreamBufferReset(instance->stream_rx);
furi_stream_buffer_reset(instance->stream_tx);
furi_stream_buffer_reset(instance->stream_rx);
instance->worker_running = true;

18
lib/subghz/subghz_worker.c
View File

@ -1,13 +1,12 @@
#include "subghz_worker.h"
#include <stream_buffer.h>
#include <furi.h>
#define TAG "SubGhzWorker"
struct SubGhzWorker {
FuriThread* thread;
StreamBufferHandle_t stream;
FuriStreamBuffer* stream;
volatile bool running;
volatile bool overrun;
@ -30,16 +29,14 @@ struct SubGhzWorker {
void subghz_worker_rx_callback(bool level, uint32_t duration, void* context) {
SubGhzWorker* instance = context;
BaseType_t xHigherPriorityTaskWoken = pdFALSE;
LevelDuration level_duration = level_duration_make(level, duration);
if(instance->overrun) {
instance->overrun = false;
level_duration = level_duration_reset();
}
size_t ret = xStreamBufferSendFromISR(
instance->stream, &level_duration, sizeof(LevelDuration), &xHigherPriorityTaskWoken);
size_t ret =
furi_stream_buffer_send(instance->stream, &level_duration, sizeof(LevelDuration), 0);
if(sizeof(LevelDuration) != ret) instance->overrun = true;
portYIELD_FROM_ISR(xHigherPriorityTaskWoken);
}
/** Worker callback thread
@ -52,8 +49,8 @@ static int32_t subghz_worker_thread_callback(void* context) {
LevelDuration level_duration;
while(instance->running) {
int ret =
xStreamBufferReceive(instance->stream, &level_duration, sizeof(LevelDuration), 10);
int ret = furi_stream_buffer_receive(
instance->stream, &level_duration, sizeof(LevelDuration), 10);
if(ret == sizeof(LevelDuration)) {
if(level_duration_is_reset(level_duration)) {
FURI_LOG_E(TAG, "Overrun buffer");
@ -97,7 +94,8 @@ SubGhzWorker* subghz_worker_alloc() {
furi_thread_set_context(instance->thread, instance);
furi_thread_set_callback(instance->thread, subghz_worker_thread_callback);
instance->stream = xStreamBufferCreate(sizeof(LevelDuration) * 4096, sizeof(LevelDuration));
instance->stream =
furi_stream_buffer_alloc(sizeof(LevelDuration) * 4096, sizeof(LevelDuration));
//setting filter
instance->filter_running = true;
@ -109,7 +107,7 @@ SubGhzWorker* subghz_worker_alloc() {
void subghz_worker_free(SubGhzWorker* instance) {
furi_assert(instance);
vStreamBufferDelete(instance->stream);
furi_stream_buffer_free(instance->stream);
furi_thread_free(instance->thread);
free(instance);

23
lib/toolbox/buffer_stream.c
View File

@ -1,5 +1,4 @@
#include "buffer_stream.h"
#include <stream_buffer.h>
struct Buffer {
volatile bool occupied;
@ -10,7 +9,7 @@ struct Buffer {
struct BufferStream {
size_t stream_overrun_count;
StreamBufferHandle_t stream;
FuriStreamBuffer* stream;
size_t index;
Buffer* buffers;
@ -54,7 +53,7 @@ BufferStream* buffer_stream_alloc(size_t buffer_size, size_t buffers_count) {
buffer_stream->buffers[i].data = malloc(buffer_size);
buffer_stream->buffers[i].max_data_size = buffer_size;
}
buffer_stream->stream = xStreamBufferCreate(
buffer_stream->stream = furi_stream_buffer_alloc(
sizeof(BufferStream*) * buffer_stream->max_buffers_count, sizeof(BufferStream*));
buffer_stream->stream_overrun_count = 0;
buffer_stream->index = 0;
@ -66,7 +65,7 @@ void buffer_stream_free(BufferStream* buffer_stream) {
for(size_t i = 0; i < buffer_stream->max_buffers_count; i++) {
free(buffer_stream->buffers[i].data);
}
vStreamBufferDelete(buffer_stream->stream);
furi_stream_buffer_free(buffer_stream->stream);
free(buffer_stream->buffers);
free(buffer_stream);
}
@ -83,11 +82,7 @@ static inline int8_t buffer_stream_get_free_buffer(BufferStream* buffer_stream)
return id;
}
bool buffer_stream_send_from_isr(
BufferStream* buffer_stream,
const uint8_t* data,
size_t size,
BaseType_t* const task_woken) {
bool buffer_stream_send_from_isr(BufferStream* buffer_stream, const uint8_t* data, size_t size) {
Buffer* buffer = &buffer_stream->buffers[buffer_stream->index];
bool result = true;
@ -96,7 +91,7 @@ bool buffer_stream_send_from_isr(
// if buffer is full - send it
buffer->occupied = true;
// we always have space for buffer in stream
xStreamBufferSendFromISR(buffer_stream->stream, &buffer, sizeof(Buffer*), task_woken);
furi_stream_buffer_send(buffer_stream->stream, &buffer, sizeof(Buffer*), 0);
// get new buffer from the pool
int8_t index = buffer_stream_get_free_buffer(buffer_stream);
@ -119,7 +114,8 @@ bool buffer_stream_send_from_isr(
Buffer* buffer_stream_receive(BufferStream* buffer_stream, TickType_t timeout) {
Buffer* buffer;
size_t size = xStreamBufferReceive(buffer_stream->stream, &buffer, sizeof(Buffer*), timeout);
size_t size =
furi_stream_buffer_receive(buffer_stream->stream, &buffer, sizeof(Buffer*), timeout);
if(size == sizeof(Buffer*)) {
return buffer;
@ -134,9 +130,8 @@ size_t buffer_stream_get_overrun_count(BufferStream* buffer_stream) {
void buffer_stream_reset(BufferStream* buffer_stream) {
FURI_CRITICAL_ENTER();
BaseType_t xReturn = xStreamBufferReset(buffer_stream->stream);
furi_assert(xReturn == pdPASS);
UNUSED(xReturn);
furi_stream_buffer_reset(buffer_stream->stream);
buffer_stream->stream_overrun_count = 0;
for(size_t i = 0; i < buffer_stream->max_buffers_count; i++) {
buffer_reset(&buffer_stream->buffers[i]);

7
lib/toolbox/buffer_stream.h
View File

@ -59,14 +59,9 @@ void buffer_stream_free(BufferStream* buffer_stream);
* @param buffer_stream
* @param data
* @param size
* @param task_woken
* @return bool
*/
bool buffer_stream_send_from_isr(
BufferStream* buffer_stream,
const uint8_t* data,
size_t size,
BaseType_t* const task_woken);
bool buffer_stream_send_from_isr(BufferStream* buffer_stream, const uint8_t* data, size_t size);
/**
* @brief Receive buffer from stream

9
lib/toolbox/stream/stream.h
View File

@ -143,7 +143,8 @@ size_t stream_write_cstring(Stream* stream, const char* string);
* @param ...
* @return size_t how many bytes was written
*/
size_t stream_write_format(Stream* stream, const char* format, ...);
size_t stream_write_format(Stream* stream, const char* format, ...)
_ATTRIBUTE((__format__(__printf__, 2, 3)));
/**
* Write formatted string to the stream, va_list version
@ -200,7 +201,8 @@ bool stream_insert_cstring(Stream* stream, const char* string);
* @return true if the operation was successful
* @return false on error
*/
bool stream_insert_format(Stream* stream, const char* format, ...);
bool stream_insert_format(Stream* stream, const char* format, ...)
_ATTRIBUTE((__format__(__printf__, 2, 3)));
/**
* Insert formatted string to the stream, va_list version
@ -251,7 +253,8 @@ bool stream_delete_and_insert_cstring(Stream* stream, size_t delete_size, const
* @return true if the operation was successful
* @return false on error
*/
bool stream_delete_and_insert_format(Stream* stream, size_t delete_size, const char* format, ...);
bool stream_delete_and_insert_format(Stream* stream, size_t delete_size, const char* format, ...)
_ATTRIBUTE((__format__(__printf__, 3, 4)));
/**
* Delete N chars from the stream and insert formatted string to the stream, va_list version