Adicionar primeiro

components/logger/CMakeLists.txt

@@ -0,0 +1,7 @@
+set(srcs
+    "src/logger.c"
+    "src/output_buffer.c"
+    )
+
+idf_component_register(SRCS "${srcs}"
+                    INCLUDE_DIRS "include")

components/logger/include/logger.h

@@ -0,0 +1,58 @@
+#ifndef LOGGER_H_
+#define LOGGER_H_
+
+#include <stdint.h>
+#include <stdbool.h>
+#include "freertos/FreeRTOS.h"
+#include "freertos/event_groups.h"
+
+#define LOGGER_SERIAL_BIT       BIT0
+
+/**
+ * @brief Logger event group LOGGER_SERIAL_BIT
+ * 
+ */
+extern EventGroupHandle_t logger_event_group;
+
+/**
+ * @brief Initialize logger
+ * 
+ */
+void logger_init(void);
+
+/**
+ * @brief Print
+ * 
+ * @param str 
+ */
+void logger_print(const char* str);
+
+/**
+ * @brief Print va
+ * 
+ * @param str 
+ * @param l 
+ * @return int 
+ */
+int logger_vprintf(const char* str, va_list l);
+
+/**
+ * @brief Get entries count
+ * 
+ * @return uint16_t 
+ */
+uint16_t logger_count(void);
+
+/**
+ * @brief Read line from index, set index for reading next entry
+ * 
+ * @param index 
+ * @param str 
+ * @param v 
+ * @return true When has next entry
+ * @return false When no entry left
+ */
+bool logger_read(uint16_t *index, char **str, uint16_t* len);
+
+
+#endif /* LOGGER_H_ */

components/logger/include/output_buffer.h

@@ -0,0 +1,24 @@
+#ifndef OUTPUT_BUFFER_H_
+#define OUTPUT_BUFFER_H_
+
+#include <stdint.h>
+#include <stdbool.h>
+
+typedef struct {
+    uint16_t size;
+    uint16_t count;    
+    uint8_t* data;    
+    uint8_t* append;
+} output_buffer_t;
+
+output_buffer_t* output_buffer_create(uint16_t size);
+
+void output_buffer_delete(output_buffer_t* buffer);
+
+void output_buffer_append_buf(output_buffer_t* buffer, const char* buf, uint16_t len);
+
+void output_buffer_append_str(output_buffer_t* buffer, const char* str);
+
+bool output_buffer_read(output_buffer_t* buffer, uint16_t *index, char **str, uint16_t* len);
+
+#endif /* OUTPUT_BUFFER_H_ */

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;
+}