From 5f6aff22558db8c43a5a8f51ccbf2b033c553d47 Mon Sep 17 00:00:00 2001 From: Albert Kharisov Date: Thu, 19 Aug 2021 03:18:42 +0300 Subject: [PATCH] [FL-1472, FL-1596, FL-1673] IRDA: stability improvements (#655) - Restrict with 31 bytes length for remote and signal name - Don't stuck for 0 PWM cycle timings - Support timings > 65535 PWM cycles - Fix remote file open error - Add IRDA TX debug redirect - Add remote parse error print, improve parsing, support tabs - Fix stucks with uncorrect RAW signal values, long strings in remote file, etc - Fix HAL signals capturing (save previous read value) - Fix leak in case of failed parsing --- applications/irda/cli/irda-cli.cpp | 30 +++- applications/irda/irda-app-brute-force.cpp | 14 +- applications/irda/irda-app-brute-force.h | 5 +- applications/irda/irda-app-file-parser.cpp | 153 +++++++++++++----- applications/irda/irda-app-file-parser.h | 15 +- applications/irda/irda-app-remote-manager.cpp | 17 +- applications/irda/irda-app-remote-manager.h | 20 +-- applications/irda/irda-app-signal.cpp | 2 +- applications/irda/irda-app.cpp | 12 ++ applications/irda/irda-app.h | 15 +- .../irda/scene/irda-app-scene-edit-rename.cpp | 13 +- .../scene/irda-app-scene-learn-enter-name.cpp | 2 +- firmware/targets/f6/furi-hal/furi-hal-irda.c | 143 ++++++++++------ .../targets/furi-hal-include/furi-hal-irda.h | 8 +- lib/app-scened-template/file-worker.c | 4 +- lib/irda/worker/irda_transmit.c | 15 +- lib/irda/worker/irda_worker.c | 46 +++--- lib/toolbox/args.h | 7 +- lib/toolbox/path.h | 3 +- 19 files changed, 347 insertions(+), 177 deletions(-) diff --git a/applications/irda/cli/irda-cli.cpp b/applications/irda/cli/irda-cli.cpp index 6cde9c95d..1becdfbbc 100644 --- a/applications/irda/cli/irda-cli.cpp +++ b/applications/irda/cli/irda-cli.cpp @@ -74,6 +74,12 @@ static void irda_cli_print_usage(void) { printf(" %s", irda_get_protocol_name((IrdaProtocol)i)); } printf("\r\n"); + printf("\tRaw format:\r\n"); + printf("\tir_tx RAW F: DC: ...\r\n"); + printf( + "\tFrequency (%d - %d), Duty cycle (0 - 100), max 512 samples\r\n", + IRDA_MIN_FREQUENCY, + IRDA_MAX_FREQUENCY); } static bool parse_message(const char* str, IrdaMessage* message) { @@ -115,6 +121,14 @@ static bool parse_signal_raw( *duty_cycle = (float)atoi(duty_cycle_str) / 100; str += strlen(frequency_str) + strlen(duty_cycle_str) + 10; + if((*frequency > IRDA_MAX_FREQUENCY) || (*frequency < IRDA_MIN_FREQUENCY)) { + return false; + } + + if((*duty_cycle <= 0) || (*duty_cycle > 1)) { + return false; + } + uint32_t timings_cnt_max = *timings_cnt; *timings_cnt = 0; @@ -131,13 +145,15 @@ static bool parse_signal_raw( ++*timings_cnt; } - printf("\r\nTransmit:"); - for(size_t i = 0; i < *timings_cnt; ++i) { - printf(" %ld", timings[i]); + if(*timings_cnt > 0) { + printf("\r\nTransmit:"); + for(size_t i = 0; i < *timings_cnt; ++i) { + printf(" %ld", timings[i]); + } + printf("\r\n"); } - printf("\r\n"); - return true; + return (parsed == 2) && (*timings_cnt > 0); } static void irda_cli_start_ir_tx(Cli* cli, string_t args, void* context) { @@ -150,8 +166,8 @@ static void irda_cli_start_ir_tx(Cli* cli, string_t args, void* context) { const char* str = string_get_cstr(args); uint32_t frequency; float duty_cycle; - uint32_t* timings = (uint32_t*)furi_alloc(sizeof(uint32_t) * 1000); - uint32_t timings_cnt = 1000; + uint32_t* timings = (uint32_t*)furi_alloc(sizeof(uint32_t) * 512); + uint32_t timings_cnt = 512; if(parse_message(str, &message)) { irda_send(&message, 1); diff --git a/applications/irda/irda-app-brute-force.cpp b/applications/irda/irda-app-brute-force.cpp index 42797d219..ab8c039bb 100644 --- a/applications/irda/irda-app-brute-force.cpp +++ b/applications/irda/irda-app-brute-force.cpp @@ -1,8 +1,10 @@ #include "irda-app-brute-force.h" #include "irda/irda-app-file-parser.h" -#include "m-string.h" -#include + #include +#include +#include +#include void IrdaAppBruteForce::add_record(int index, const char* name) { records[name].index = index; @@ -16,7 +18,7 @@ bool IrdaAppBruteForce::calculate_messages() { file_parser = std::make_unique(); fs_res = file_parser->open_irda_file_read(universal_db_filename); if(!fs_res) { - file_parser.reset(nullptr); + file_parser.reset(); return false; } @@ -31,7 +33,7 @@ bool IrdaAppBruteForce::calculate_messages() { } file_parser->close(); - file_parser.reset(nullptr); + file_parser.reset(); return true; } @@ -43,7 +45,7 @@ void IrdaAppBruteForce::stop_bruteforce() { furi_assert(file_parser); current_record.clear(); file_parser->close(); - file_parser.reset(nullptr); + file_parser.reset(); } } @@ -81,7 +83,7 @@ bool IrdaAppBruteForce::start_bruteforce(int index, int& record_amount) { file_parser = std::make_unique(); result = file_parser->open_irda_file_read(universal_db_filename); if(!result) { - (void)file_parser.reset(nullptr); + file_parser.reset(); } } diff --git a/applications/irda/irda-app-brute-force.h b/applications/irda/irda-app-brute-force.h index 174f74f54..58736759b 100644 --- a/applications/irda/irda-app-brute-force.h +++ b/applications/irda/irda-app-brute-force.h @@ -1,7 +1,8 @@ #pragma once -#include "furi/check.h" -#include + #include "irda-app-file-parser.h" + +#include #include class IrdaAppBruteForce { diff --git a/applications/irda/irda-app-file-parser.cpp b/applications/irda/irda-app-file-parser.cpp index 8cd0499b6..f462919e6 100644 --- a/applications/irda/irda-app-file-parser.cpp +++ b/applications/irda/irda-app-file-parser.cpp @@ -1,22 +1,16 @@ #include "irda-app-file-parser.h" -#include "furi/check.h" #include "irda-app-remote-manager.h" #include "irda-app-signal.h" -#include "m-string.h" + +#include +#include #include #include -#include -#include -#include #include #include +#include #include -uint32_t const IrdaAppFileParser::max_line_length = ((9 + 1) * 512 + 100); -const char* IrdaAppFileParser::irda_directory = "/any/irda"; -const char* IrdaAppFileParser::irda_extension = ".ir"; -uint32_t const IrdaAppFileParser::max_raw_timings_in_signal = 512; - bool IrdaAppFileParser::open_irda_file_read(const char* name) { std::string full_filename; if(name[0] != '/') @@ -158,18 +152,41 @@ std::unique_ptr IrdaProtocol protocol = irda_get_protocol_by_name(protocol_name); if(!irda_is_protocol_valid((IrdaProtocol)protocol)) { + size_t end_of_str = MIN(str.find_last_not_of(" \t\r\n") + 1, (size_t)30); + FURI_LOG_E( + "IrdaFileParser", + "Unknown protocol(\'%.*s...\'): \'%s\'", + end_of_str, + str.c_str(), + protocol_name); return nullptr; } int address_length = irda_get_protocol_address_length(protocol); uint32_t address_mask = (1LU << (4 * address_length)) - 1; if(address != (address & address_mask)) { + size_t end_of_str = MIN(str.find_last_not_of(" \t\r\n") + 1, (size_t)30); + FURI_LOG_E( + "IrdaFileParser", + "Signal(\'%.*s...\'): address is too long (mask for this protocol is 0x%08X): 0x%X", + end_of_str, + str.c_str(), + address_mask, + address); return nullptr; } int command_length = irda_get_protocol_command_length(protocol); uint32_t command_mask = (1LU << (4 * command_length)) - 1; if(command != (command & command_mask)) { + size_t end_of_str = MIN(str.find_last_not_of(" \t\r\n") + 1, (size_t)30); + FURI_LOG_E( + "IrdaFileParser", + "Signal(\'%.*s...\'): command is too long (mask for this protocol is 0x%08X): 0x%X", + end_of_str, + str.c_str(), + command_mask, + command); return nullptr; } @@ -195,34 +212,81 @@ const char* find_first_not_of(const char* str, char symbol) { return str; } +static int remove_args32(std::string_view& str, size_t num) { + int removed_length = 0; + + while(num--) { + char buf[32]; + + size_t index = str.find_first_not_of(" \t"); + if(index == std::string_view::npos) break; + removed_length += index; + str.remove_prefix(index); + + if(str.empty()) break; + + int parsed = std::sscanf(str.data(), "%31s", buf); + if(!parsed) break; + + size_t len = strlen(buf); + if(!len) break; + removed_length += len; + str.remove_prefix(len); + + if(str.empty()) break; + } + + return removed_length; +} + std::unique_ptr IrdaAppFileParser::parse_signal_raw(const std::string& string) const { uint32_t frequency; uint32_t duty_cycle; - int str_len = string.size(); std::string_view str(string.c_str()); auto irda_file_signal = std::make_unique(); int parsed = std::sscanf( str.data(), "%31s RAW F:%ld DC:%ld", irda_file_signal->name, &frequency, &duty_cycle); - if((parsed != 3) || (frequency > 42000) || (frequency < 32000) || (duty_cycle == 0) || - (duty_cycle >= 100)) { + if(parsed != 3) { return nullptr; } - char dummy[100] = {0}; - int header_len = 0; - header_len = sniprintf( - dummy, - sizeof(dummy), - "%.31s RAW F:%ld DC:%ld", - irda_file_signal->name, - frequency, - duty_cycle); + if((frequency < IRDA_MIN_FREQUENCY) || (frequency > IRDA_MAX_FREQUENCY)) { + size_t end_of_str = MIN(string.find_last_not_of(" \t\r\n") + 1, (size_t)30); + FURI_LOG_E( + "IrdaFileParser", + "RAW signal(\'%.*s...\'): frequency is out of bounds (%ld-%ld): %ld", + end_of_str, + string.c_str(), + IRDA_MIN_FREQUENCY, + IRDA_MAX_FREQUENCY, + frequency); + return nullptr; + } - furi_assert(header_len < str_len); - str.remove_prefix(header_len); + if((duty_cycle == 0) || (duty_cycle > 100)) { + size_t end_of_str = MIN(string.find_last_not_of(" \t\r\n") + 1, (size_t)30); + FURI_LOG_E( + "IrdaFileParser", + "RAW signal(\'%.*s...\'): duty cycle is out of bounds (0-100): %ld", + end_of_str, + string.c_str(), + duty_cycle); + return nullptr; + } + + int header_len = remove_args32(str, 4); + + size_t last_valid_ch = str.find_last_not_of(" \t\r\n"); + if(last_valid_ch != std::string_view::npos) { + str.remove_suffix(str.size() - last_valid_ch - 1); + } else { + FURI_LOG_E( + "IrdaFileParser", "RAW signal(\'%.*s\'): no timings", header_len, string.c_str()); + return nullptr; + } /* move allocated timings into raw signal object */ IrdaAppSignal::RawSignal raw_signal = { @@ -231,40 +295,59 @@ std::unique_ptr while(!str.empty()) { char buf[10]; - size_t index = str.find_first_not_of(' ', 1); + size_t index = str.find_first_not_of(" \t", 1); if(index == std::string_view::npos) { break; } str.remove_prefix(index); parsed = std::sscanf(str.data(), "%9s", buf); if(parsed != 1) { + FURI_LOG_E( + "IrdaFileParser", + "RAW signal(\'%.*s...\'): failed on timing[%ld] \'%*s\'", + header_len, + string.c_str(), + raw_signal.timings_cnt, + str.size(), + str.data()); result = false; - furi_assert(0); break; } str.remove_prefix(strlen(buf)); int value = atoi(buf); if(value <= 0) { + FURI_LOG_E( + "IrdaFileParser", + "RAW signal(\'%.*s...\'): failed on timing[%ld] \'%s\'", + header_len, + string.c_str(), + raw_signal.timings_cnt, + buf); + result = false; + break; + } + + if(raw_signal.timings_cnt >= max_raw_timings_in_signal) { + FURI_LOG_E( + "IrdaFileParser", + "RAW signal(\'%.*s...\'): too much timings (max %ld)", + header_len, + string.c_str(), + max_raw_timings_in_signal); result = false; - furi_assert(0); break; } raw_signal.timings[raw_signal.timings_cnt] = value; ++raw_signal.timings_cnt; result = true; - if(raw_signal.timings_cnt >= max_raw_timings_in_signal) { - result = false; - furi_assert(0); - break; - } } if(result) { /* copy timings instead of moving them to occupy less than max_raw_timings_in_signal */ irda_file_signal->signal.copy_raw_signal(raw_signal.timings, raw_signal.timings_cnt); } else { - (void)irda_file_signal.release(); + irda_file_signal.reset(); } delete[] raw_signal.timings; return irda_file_signal; @@ -306,13 +389,11 @@ bool IrdaAppFileParser::check_errors() { } std::string IrdaAppFileParser::file_select(const char* selected) { - TextStore* filename_ts = new TextStore(128); + auto filename_ts = std::make_unique(IrdaAppRemoteManager::max_remote_name_length); bool result; result = file_worker.file_select( irda_directory, irda_extension, filename_ts->text, filename_ts->text_size, selected); - delete filename_ts; - return result ? std::string(filename_ts->text) : std::string(); } diff --git a/applications/irda/irda-app-file-parser.h b/applications/irda/irda-app-file-parser.h index f3d42e491..b0c98ad6c 100644 --- a/applications/irda/irda-app-file-parser.h +++ b/applications/irda/irda-app-file-parser.h @@ -1,8 +1,12 @@ #pragma once + +#include "irda-app-signal.h" + #include #include -#include "irda-app-signal.h" #include +#include +#include class IrdaAppFileParser { public: @@ -40,10 +44,11 @@ private: std::unique_ptr parse_signal_raw(const std::string& str) const; std::string make_full_name(const std::string& name) const; - static const char* irda_directory; - static const char* irda_extension; - static const uint32_t max_line_length; - static uint32_t const max_raw_timings_in_signal; + static inline const char* const irda_directory = "/any/irda"; + static inline const char* const irda_extension = ".ir"; + static inline const uint32_t max_raw_timings_in_signal = 512; + static inline const uint32_t max_line_length = + (9 + 1) * IrdaAppFileParser::max_raw_timings_in_signal + 100; FileWorkerCpp file_worker; char file_buf[128]; diff --git a/applications/irda/irda-app-remote-manager.cpp b/applications/irda/irda-app-remote-manager.cpp index cd98893e0..b3f713ce4 100644 --- a/applications/irda/irda-app-remote-manager.cpp +++ b/applications/irda/irda-app-remote-manager.cpp @@ -1,15 +1,14 @@ #include "irda-app-remote-manager.h" -#include -#include "furi.h" -#include "furi/check.h" -#include "gui/modules/button_menu.h" -#include "irda.h" -#include -#include -#include -#include #include "irda-app-file-parser.h" +#include + +#include +#include +#include +#include +#include + static const std::string default_remote_name = "remote"; std::string IrdaAppRemoteManager::find_vacant_remote_name(const std::string& name) { diff --git a/applications/irda/irda-app-remote-manager.h b/applications/irda/irda-app-remote-manager.h index 60993b308..b2a0197fa 100644 --- a/applications/irda/irda-app-remote-manager.h +++ b/applications/irda/irda-app-remote-manager.h @@ -1,13 +1,15 @@ #pragma once -#include -#include -#include -#include -#include -#include -#include + #include "irda-app-signal.h" +#include +#include + +#include +#include +#include +#include + class IrdaAppRemoteButton { friend class IrdaAppRemoteManager; std::string name; @@ -40,13 +42,13 @@ public: }; class IrdaAppRemoteManager { - static const char* irda_directory; - static const char* irda_extension; std::unique_ptr remote; std::string make_full_name(const std::string& remote_name) const; std::string make_remote_name(const std::string& full_name) const; public: + static inline const uint32_t max_button_name_length = 31; + static inline const uint32_t max_remote_name_length = 31; bool add_remote_with_button(const char* button_name, const IrdaAppSignal& signal); bool add_button(const char* button_name, const IrdaAppSignal& signal); diff --git a/applications/irda/irda-app-signal.cpp b/applications/irda/irda-app-signal.cpp index 0a9a79567..45ec37670 100644 --- a/applications/irda/irda-app-signal.cpp +++ b/applications/irda/irda-app-signal.cpp @@ -5,9 +5,9 @@ void IrdaAppSignal::copy_timings(const uint32_t* timings, size_t size) { furi_assert(size); furi_assert(timings); + payload.raw.timings_cnt = size; if(size) { payload.raw.timings = new uint32_t[size]; - payload.raw.timings_cnt = size; memcpy(payload.raw.timings, timings, size * sizeof(uint32_t)); } } diff --git a/applications/irda/irda-app.cpp b/applications/irda/irda-app.cpp index 5dd7c7b48..042d237cc 100644 --- a/applications/irda/irda-app.cpp +++ b/applications/irda/irda-app.cpp @@ -48,6 +48,18 @@ int32_t IrdaApp::run(void* args) { return 0; }; +IrdaApp::IrdaApp() { + furi_check(IrdaAppRemoteManager::max_button_name_length < get_text_store_size()); + notification = static_cast(furi_record_open("notification")); + irda_worker = irda_worker_alloc(); +} + +IrdaApp::~IrdaApp() { + irda_worker_free(irda_worker); + furi_record_close("notification"); + for(auto& [key, scene] : scenes) delete scene; +} + IrdaAppViewManager* IrdaApp::get_view_manager() { return &view_manager; } diff --git a/applications/irda/irda-app.h b/applications/irda/irda-app.h index cc7611a41..904bead3b 100644 --- a/applications/irda/irda-app.h +++ b/applications/irda/irda-app.h @@ -88,19 +88,12 @@ public: static void text_input_callback(void* context); static void popup_callback(void* context); - IrdaApp() { - notification = static_cast(furi_record_open("notification")); - irda_worker = irda_worker_alloc(); - } - ~IrdaApp() { - irda_worker_free(irda_worker); - furi_record_close("notification"); - for(auto& it : scenes) delete it.second; - } + IrdaApp(); + ~IrdaApp(); private: - static const uint8_t text_store_size = 128; - static const uint8_t text_store_max = 2; + static inline const uint8_t text_store_size = 128; + static inline const uint8_t text_store_max = 2; char text_store[text_store_max][text_store_size + 1]; bool learn_new_remote; EditElement element; diff --git a/applications/irda/scene/irda-app-scene-edit-rename.cpp b/applications/irda/scene/irda-app-scene-edit-rename.cpp index d821d03fe..39fbf2ba0 100644 --- a/applications/irda/scene/irda-app-scene-edit-rename.cpp +++ b/applications/irda/scene/irda-app-scene-edit-rename.cpp @@ -3,24 +3,31 @@ void IrdaAppSceneEditRename::on_enter(IrdaApp* app) { IrdaAppViewManager* view_manager = app->get_view_manager(); TextInput* text_input = view_manager->get_text_input(); + size_t enter_name_length = 0; auto remote_manager = app->get_remote_manager(); if(app->get_edit_element() == IrdaApp::EditElement::Button) { furi_assert(app->get_current_button() != IrdaApp::ButtonNA); auto button_name = remote_manager->get_button_name(app->get_current_button()); - strncpy(app->get_text_store(0), button_name.c_str(), app->get_text_store_size()); + char* buffer_str = app->get_text_store(0); + size_t max_len = IrdaAppRemoteManager::max_button_name_length; + strncpy(buffer_str, button_name.c_str(), max_len); + buffer_str[max_len + 1] = 0; + enter_name_length = max_len; + text_input_set_header_text(text_input, "Name the key"); } else { auto remote_name = remote_manager->get_remote_name(); strncpy(app->get_text_store(0), remote_name.c_str(), app->get_text_store_size()); + enter_name_length = IrdaAppRemoteManager::max_remote_name_length; + text_input_set_header_text(text_input, "Name the remote"); } - text_input_set_header_text(text_input, "Name the key"); text_input_set_result_callback( text_input, IrdaApp::text_input_callback, app, app->get_text_store(0), - app->get_text_store_size(), + enter_name_length, false); view_manager->switch_to(IrdaAppViewManager::ViewType::TextInput); diff --git a/applications/irda/scene/irda-app-scene-learn-enter-name.cpp b/applications/irda/scene/irda-app-scene-learn-enter-name.cpp index 185e7fbc3..aa22d6208 100644 --- a/applications/irda/scene/irda-app-scene-learn-enter-name.cpp +++ b/applications/irda/scene/irda-app-scene-learn-enter-name.cpp @@ -26,7 +26,7 @@ void IrdaAppSceneLearnEnterName::on_enter(IrdaApp* app) { IrdaApp::text_input_callback, app, app->get_text_store(0), - app->get_text_store_size(), + IrdaAppRemoteManager::max_button_name_length, false); view_manager->switch_to(IrdaAppViewManager::ViewType::TextInput); diff --git a/firmware/targets/f6/furi-hal/furi-hal-irda.c b/firmware/targets/f6/furi-hal/furi-hal-irda.c index 16e5b8dd8..370fea42c 100644 --- a/firmware/targets/f6/furi-hal/furi-hal-irda.c +++ b/firmware/targets/f6/furi-hal/furi-hal-irda.c @@ -17,6 +17,13 @@ #include #include +#define IRDA_TX_DEBUG 0 + +#if IRDA_TX_DEBUG == 1 +#define gpio_irda_tx gpio_irda_tx_debug +const GpioPin gpio_irda_tx_debug = {.port = GPIOA, .pin = GPIO_PIN_7}; +#endif + #define IRDA_TIM_TX_DMA_BUFFER_SIZE 200 #define IRDA_POLARITY_SHIFT 1 @@ -46,6 +53,9 @@ typedef struct { void* signal_sent_context; IrdaTxBuf buffer[2]; osSemaphoreId_t stop_semaphore; + uint32_t tx_timing_rest_duration; /** if timing is too long (> 0xFFFF), send it in few iterations */ + bool tx_timing_rest_level; + FuriHalIrdaTxGetDataState tx_timing_rest_status; } IrdaTimTx; typedef enum { @@ -62,7 +72,7 @@ static volatile IrdaState furi_hal_irda_state = IrdaStateIdle; static IrdaTimTx irda_tim_tx; static IrdaTimRx irda_tim_rx; -static bool furi_hal_irda_tx_fill_buffer(uint8_t buf_num, uint8_t polarity_shift); +static void furi_hal_irda_tx_fill_buffer(uint8_t buf_num, uint8_t polarity_shift); static void furi_hal_irda_async_tx_free_resources(void); static void furi_hal_irda_tx_dma_set_polarity(uint8_t buf_num, uint8_t polarity_shift); static void furi_hal_irda_tx_dma_set_buffer(uint8_t buf_num); @@ -72,6 +82,7 @@ static void furi_hal_irda_tx_dma_polarity_isr(); static void furi_hal_irda_tx_dma_isr(); static void furi_hal_irda_tim_rx_isr() { + static uint32_t previous_captured_ch2 = 0; /* Timeout */ if(LL_TIM_IsActiveFlag_CC3(TIM2)) { @@ -97,7 +108,7 @@ static void furi_hal_irda_tim_rx_isr() { if(READ_BIT(TIM2->CCMR1, TIM_CCMR1_CC1S)) { /* Low pin level is a Mark state of IRDA signal. Invert level for further processing. */ - uint32_t duration = LL_TIM_IC_GetCaptureCH1(TIM2) - LL_TIM_IC_GetCaptureCH2(TIM2); + uint32_t duration = LL_TIM_IC_GetCaptureCH1(TIM2) - previous_captured_ch2; if (irda_tim_rx.capture_callback) irda_tim_rx.capture_callback(irda_tim_rx.capture_context, 1, duration); } else { @@ -113,6 +124,7 @@ static void furi_hal_irda_tim_rx_isr() { if(READ_BIT(TIM2->CCMR1, TIM_CCMR1_CC2S)) { /* High pin level is a Space state of IRDA signal. Invert level for further processing. */ uint32_t duration = LL_TIM_IC_GetCaptureCH2(TIM2); + previous_captured_ch2 = duration; if (irda_tim_rx.capture_callback) irda_tim_rx.capture_callback(irda_tim_rx.capture_context, 0, duration); } else { @@ -258,14 +270,10 @@ static void furi_hal_irda_tx_dma_isr() { if (irda_tim_tx.buffer[buf_num].last_packet_end) { LL_DMA_DisableIT_HT(DMA1, LL_DMA_CHANNEL_2); } else if (!irda_tim_tx.buffer[buf_num].packet_end || (furi_hal_irda_state == IrdaStateAsyncTx)) { - bool result = furi_hal_irda_tx_fill_buffer(next_buf_num, 0); + furi_hal_irda_tx_fill_buffer(next_buf_num, 0); if (irda_tim_tx.buffer[next_buf_num].last_packet_end) { LL_DMA_DisableIT_HT(DMA1, LL_DMA_CHANNEL_2); } - if (!result) { - furi_assert(0); - furi_hal_irda_state = IrdaStateAsyncTxStopReq; - } } else if (furi_hal_irda_state == IrdaStateAsyncTxStopReq) { /* fallthrough */ } else { @@ -291,7 +299,7 @@ static void furi_hal_irda_tx_dma_isr() { /* if it's not end of the packet - continue receiving */ furi_hal_irda_tx_dma_set_buffer(next_buf_num); } - if (irda_tim_tx.signal_sent_callback) { + if (irda_tim_tx.signal_sent_callback && irda_tim_tx.buffer[buf_num].packet_end && (furi_hal_irda_state != IrdaStateAsyncTxStopped)) { irda_tim_tx.signal_sent_callback(irda_tim_tx.signal_sent_context); } } @@ -309,6 +317,16 @@ static void furi_hal_irda_configure_tim_pwm_tx(uint32_t freq, float duty_cycle) LL_TIM_SetCounterMode(TIM1, LL_TIM_COUNTERMODE_UP); LL_TIM_EnableARRPreload(TIM1); LL_TIM_SetAutoReload(TIM1, __LL_TIM_CALC_ARR(SystemCoreClock, LL_TIM_GetPrescaler(TIM1), freq)); +#if IRDA_TX_DEBUG == 1 + LL_TIM_OC_SetCompareCH1(TIM1, ( (LL_TIM_GetAutoReload(TIM1) + 1 ) * (1 - duty_cycle))); + LL_TIM_OC_EnablePreload(TIM1, LL_TIM_CHANNEL_CH1); + /* LL_TIM_OCMODE_PWM2 set by DMA */ + LL_TIM_OC_SetMode(TIM1, LL_TIM_CHANNEL_CH1, LL_TIM_OCMODE_FORCED_INACTIVE); + LL_TIM_OC_SetPolarity(TIM1, LL_TIM_CHANNEL_CH1N, LL_TIM_OCPOLARITY_HIGH); + LL_TIM_OC_DisableFast(TIM1, LL_TIM_CHANNEL_CH1); + LL_TIM_CC_EnableChannel(TIM1, LL_TIM_CHANNEL_CH1N); + LL_TIM_DisableIT_CC1(TIM1); +#else LL_TIM_OC_SetCompareCH3(TIM1, ( (LL_TIM_GetAutoReload(TIM1) + 1 ) * (1 - duty_cycle))); LL_TIM_OC_EnablePreload(TIM1, LL_TIM_CHANNEL_CH3); /* LL_TIM_OCMODE_PWM2 set by DMA */ @@ -317,6 +335,7 @@ static void furi_hal_irda_configure_tim_pwm_tx(uint32_t freq, float duty_cycle) LL_TIM_OC_DisableFast(TIM1, LL_TIM_CHANNEL_CH3); LL_TIM_CC_EnableChannel(TIM1, LL_TIM_CHANNEL_CH3N); LL_TIM_DisableIT_CC3(TIM1); +#endif LL_TIM_DisableMasterSlaveMode(TIM1); LL_TIM_EnableAllOutputs(TIM1); LL_TIM_DisableIT_UPDATE(TIM1); @@ -330,7 +349,11 @@ static void furi_hal_irda_configure_tim_cmgr2_dma_tx(void) { LL_C2_AHB1_GRP1_EnableClock(LL_C2_AHB1_GRP1_PERIPH_DMA1); LL_DMA_InitTypeDef dma_config = {0}; +#if IRDA_TX_DEBUG == 1 + dma_config.PeriphOrM2MSrcAddress = (uint32_t)&(TIM1->CCMR1); +#else dma_config.PeriphOrM2MSrcAddress = (uint32_t)&(TIM1->CCMR2); +#endif dma_config.MemoryOrM2MDstAddress = (uint32_t) NULL; dma_config.Direction = LL_DMA_DIRECTION_MEMORY_TO_PERIPH; dma_config.Mode = LL_DMA_MODE_NORMAL; @@ -399,7 +422,7 @@ static void furi_hal_irda_tx_fill_buffer_last(uint8_t buf_num) { irda_tim_tx.buffer[buf_num].packet_end = true; } -static bool furi_hal_irda_tx_fill_buffer(uint8_t buf_num, uint8_t polarity_shift) { +static void furi_hal_irda_tx_fill_buffer(uint8_t buf_num, uint8_t polarity_shift) { furi_assert(buf_num < 2); furi_assert(furi_hal_irda_state != IrdaStateAsyncRx); furi_assert(furi_hal_irda_state < IrdaStateMAX); @@ -418,28 +441,53 @@ static bool furi_hal_irda_tx_fill_buffer(uint8_t buf_num, uint8_t polarity_shift } for (*size = 0; (*size < IRDA_TIM_TX_DMA_BUFFER_SIZE) && (status == FuriHalIrdaTxGetDataStateOk); ++(*size), ++polarity_counter) { - status = irda_tim_tx.data_callback(irda_tim_tx.data_context, &duration, &level); - if (status == FuriHalIrdaTxGetDataStateError) { - furi_assert(0); - break; + if (irda_tim_tx.tx_timing_rest_duration > 0) { + if (irda_tim_tx.tx_timing_rest_duration > 0xFFFF) { + buffer->data[*size] = 0xFFFF; + status = FuriHalIrdaTxGetDataStateOk; + } else { + buffer->data[*size] = irda_tim_tx.tx_timing_rest_duration; + status = irda_tim_tx.tx_timing_rest_status; + } + irda_tim_tx.tx_timing_rest_duration -= buffer->data[*size]; + buffer->polarity[polarity_counter] = irda_tim_tx.tx_timing_rest_level ? IRDA_TX_CCMR_HIGH : IRDA_TX_CCMR_LOW; + continue; } + status = irda_tim_tx.data_callback(irda_tim_tx.data_context, &duration, &level); + uint32_t num_of_impulses = roundf(duration / irda_tim_tx.cycle_duration); - if ((buffer->data[*size] + num_of_impulses - 1) > 0xFFFF) { - furi_assert(0); - status = FuriHalIrdaTxGetDataStateError; - break; + if (num_of_impulses == 0) { + if ((*size == 0) && (status == FuriHalIrdaTxGetDataStateDone)) { + /* if this is one sample in current buffer, but we + * have more to send - continue + */ + status = FuriHalIrdaTxGetDataStateOk; + } + --(*size); + --polarity_counter; + } else if ((num_of_impulses - 1) > 0xFFFF) { + irda_tim_tx.tx_timing_rest_duration = num_of_impulses - 1; + irda_tim_tx.tx_timing_rest_status = status; + irda_tim_tx.tx_timing_rest_level = level; + buffer->polarity[polarity_counter] = level ? IRDA_TX_CCMR_HIGH : IRDA_TX_CCMR_LOW; + buffer->data[*size] = 0xFFFF; + status = FuriHalIrdaTxGetDataStateOk; + } else { + buffer->polarity[polarity_counter] = level ? IRDA_TX_CCMR_HIGH : IRDA_TX_CCMR_LOW; + buffer->data[*size] = num_of_impulses - 1; } - - buffer->polarity[polarity_counter] = level ? IRDA_TX_CCMR_HIGH : IRDA_TX_CCMR_LOW; - buffer->data[*size] = num_of_impulses - 1; } buffer->last_packet_end = (status == FuriHalIrdaTxGetDataStateLastDone); buffer->packet_end = buffer->last_packet_end || (status == FuriHalIrdaTxGetDataStateDone); - return status != FuriHalIrdaTxGetDataStateError; + if (*size == 0) { + buffer->data[0] = 0; // 1 pulse + buffer->polarity[0] = IRDA_TX_CCMR_LOW; + buffer->size = 1; + } } static void furi_hal_irda_tx_dma_set_polarity(uint8_t buf_num, uint8_t polarity_shift) { @@ -505,10 +553,9 @@ static void furi_hal_irda_async_tx_free_resources(void) { irda_tim_tx.buffer[1].polarity = NULL; } -bool furi_hal_irda_async_tx_start(uint32_t freq, float duty_cycle) { - if ((duty_cycle > 1) || (duty_cycle < 0) || (freq > 40000) || (freq < 10000) || (irda_tim_tx.data_callback == NULL)) { - furi_assert(0); - return false; +void furi_hal_irda_async_tx_start(uint32_t freq, float duty_cycle) { + if ((duty_cycle > 1) || (duty_cycle <= 0) || (freq > IRDA_MAX_FREQUENCY) || (freq < IRDA_MIN_FREQUENCY) || (irda_tim_tx.data_callback == NULL)) { + furi_check(0); } furi_assert(furi_hal_irda_state == IrdaStateIdle); @@ -527,37 +574,31 @@ bool furi_hal_irda_async_tx_start(uint32_t freq, float duty_cycle) { irda_tim_tx.stop_semaphore = osSemaphoreNew(1, 0, NULL); irda_tim_tx.cycle_duration = 1000000.0 / freq; + irda_tim_tx.tx_timing_rest_duration = 0; - bool result = furi_hal_irda_tx_fill_buffer(0, IRDA_POLARITY_SHIFT); + furi_hal_irda_tx_fill_buffer(0, IRDA_POLARITY_SHIFT); - if (result) { - furi_hal_irda_configure_tim_pwm_tx(freq, duty_cycle); - furi_hal_irda_configure_tim_cmgr2_dma_tx(); - furi_hal_irda_configure_tim_rcr_dma_tx(); - furi_hal_irda_tx_dma_set_polarity(0, IRDA_POLARITY_SHIFT); - furi_hal_irda_tx_dma_set_buffer(0); + furi_hal_irda_configure_tim_pwm_tx(freq, duty_cycle); + furi_hal_irda_configure_tim_cmgr2_dma_tx(); + furi_hal_irda_configure_tim_rcr_dma_tx(); + furi_hal_irda_tx_dma_set_polarity(0, IRDA_POLARITY_SHIFT); + furi_hal_irda_tx_dma_set_buffer(0); - furi_hal_irda_state = IrdaStateAsyncTx; + furi_hal_irda_state = IrdaStateAsyncTx; - LL_TIM_ClearFlag_UPDATE(TIM1); - LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_1); - LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_2); - delay_us(5); - LL_TIM_GenerateEvent_UPDATE(TIM1); /* DMA -> TIMx_RCR */ - delay_us(5); - LL_GPIO_ResetOutputPin(gpio_irda_tx.port, gpio_irda_tx.pin); /* when disable it prevents false pulse */ - hal_gpio_init_ex(&gpio_irda_tx, GpioModeAltFunctionPushPull, GpioPullUp, GpioSpeedHigh, GpioAltFn1TIM1); + LL_TIM_ClearFlag_UPDATE(TIM1); + LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_1); + LL_DMA_EnableChannel(DMA1, LL_DMA_CHANNEL_2); + delay_us(5); + LL_TIM_GenerateEvent_UPDATE(TIM1); /* DMA -> TIMx_RCR */ + delay_us(5); + LL_GPIO_ResetOutputPin(gpio_irda_tx.port, gpio_irda_tx.pin); /* when disable it prevents false pulse */ + hal_gpio_init_ex(&gpio_irda_tx, GpioModeAltFunctionPushPull, GpioPullUp, GpioSpeedHigh, GpioAltFn1TIM1); - __disable_irq(); - LL_TIM_GenerateEvent_UPDATE(TIM1); /* TIMx_RCR -> Repetition counter */ - LL_TIM_EnableCounter(TIM1); - __enable_irq(); - - } else { - furi_hal_irda_async_tx_free_resources(); - } - - return result; + __disable_irq(); + LL_TIM_GenerateEvent_UPDATE(TIM1); /* TIMx_RCR -> Repetition counter */ + LL_TIM_EnableCounter(TIM1); + __enable_irq(); } void furi_hal_irda_async_tx_wait_termination(void) { diff --git a/firmware/targets/furi-hal-include/furi-hal-irda.h b/firmware/targets/furi-hal-include/furi-hal-irda.h index 6e490402f..260180d26 100644 --- a/firmware/targets/furi-hal-include/furi-hal-irda.h +++ b/firmware/targets/furi-hal-include/furi-hal-irda.h @@ -7,8 +7,10 @@ extern "C" { #endif +#define IRDA_MAX_FREQUENCY 56000 +#define IRDA_MIN_FREQUENCY 10000 + typedef enum { - FuriHalIrdaTxGetDataStateError, /* An error occured during transmission */ FuriHalIrdaTxGetDataStateOk, /* New data obtained */ FuriHalIrdaTxGetDataStateDone, /* New data obtained, and this is end of package */ FuriHalIrdaTxGetDataStateLastDone, /* New data obtained, and this is end of package and no more data available */ @@ -103,10 +105,8 @@ void furi_hal_irda_async_tx_set_data_isr_callback(FuriHalIrdaTxGetDataISRCallbac * * @param[in] freq - frequency for PWM * @param[in] duty_cycle - duty cycle for PWM - * @return true if transmission successfully started, false otherwise. - * If start failed no need to free resources. */ -bool furi_hal_irda_async_tx_start(uint32_t freq, float duty_cycle); +void furi_hal_irda_async_tx_start(uint32_t freq, float duty_cycle); /** * Stop IR asynchronous transmission and free resources. diff --git a/lib/app-scened-template/file-worker.c b/lib/app-scened-template/file-worker.c index 3f1bb1752..52427aed6 100644 --- a/lib/app-scened-template/file-worker.c +++ b/lib/app-scened-template/file-worker.c @@ -1,5 +1,5 @@ #include "file-worker.h" -#include "m-string.h" +#include #include #include #include @@ -350,7 +350,7 @@ bool file_worker_read_until_buffered( } } - if(max_length_exceeded) string_clear(str_result); + if(max_length_exceeded) string_clean(str_result); return string_size(str_result) || *file_buf_cnt; } diff --git a/lib/irda/worker/irda_transmit.c b/lib/irda/worker/irda_transmit.c index e87de6ca1..b27b18c07 100644 --- a/lib/irda/worker/irda_transmit.c +++ b/lib/irda/worker/irda_transmit.c @@ -38,7 +38,6 @@ FuriHalIrdaTxGetDataState irda_get_raw_data_callback (void* context, uint32_t* d void irda_send_raw_ext(const uint32_t timings[], uint32_t timings_cnt, bool start_from_mark, uint32_t frequency, float duty_cycle) { furi_assert(timings); - furi_assert(timings_cnt > 1); irda_tx_raw_start_from_mark = start_from_mark; irda_tx_raw_timings_index = 0; @@ -56,7 +55,7 @@ void irda_send_raw(const uint32_t timings[], uint32_t timings_cnt, bool start_fr } FuriHalIrdaTxGetDataState irda_get_data_callback (void* context, uint32_t* duration, bool* level) { - FuriHalIrdaTxGetDataState state = FuriHalIrdaTxGetDataStateError; + FuriHalIrdaTxGetDataState state = FuriHalIrdaTxGetDataStateLastDone; IrdaEncoderHandler* handler = context; IrdaStatus status = IrdaStatusError; @@ -65,7 +64,9 @@ FuriHalIrdaTxGetDataState irda_get_data_callback (void* context, uint32_t* durat } if (status == IrdaStatusError) { - state = FuriHalIrdaTxGetDataStateError; + state = FuriHalIrdaTxGetDataStateLastDone; + *duration = 0; + *level = 0; } else if (status == IrdaStatusOk) { state = FuriHalIrdaTxGetDataStateOk; } else if (status == IrdaStatusDone) { @@ -74,8 +75,7 @@ FuriHalIrdaTxGetDataState irda_get_data_callback (void* context, uint32_t* durat state = FuriHalIrdaTxGetDataStateLastDone; } } else { - furi_assert(0); - state = FuriHalIrdaTxGetDataStateError; + furi_check(0); } return state; @@ -90,8 +90,11 @@ void irda_send(const IrdaMessage* message, int times) { irda_reset_encoder(handler, message); irda_tx_number_of_transmissions = times; + uint32_t frequency = irda_get_protocol_frequency(message->protocol); + float duty_cycle = irda_get_protocol_duty_cycle(message->protocol); + furi_hal_irda_async_tx_set_data_isr_callback(irda_get_data_callback, handler); - furi_hal_irda_async_tx_start(IRDA_COMMON_CARRIER_FREQUENCY, IRDA_COMMON_DUTY_CYCLE); + furi_hal_irda_async_tx_start(frequency, duty_cycle); furi_hal_irda_async_tx_wait_termination(); irda_free_encoder(handler); diff --git a/lib/irda/worker/irda_worker.c b/lib/irda/worker/irda_worker.c index 041ea090c..62d4363f4 100644 --- a/lib/irda/worker/irda_worker.c +++ b/lib/irda/worker/irda_worker.c @@ -44,8 +44,9 @@ struct IrdaWorkerSignal{ size_t timings_cnt; union { IrdaMessage message; - uint32_t timings[MAX_TIMINGS_AMOUNT]; - } data; + /* +1 is for pause we add at the beginning */ + uint32_t timings[MAX_TIMINGS_AMOUNT + 1]; + }; }; struct IrdaWorker { @@ -125,7 +126,7 @@ static void irda_worker_process_timeout(IrdaWorker* instance) { static void irda_worker_process_timings(IrdaWorker* instance, uint32_t duration, bool level) { const IrdaMessage* message_decoded = irda_decode(instance->irda_decoder, level, duration); if (message_decoded) { - instance->signal.data.message = *message_decoded; + instance->signal.message = *message_decoded; instance->signal.timings_cnt = 0; instance->signal.decoded = true; if (instance->rx.received_signal_callback) @@ -137,7 +138,7 @@ static void irda_worker_process_timings(IrdaWorker* instance, uint32_t duration, } if (instance->signal.timings_cnt < MAX_TIMINGS_AMOUNT) { - instance->signal.data.timings[instance->signal.timings_cnt] = duration; + instance->signal.timings[instance->signal.timings_cnt] = duration; ++instance->signal.timings_cnt; } else { uint32_t flags_set = osEventFlagsSet(instance->events, IRDA_WORKER_OVERRUN); @@ -211,7 +212,7 @@ IrdaWorker* irda_worker_alloc() { furi_thread_set_stack_size(instance->thread, 2048); furi_thread_set_context(instance->thread, instance); - size_t buffer_size = MAX(sizeof(IrdaWorkerTiming) * MAX_TIMINGS_AMOUNT, sizeof(LevelDuration) * MAX_TIMINGS_AMOUNT); + size_t buffer_size = MAX(sizeof(IrdaWorkerTiming) * (MAX_TIMINGS_AMOUNT + 1), sizeof(LevelDuration) * MAX_TIMINGS_AMOUNT); instance->stream = xStreamBufferCreate(buffer_size, sizeof(IrdaWorkerTiming)); instance->irda_decoder = irda_alloc_decoder(); instance->irda_encoder = irda_alloc_encoder(); @@ -283,13 +284,13 @@ void irda_worker_get_raw_signal(const IrdaWorkerSignal* signal, const uint32_t** furi_assert(timings); furi_assert(timings_cnt); - *timings = signal->data.timings; + *timings = signal->timings; *timings_cnt = signal->timings_cnt; } const IrdaMessage* irda_worker_get_decoded_signal(const IrdaWorkerSignal* signal) { furi_assert(signal); - return &signal->data.message; + return &signal->message; } void irda_worker_rx_enable_blink_on_receiving(IrdaWorker* instance, bool enable) { @@ -328,21 +329,24 @@ static FuriHalIrdaTxGetDataState irda_worker_furi_hal_data_isr_callback(void* co furi_assert(level); IrdaWorker* instance = context; - IrdaWorkerTiming timing = {.state = FuriHalIrdaTxGetDataStateError} ; + IrdaWorkerTiming timing; + FuriHalIrdaTxGetDataState state; if (sizeof(IrdaWorkerTiming) == xStreamBufferReceiveFromISR(instance->stream, &timing, sizeof(IrdaWorkerTiming), 0)) { *level = timing.level; *duration = timing.duration; - furi_assert(timing.state != FuriHalIrdaTxGetDataStateError); + state = timing.state; } else { furi_assert(0); - timing.state = FuriHalIrdaTxGetDataStateError; + *level = 0; + *duration = 100; + state = FuriHalIrdaTxGetDataStateDone; } uint32_t flags_set = osEventFlagsSet(instance->events, IRDA_WORKER_TX_FILL_BUFFER); furi_check(flags_set & IRDA_WORKER_TX_FILL_BUFFER); - return timing.state; + return state; } static bool irda_get_new_signal(IrdaWorker* instance) { @@ -353,8 +357,8 @@ static bool irda_get_new_signal(IrdaWorker* instance) { uint32_t new_tx_frequency = 0; float new_tx_duty_cycle = 0; if (instance->signal.decoded) { - new_tx_frequency = irda_get_protocol_frequency(instance->signal.data.message.protocol); - new_tx_duty_cycle = irda_get_protocol_duty_cycle(instance->signal.data.message.protocol); + new_tx_frequency = irda_get_protocol_frequency(instance->signal.message.protocol); + new_tx_duty_cycle = irda_get_protocol_duty_cycle(instance->signal.message.protocol); } else { furi_assert(instance->signal.timings_cnt > 1); new_tx_frequency = IRDA_COMMON_CARRIER_FREQUENCY; @@ -366,7 +370,7 @@ static bool irda_get_new_signal(IrdaWorker* instance) { instance->tx.frequency = new_tx_frequency; instance->tx.duty_cycle = new_tx_duty_cycle; if (instance->signal.decoded) { - irda_reset_encoder(instance->irda_encoder, &instance->signal.data.message); + irda_reset_encoder(instance->irda_encoder, &instance->signal.message); } new_signal_obtained = true; } else if (response == IrdaWorkerGetSignalResponseSame) { @@ -390,8 +394,8 @@ static bool irda_worker_tx_fill_buffer(IrdaWorker* instance) { if (instance->signal.decoded) { status = irda_encode(instance->irda_encoder, &timing.duration, &timing.level); } else { - timing.duration = instance->signal.data.timings[instance->tx.tx_raw_cnt]; -/* raw always starts from Mark, but we fulfill it with space delay at start */ + timing.duration = instance->signal.timings[instance->tx.tx_raw_cnt]; +/* raw always starts from Mark, but we fill it with space delay at start */ timing.level = (instance->tx.tx_raw_cnt % 2); ++instance->tx.tx_raw_cnt; if (instance->tx.tx_raw_cnt >= instance->signal.timings_cnt) { @@ -532,16 +536,18 @@ void irda_worker_set_decoded_signal(IrdaWorker* instance, const IrdaMessage* mes furi_assert(message); instance->signal.decoded = true; - instance->signal.data.message = *message; + instance->signal.message = *message; } void irda_worker_set_raw_signal(IrdaWorker* instance, const uint32_t* timings, size_t timings_cnt) { furi_assert(instance); furi_assert(timings); - furi_assert(timings_cnt > 2); + furi_assert(timings_cnt > 0); + size_t max_copy_num = COUNT_OF(instance->signal.timings) - 1; + furi_check(timings_cnt <= max_copy_num); - instance->signal.data.timings[0] = IRDA_RAW_TX_TIMING_DELAY_US; - memcpy(&instance->signal.data.timings[1], timings, timings_cnt * sizeof(uint32_t)); + instance->signal.timings[0] = IRDA_RAW_TX_TIMING_DELAY_US; + memcpy(&instance->signal.timings[1], timings, timings_cnt * sizeof(uint32_t)); instance->signal.decoded = false; instance->signal.timings_cnt = timings_cnt + 1; } diff --git a/lib/toolbox/args.h b/lib/toolbox/args.h index 4d394092d..e6c35e569 100644 --- a/lib/toolbox/args.h +++ b/lib/toolbox/args.h @@ -1,7 +1,8 @@ #pragma once -#include "m-string.h" -#include "stdint.h" -#include "stdbool.h" + +#include +#include +#include #ifdef __cplusplus extern "C" { diff --git a/lib/toolbox/path.h b/lib/toolbox/path.h index fbcf63499..da9b703da 100644 --- a/lib/toolbox/path.h +++ b/lib/toolbox/path.h @@ -1,5 +1,6 @@ #pragma once -#include "m-string.h" + +#include #ifdef __cplusplus extern "C" {