Furi (#24)

* furiac start and thread create implementation"

* create and kill task

* rename debug, add header

* remove write.c

* kill itself

* furi exit/switch

* success switch and exit

* WIP furi records

* add furi record interface

* rename furi app control file

* record implementation in progress

* wip furi implementation

* add automatic tests for FURI AC

* differ build tests

* small changes

* FURI record tests description

* change furi statuses

* FURI record test blank

* exit after all application ends

* delay: print then wait

* fix FURI implementatnion building

* pipe record test

* concurrent access

* uncomplete mute-test

* update FURI documentation

target_lo/Inc/cmsis_os.h

@@ -1,3 +1,30 @@
 #include "main.h"
+#include <stdbool.h>
 
-void osDelay(uint32_t ms);
+void osDelay(uint32_t ms);
+
+// some FreeRTOS types
+typedef void(*TaskFunction_t)(void*);
+typedef uint32_t UBaseType_t;
+typedef uint32_t StackType_t;
+typedef uint32_t StaticTask_t;
+typedef pthread_t* TaskHandle_t;
+typedef uint32_t StaticSemaphore_t;
+typedef void* SemaphoreHandle_t;
+
+#define tskIDLE_PRIORITY 0
+
+TaskHandle_t xTaskCreateStatic(
+    TaskFunction_t pxTaskCode,
+    const char * const pcName,
+    const uint32_t ulStackDepth,
+    void * const pvParameters,
+    UBaseType_t uxPriority,
+    StackType_t * const puxStackBuffer,
+    StaticTask_t * const pxTaskBuffer
+);
+
+void vTaskDelete(TaskHandle_t xTask);
+TaskHandle_t xTaskGetCurrentTaskHandle(void);
+SemaphoreHandle_t xSemaphoreCreateMutexStatic(StaticSemaphore_t* pxMutexBuffer);
+bool task_equal(TaskHandle_t a, TaskHandle_t b);

target_lo/Makefile

@@ -25,11 +25,17 @@ Src/main.c
 
 CPP_SOURCES = ../core/app.cpp
 
-C_SOURCES += ../core/write.c
+C_SOURCES += ../core/debug.c
+C_SOURCES += ../core/furi.c
+C_SOURCES += ../core/furi_ac.c
 C_SOURCES += Src/flipper_hal.c
 C_SOURCES += Src/lo_os.c
 C_SOURCES += Src/lo_hal.c
 
+C_SOURCES += ../applications/tests/furiac_test.c
+C_SOURCES += ../applications/tests/furi_record_test.c
+C_SOURCES += ../applications/tests/test_index.c
+
 #######################################
 # binaries
 #######################################
@@ -56,10 +62,11 @@ C_DEFS =  \
 # C includes
 C_INCLUDES =  \
 -IInc \
--I../app
+-I../applications \
+-I../core
 
 # compile gcc flags
-CFLAGS = $(C_DEFS) $(C_INCLUDES) $(OPT) -Wall -fdata-sections -ffunction-sections
+CFLAGS = $(C_DEFS) $(C_INCLUDES) $(OPT) -Wall -fdata-sections -ffunction-sections -pthread
 
 ifeq ($(DEBUG), 1)
 CFLAGS += -g -gdwarf-2
@@ -78,7 +85,7 @@ CPPFLAGS = -fno-threadsafe-statics
 # libraries
 LIBS = -lc -lm
 LIBDIR = 
-LDFLAGS = $(LIBDIR) $(LIBS) -Wl,-Map=$(BUILD_DIR)/$(TARGET).map,--cref -Wl,--gc-sections
+LDFLAGS = $(LIBDIR) $(LIBS) -Wl,-Map=$(BUILD_DIR)/$(TARGET).map,--cref -Wl,--gc-sections -pthread
 
 # default action: build all
 all: $(BUILD_DIR)/$(TARGET)

target_lo/Src/lo_os.c

@@ -1,8 +1,85 @@
 #include "cmsis_os.h"
 #include <unistd.h>
 #include <stdio.h>
+#include <pthread.h>
+#include <errno.h>
+#include <signal.h>
 
 void osDelay(uint32_t ms) {
-	usleep(ms * 1000);
-	printf("[DELAY] %d ms\n", ms);
+    printf("[DELAY] %d ms\n", ms);
+    usleep(ms * 1000);
+}
+
+// temporary struct to pass function ptr and param to wrapper
+typedef struct {
+    TaskFunction_t func;
+    void * param;
+} PthreadTask;
+
+void* pthread_wrapper(void* p) {
+    pthread_setcanceltype(PTHREAD_CANCEL_ASYNCHRONOUS, 0x00);
+    pthread_setcancelstate(PTHREAD_CANCEL_ENABLE, 0x00);
+
+    PthreadTask* task = (PthreadTask*)p;
+    
+    task->func(task->param);
+
+    return NULL;
+}
+
+TaskHandle_t xTaskCreateStatic(
+    TaskFunction_t pxTaskCode,
+    const char * const pcName,
+    const uint32_t ulStackDepth,
+    void * const pvParameters,
+    UBaseType_t uxPriority,
+    StackType_t * const puxStackBuffer,
+    StaticTask_t * const pxTaskBuffer
+) {
+    TaskHandle_t thread = malloc(sizeof(TaskHandle_t));
+    PthreadTask* task = malloc(sizeof(PthreadTask));
+
+    task->func = pxTaskCode;
+    task->param = pvParameters;
+
+    pthread_create(thread, NULL, pthread_wrapper, (void*)task);
+
+    return thread;
+}
+
+void vTaskDelete(TaskHandle_t xTask) {
+
+    if(xTask == NULL) {
+        // kill itself
+        pthread_exit(NULL);
+    }
+
+    // maybe thread already join
+    if (pthread_kill(*xTask, 0) == ESRCH) return;
+
+    // send thread_child signal to stop it сигнал, который ее завершает
+    pthread_cancel(*xTask);
+
+    // wait for join and close descriptor
+    pthread_join(*xTask, 0x00);
+
+    // cleanup thread handler
+    *xTask = 0;
+}
+
+TaskHandle_t xTaskGetCurrentTaskHandle(void) {
+    TaskHandle_t thread = malloc(sizeof(TaskHandle_t));
+    *thread = pthread_self();
+    return thread;
+}
+
+bool task_equal(TaskHandle_t a, TaskHandle_t b) {
+    if(a == NULL || b == NULL) return false;
+    
+    return pthread_equal(*a, *b) != 0;
+}
+
+SemaphoreHandle_t xSemaphoreCreateMutexStatic(StaticSemaphore_t* pxMutexBuffer) {
+    // TODO add posix mutex init
+    return NULL;
 }