logger.cpp

#include "logger.h"

SerialLogger::SerialLogger(const char *control_sequence)
    :_control_sequence(control_sequence), _control_sequence_len(strlen(control_sequence))
{
}

bool SerialLogger::begin(void *args) {
    return Serial;
}

void SerialLogger::log_raw(uint8_t *data, size_t length) {
    Serial.write(data, length);
    Serial.write(_control_sequence, _control_sequence_len); 
}

void SerialLogger::sync(size_t packet_size) { 
    for (int i = 0; i < packet_size; ++i) {
        Serial.print(0);
    }
    Serial.write(_control_sequence, _control_sequence_len); 
}

void SerialLogger::log_pretty(TraceEntry_t &data) {
    TraceEntry_t *entry = (TraceEntry_t *)&data;

    Serial.printf("[%" PRIu32 "] Core:%ld ID:%" PRIu32 "FN: %ld" " | ", 
        entry->timestamp, 
        (long)entry->core_id, 
        entry->trace_id,
        entry->function_call_id
    );

    switch (entry->trace_type) {
        case ENTER: {
            const TraceFunctionEntry_t& fn = entry->function_entry;
            Serial.printf("ENTER: %s(", fn.func_name);

            // Loop through arguments
            for (int i = 0; i < fn.arg_count; i++) {
                // Note: We are printing raw hex because we don't know 
                // how to decode 'val_types' yet.
                Serial.printf("0x%08" PRIx32, fn.func_arguments[i]);
                
                if (i < fn.arg_count - 1) {
                    Serial.printf(", ");
                }
            }
            Serial.printf(")\n");
            break;
        }

        case EXIT: {
            const TraceFunctionEntry_t& fn = entry->function_entry;
            Serial.printf("EXIT : %s | Return: 0x%08" PRIx32, 
                   fn.func_name, 
                   fn.return_val);

            #ifdef TRACER_TRACE_STACK
            Serial.printf(" | Stack Left: %ld bytes", (long)fn.stack_space_left);
            #endif
            
            Serial.printf("\n");
            break;
        }

        case PANIC: {
            const TracePanicEntry_t& panic = entry->panic_entry;
            Serial.printf("PANIC: PC:0x%08" PRIx32 " Reason: %s\n", 
                   panic.faulting_pc, 
                   panic.exception_reason);
            break;
        }

        default:
            Serial.printf("UNKNOWN EVENT TYPE\n");
            break;
    }
}

void SerialLogger::flush() { Serial.flush(); }

UDPLogger::UDPLogger(const String& ssid, const String& password, uint16_t port, const char* server_addr)
    :_ssid(ssid), _password(password), _port(port), _server_addr(IPAddress(server_addr))
{}

bool UDPLogger::begin(void* args) {
    WiFi.begin(_ssid, _password);

    while (WiFi.status() != WL_CONNECTED) {
        delay(500);
        Serial.println(".");
    }

    Serial.println("wifi connected");

    if (_udp.begin(_port)) {
        Serial.print("UDP client initialized on port ");
        Serial.println(_port);
    } else {
        return false;
    }

    return true;
}

void UDPLogger::sync(size_t packet_size) {
    return;
}

void UDPLogger::log_raw(uint8_t *data, size_t length) {
    _check_conn_and_reconnect();

    _udp.beginPacket(_server_addr, _port);
    _udp.write(data, length);
    _udp.endPacket();
}

void UDPLogger::log_pretty(TraceEntry_t &data) {
    // there is no way to print pretty over the network, so just send the same stuff
    log_raw(reinterpret_cast<uint8_t *>(&data), sizeof(data));
}

void UDPLogger::flush() { return; }

void UDPLogger::_check_conn_and_reconnect() {
    bool had_to_reconnect = false;
    while (WiFi.status() != WL_CONNECTED) {
        had_to_reconnect = true;

        WiFi.disconnect();
        delay(100);
        WiFi.reconnect();
        delay(100);
    }

    if (had_to_reconnect) {
        while (!_udp.begin(_port)) {
            delay(100);
            Serial.println(",");
        }
    }
}