init

lib/log/logger.cpp

@@ -0,0 +1,149 @@
+#include "logger.hpp"
+#include <Arduino.h>
+#include <string.h>
+#include <stdarg.h> // For va_list, vsnprintf
+#include <sys/time.h>
+
+Logger::Logger() 
+    : logCount(0), logIndex(0), currentLogLevel(LOG_INFO), 
+      logCallback(nullptr), logQueue(nullptr), logTaskHandle(nullptr) {}
+
+Logger::~Logger() {
+    // Clean up FreeRTOS objects
+    if (logTaskHandle) vTaskDelete(logTaskHandle);
+    if (logQueue) vQueueDelete(logQueue);
+}
+
+void Logger::begin(UBaseType_t taskPriority, uint32_t taskStackSize) {
+    // Create a queue that can hold up to 10 LogEntry items.
+    logQueue = xQueueCreate(10, sizeof(LogEntry));
+
+    if (logQueue == nullptr) {
+        Serial.println("FATAL: Failed to create logger queue!");
+        return;
+    }
+
+    // Create the background task. It passes 'this' so the static function
+    // can access the instance's members.
+    xTaskCreate(
+        logProcessingTask,
+        "LoggerTask",
+        taskStackSize,
+        this, // Pass the current object instance to the task
+        taskPriority,
+        &logTaskHandle
+    );
+
+    if (logTaskHandle == nullptr) {
+        Serial.println("FATAL: Failed to create logger task!");
+    }
+}
+
+void Logger::addLog(LogLevel level, const char* format, va_list args) {
+    if (level < currentLogLevel) {
+        return;
+    }
+
+    LogEntry entry;
+    entry.level = level;
+
+    // Verwende Systemzeit statt millis()
+    struct timeval tv;
+    if (gettimeofday(&tv, nullptr) != 0) {
+        LOG_ERROR("Failed to get system time for log entry");
+        entry.timestamp = 0; // Fallback-Wert
+    } else {
+        entry.timestamp = tv.tv_sec; // Unix-Timestamp in Sekunden
+    }
+
+    vsnprintf(entry.message, sizeof(entry.message), format, args);
+    
+    // Add to internal circular buffer for history
+    logs[logIndex] = entry;
+    logIndex = (logIndex + 1) % MAX_LOGS;
+    if (logCount < MAX_LOGS) {
+        logCount++;
+    }
+
+    if (logQueue != nullptr) {
+        xQueueSend(logQueue, &entry, pdMS_TO_TICKS(10));
+    }
+}
+
+// This is the function that runs in its own task.
+void Logger::logProcessingTask(void* instance) {
+    // The instance pointer is the 'this' we passed in xTaskCreate.
+    Logger* loggerInstance = static_cast<Logger*>(instance);
+    LogEntry entryToProcess;
+
+    while (true) {
+        if (xQueueReceive(loggerInstance->logQueue, &entryToProcess, portMAX_DELAY) == pdPASS) {
+            if (loggerInstance->logCallback) {
+                loggerInstance->logCallback(entryToProcess);
+            }
+        }
+    }
+}
+
+void Logger::setLogLevel(LogLevel level) {
+    currentLogLevel = level;
+}
+
+LogLevel Logger::getLogLevel() const {
+    return currentLogLevel;
+}
+
+void Logger::setLogCallback(std::function<void(const LogEntry& entry)> callback) {
+    logCallback = callback;
+}
+
+// --- NEW: Public methods now handle the variable arguments ---
+void Logger::debug(const char* format, ...) {
+    va_list args;
+    va_start(args, format);
+    addLog(LOG_DEBUG, format, args);
+    va_end(args);
+}
+
+void Logger::info(const char* format, ...) {
+    va_list args;
+    va_start(args, format);
+    addLog(LOG_INFO, format, args);
+    va_end(args);
+}
+
+void Logger::warn(const char* format, ...) {
+    va_list args;
+    va_start(args, format);
+    addLog(LOG_WARN, format, args);
+    va_end(args);
+}
+
+void Logger::error(const char* format, ...) {
+    va_list args;
+    va_start(args, format);
+    addLog(LOG_ERROR, format, args);
+    va_end(args);
+}
+
+const LogEntry* Logger::getLogs(int& count) const {
+    count = logCount;
+    return logs;
+}
+
+void Logger::clear() {
+    logCount = 0;
+    logIndex = 0;
+}
+
+const char* Logger::levelToString(LogLevel level) const {
+    switch (level) {
+        case LOG_DEBUG: return "D";
+        case LOG_INFO:  return "I";
+        case LOG_WARN:  return "W";
+        case LOG_ERROR: return "E";
+        default:        return "U";
+    }
+}
+
+Logger logger;