Adicionar primeiro

components/logger/src/logger.c

@@ -0,0 +1,71 @@
+#include <stdio.h>
+#include <memory.h>
+#include <sys/param.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/semphr.h"
+
+#include "logger.h"
+#include "output_buffer.h"
+
+#define LOG_BUFFER_SIZE     6096 //4096
+#define MAX_LOG_SIZE        512
+
+
+static SemaphoreHandle_t mutex;
+
+static output_buffer_t * buffer = NULL;
+
+EventGroupHandle_t logger_event_group = NULL;
+
+void logger_init(void)
+{
+    mutex = xSemaphoreCreateMutex();
+    logger_event_group = xEventGroupCreate();
+
+    buffer = output_buffer_create(LOG_BUFFER_SIZE);
+}
+
+uint16_t logger_count(void)
+{
+    return buffer->count;
+}
+
+void logger_print(const char* str)
+{
+    xSemaphoreTake(mutex, portMAX_DELAY);
+
+    output_buffer_append_str(buffer, str);
+    xEventGroupSetBits(logger_event_group, 0xFF);
+  
+    xSemaphoreGive(mutex);
+}
+
+int logger_vprintf(const char* str, va_list l)
+{
+#ifdef CONFIG_ESP_CONSOLE_UART
+    vprintf(str, l);
+#endif
+
+    xSemaphoreTake(mutex, portMAX_DELAY);
+
+    static char log[MAX_LOG_SIZE];
+    int len = vsnprintf(log, MAX_LOG_SIZE, str, l);
+
+    output_buffer_append_buf(buffer, log, len);
+    xEventGroupSetBits(logger_event_group, 0xFF);
+
+    xSemaphoreGive(mutex);
+
+    return len;
+}
+
+bool logger_read(uint16_t* index, char** str, uint16_t* len)
+{
+    xSemaphoreTake(mutex, portMAX_DELAY);
+
+    bool has_next = output_buffer_read(buffer, index, str, len);
+
+    xSemaphoreGive(mutex);
+
+    return has_next;
+}

components/logger/src/output_buffer.c

@@ -0,0 +1,86 @@
+#include <memory.h>
+
+#include "output_buffer.h"
+
+
+output_buffer_t* output_buffer_create(uint16_t size)
+{
+    output_buffer_t* buffer = (output_buffer_t*)malloc(sizeof(output_buffer_t));
+
+    buffer->size = size;
+    buffer->count = 0;
+    buffer->data = (uint8_t*)malloc(sizeof(uint8_t) * size);
+    buffer->append = buffer->data;
+
+    return buffer;
+}
+
+void output_buffer_delete(output_buffer_t* buffer)
+{
+    free((void*)buffer->data);
+    free((void*)buffer);
+}
+
+void output_buffer_append_buf(output_buffer_t* buffer, const char* str, uint16_t len)
+{
+    if (((buffer->append - buffer->data) + sizeof(uint16_t) + len) >= buffer->size) {
+        //rotate buffer
+        uint8_t* pos = buffer->data;
+        uint16_t rotate_count = 0;
+        while ((pos - buffer->data) < buffer->size / 2) {
+            //seek first half
+            uint16_t entry_len;
+            memcpy((void*)&entry_len, (void*)pos, sizeof(uint16_t));
+            pos += entry_len + sizeof(uint16_t);
+            rotate_count++;
+        }
+
+        memmove((void*)buffer->data, (void*)pos, buffer->size - (pos - buffer->data));
+        buffer->count -= rotate_count;
+        buffer->append -= (pos - buffer->data);
+    }
+
+    memcpy((void*)buffer->append, (void*)&len, sizeof(uint16_t));
+    buffer->append += sizeof(uint16_t);
+
+    memcpy((void*)buffer->append, (void*)str, len);
+    buffer->append += len;
+
+    buffer->count++;
+}
+
+void output_buffer_append_str(output_buffer_t* buffer, const char* str)
+{
+    output_buffer_append_buf(buffer, str, strlen(str));
+}
+
+bool output_buffer_read(output_buffer_t* buffer, uint16_t* index, char** str, uint16_t* len)
+{
+    if (*index > buffer->count) {
+        *index = buffer->count;
+    }
+
+    bool has_next = false;
+
+    if (*index < buffer->count) {
+        uint8_t* pos = buffer->data;
+        uint16_t current = 0;
+
+        while (current != *index) {
+            uint16_t entry_len;
+            memcpy((void*)&entry_len, (void*)pos, sizeof(uint16_t));
+            pos += entry_len + sizeof(uint16_t);
+            current++;
+        }
+
+        memcpy((void*)len, (void*)pos, sizeof(uint16_t));
+        pos += sizeof(uint16_t);
+        *str = (char*)pos;
+
+        (*index)++;
+
+        has_next = true;
+    }
+
+    return has_next;
+}