Furi, FuriHal: remove FreeRTOS headers leaks (#3179)

* Furi: remove direct FreeRTOS timers use
* Furi: eliminate FreeRTOS headers leak. What did it cost? Everything...
* SubGhz: proper public api for protocols. Format Sources.
* Furi: slightly less redundant declarations
* Desktop: proper types in printf
* Sync API Symbols
* Furi: add timer reset and fix dolphin service, fix unit tests
* Furi: proper timer restart method naming and correct behavior in timer stopped state.

---------

Co-authored-by: hedger <hedger@nanode.su>

furi/core/base.h

@@ -2,6 +2,7 @@
 
 #include <stdint.h>
 #include <stdbool.h>
+#include <furi_config.h>
 
 #ifdef __cplusplus
 extern "C" {

furi/core/check.c

@@ -55,8 +55,6 @@ PLACE_IN_SECTION("MB_MEM2") uint32_t __furi_check_registers[13] = {0};
                  : "memory");
 
 extern size_t xPortGetTotalHeapSize(void);
-extern size_t xPortGetFreeHeapSize(void);
-extern size_t xPortGetMinimumEverFreeHeapSize(void);
 
 static void __furi_put_uint32_as_text(uint32_t data) {
     char tmp_str[] = "-2147483648";

furi/core/common_defines.h

@@ -2,8 +2,6 @@
 
 #include "core_defines.h"
 #include <stdbool.h>
-#include <FreeRTOS.h>
-#include <task.h>
 
 #ifdef __cplusplus
 extern "C" {

furi/core/critical.c

@@ -1,5 +1,8 @@
 #include "common_defines.h"
 
+#include <FreeRTOS.h>
+#include <task.h>
+
 __FuriCriticalInfo __furi_critical_enter(void) {
     __FuriCriticalInfo info;
 

furi/core/event_flag.c

@@ -2,6 +2,7 @@
 #include "common_defines.h"
 #include "check.h"
 
+#include <FreeRTOS.h>
 #include <event_groups.h>
 
 #define FURI_EVENT_FLAG_MAX_BITS_EVENT_GROUPS 24U

furi/core/kernel.c

@@ -5,6 +5,9 @@
 
 #include <furi_hal.h>
 
+#include <FreeRTOS.h>
+#include <task.h>
+
 #include CMSIS_device_header
 
 bool furi_kernel_is_irq_or_masked() {
@@ -31,6 +34,10 @@ bool furi_kernel_is_irq_or_masked() {
     return (irq);
 }
 
+bool furi_kernel_is_running() {
+    return xTaskGetSchedulerState() != taskSCHEDULER_RUNNING;
+}
+
 int32_t furi_kernel_lock() {
     furi_assert(!furi_kernel_is_irq_or_masked());
 

furi/core/kernel.h

@@ -27,6 +27,12 @@ extern "C" {
  */
 bool furi_kernel_is_irq_or_masked();
 
+/** Check if kernel is running
+ *
+ * @return     true if running, false otherwise
+ */
+bool furi_kernel_is_running();
+
 /** Lock kernel, pause process scheduling
  *
  * @warning This should never be called in interrupt request context.

furi/core/memmgr_heap.c

@@ -47,8 +47,8 @@ all the API functions to use the MPU wrappers.  That should only be done when
 task.h is included from an application file. */
 #define MPU_WRAPPERS_INCLUDED_FROM_API_FILE
 
-#include "FreeRTOS.h"
-#include "task.h"
+#include <FreeRTOS.h>
+#include <task.h>
 
 #undef MPU_WRAPPERS_INCLUDED_FROM_API_FILE
 

furi/core/message_queue.c

@@ -1,8 +1,9 @@
 #include "kernel.h"
 #include "message_queue.h"
+#include "check.h"
+
 #include <FreeRTOS.h>
 #include <queue.h>
-#include "check.h"
 
 FuriMessageQueue* furi_message_queue_alloc(uint32_t msg_count, uint32_t msg_size) {
     furi_assert((furi_kernel_is_irq_or_masked() == 0U) && (msg_count > 0U) && (msg_size > 0U));

furi/core/mutex.c

@@ -2,6 +2,7 @@
 #include "check.h"
 #include "common_defines.h"
 
+#include <FreeRTOS.h>
 #include <semphr.h>
 
 FuriMutex* furi_mutex_alloc(FuriMutexType type) {

furi/core/semaphore.c

@@ -2,6 +2,7 @@
 #include "check.h"
 #include "common_defines.h"
 
+#include <FreeRTOS.h>
 #include <semphr.h>
 
 FuriSemaphore* furi_semaphore_alloc(uint32_t max_count, uint32_t initial_count) {

furi/core/stream_buffer.c

@@ -2,6 +2,7 @@
 #include "check.h"
 #include "stream_buffer.h"
 #include "common_defines.h"
+
 #include <FreeRTOS.h>
 #include <FreeRTOS-Kernel/include/stream_buffer.h>
 

furi/core/thread.c

@@ -7,11 +7,13 @@
 #include "mutex.h"
 #include "string.h"
 
-#include <task.h>
 #include "log.h"
 #include <furi_hal_rtc.h>
 #include <furi_hal_console.h>
 
+#include <FreeRTOS.h>
+#include <task.h>
+
 #define TAG "FuriThread"
 
 #define THREAD_NOTIFY_INDEX 1 // Index 0 is used for stream buffers

furi/core/thread.h

@@ -8,6 +8,9 @@
 #include "base.h"
 #include "common_defines.h"
 
+#include <stdint.h>
+#include <stddef.h>
+
 #ifdef __cplusplus
 extern "C" {
 #endif
@@ -28,7 +31,8 @@ typedef enum {
     FuriThreadPriorityNormal = 16, /**< Normal */
     FuriThreadPriorityHigh = 17, /**< High */
     FuriThreadPriorityHighest = 18, /**< Highest */
-    FuriThreadPriorityIsr = (configMAX_PRIORITIES - 1), /**< Deferred ISR (highest possible) */
+    FuriThreadPriorityIsr =
+        (FURI_CONFIG_THREAD_MAX_PRIORITIES - 1), /**< Deferred ISR (highest possible) */
 } FuriThreadPriority;
 
 /** FuriThread anonymous structure */

furi/core/timer.c

@@ -97,6 +97,23 @@ FuriStatus furi_timer_start(FuriTimer* instance, uint32_t ticks) {
     return (stat);
 }
 
+FuriStatus furi_timer_restart(FuriTimer* instance) {
+    furi_assert(!furi_kernel_is_irq_or_masked());
+    furi_assert(instance);
+
+    TimerHandle_t hTimer = (TimerHandle_t)instance;
+    FuriStatus stat;
+
+    if(xTimerReset(hTimer, portMAX_DELAY) == pdPASS) {
+        stat = FuriStatusOk;
+    } else {
+        stat = FuriStatusErrorResource;
+    }
+
+    /* Return execution status */
+    return (stat);
+}
+
 FuriStatus furi_timer_stop(FuriTimer* instance) {
     furi_assert(!furi_kernel_is_irq_or_masked());
     furi_assert(instance);
@@ -125,6 +142,15 @@ uint32_t furi_timer_is_running(FuriTimer* instance) {
     return (uint32_t)xTimerIsTimerActive(hTimer);
 }
 
+uint32_t furi_timer_get_expire_time(FuriTimer* instance) {
+    furi_assert(!furi_kernel_is_irq_or_masked());
+    furi_assert(instance);
+
+    TimerHandle_t hTimer = (TimerHandle_t)instance;
+
+    return (uint32_t)xTimerGetExpiryTime(hTimer);
+}
+
 void furi_timer_pending_callback(FuriTimerPendigCallback callback, void* context, uint32_t arg) {
     BaseType_t ret = pdFAIL;
     if(furi_kernel_is_irq_or_masked()) {
@@ -133,4 +159,17 @@ void furi_timer_pending_callback(FuriTimerPendigCallback callback, void* context
         ret = xTimerPendFunctionCall(callback, context, arg, FuriWaitForever);
     }
     furi_check(ret == pdPASS);
+}
+
+void furi_timer_set_thread_priority(FuriTimerThreadPriority priority) {
+    furi_assert(!furi_kernel_is_irq_or_masked());
+    TaskHandle_t task_handle = xTaskGetHandle(configTIMER_SERVICE_TASK_NAME);
+
+    if(priority == FuriTimerThreadPriorityNormal) {
+        vTaskPrioritySet(task_handle, configTIMER_TASK_PRIORITY);
+    } else if(priority == FuriTimerThreadPriorityElevated) {
+        vTaskPrioritySet(task_handle, configMAX_PRIORITIES - 1);
+    } else {
+        furi_crash();
+    }
 }

furi/core/timer.h

@@ -40,6 +40,14 @@ void furi_timer_free(FuriTimer* instance);
  */
 FuriStatus furi_timer_start(FuriTimer* instance, uint32_t ticks);
 
+/** Restart timer with previous timeout value
+ *
+ * @param      instance  The pointer to FuriTimer instance
+ *
+ * @return     The furi status.
+ */
+FuriStatus furi_timer_restart(FuriTimer* instance);
+
 /** Stop timer
  *
  * @param      instance  The pointer to FuriTimer instance
@@ -56,10 +64,29 @@ FuriStatus furi_timer_stop(FuriTimer* instance);
  */
 uint32_t furi_timer_is_running(FuriTimer* instance);
 
+/** Get timer expire time
+ *
+ * @param      instance  The Timer instance
+ *
+ * @return     expire tick
+ */
+uint32_t furi_timer_get_expire_time(FuriTimer* instance);
+
 typedef void (*FuriTimerPendigCallback)(void* context, uint32_t arg);
 
 void furi_timer_pending_callback(FuriTimerPendigCallback callback, void* context, uint32_t arg);
 
+typedef enum {
+    FuriTimerThreadPriorityNormal, /**< Lower then other threads */
+    FuriTimerThreadPriorityElevated, /**< Same as other threads */
+} FuriTimerThreadPriority;
+
+/** Set Timer thread priority
+ *
+ * @param[in]  priority  The priority
+ */
+void furi_timer_set_thread_priority(FuriTimerThreadPriority priority);
+
 #ifdef __cplusplus
 }
 #endif