forex-scalping.com

Code: Select all

//+------------------------------------------------------------------+
//|                                        HolidaySpreadLogger.mq4   |
//|                    Continuous Spread Logger for Liquidity Profiling|
//+------------------------------------------------------------------+
#property copyright "Raw Spread Analytics"
#property strict
#property show_inputs

//--- input parameters
input int    LogIntervalSeconds = 60;              // Logging Interval (Seconds)
input string FileNamePrefix     = "SpreadLog_";    // File Name Prefix

void OnStart()
{
    string fileName = FileNamePrefix + Symbol() + ".csv";
    
    // Open file for shared reading and writing
    int fileHandle = FileOpen(fileName, FILE_CSV|FILE_READ|FILE_WRITE|FILE_ANSI, ",");
    
    if(fileHandle == INVALID_HANDLE)
    {
        Print("Critical Error: Failed to open file. Error code: ", GetLastError());
        return;
    }

    // Move file pointer to the end to append data
    FileSeek(fileHandle, 0, SEEK_END);
    
    // If it's a new file, write the CSV header
    if(FileSize(fileHandle) == 0)
    {
        FileWrite(fileHandle, "Timestamp", "Symbol", "Bid", "Ask", "Spread_Points");
    }

    Print("Spread logger initiated on ", Symbol(), ". Interval: ", LogIntervalSeconds, "s. Remove script from chart to terminate.");

    // Infinite loop to act as a continuous logger without requiring EA permissions
    while(!IsStopped())
    {
        double bid = MarketInfo(Symbol(), MODE_BID);
        double ask = MarketInfo(Symbol(), MODE_ASK);
        int spread = (int)MarketInfo(Symbol(), MODE_SPREAD);
        
        // Format: YYYY.MM.DD HH:MI:SS
        string timeStr = TimeToString(TimeCurrent(), TIME_DATE|TIME_MINUTES|TIME_SECONDS);

        // Write current market data
        FileWrite(fileHandle, timeStr, Symbol(), DoubleToStr(bid, Digits), DoubleToStr(ask, Digits), spread);
        
        // Flush forces the terminal to write from RAM to the physical disk immediately.
        // This ensures no data is lost if the MT4 terminal crashes or shuts down abruptly.
        FileFlush(fileHandle);

        // Sleep releases the thread. Multiply by 1000 for milliseconds.
        Sleep(LogIntervalSeconds * 1000);
    }

    // Clean up on script removal
    FileClose(fileHandle);
    Print("Spread logger terminated gracefully.");
}

Code: Select all

//+------------------------------------------------------------------+
//|                                     ProLiquidityProfiler_EA.mq4  |
//|               Tick-Level Aggregation for Liquidity Analysis      |
//+------------------------------------------------------------------+
#property copyright "Quantitative Market Analytics"
#property strict

int    fileHandle;
string fileName;
int    currentMinute;

// In-memory aggregation variables
int    tickCount;
long   cumulativeSpread;
int    maxSpread;
int    minSpread;

int OnInit()
{
    fileName = "LiquidityProfile_" + Symbol() + ".csv";
    
    // FILE_SHARE_READ allows you to open the CSV in Excel while MT4 is running
    fileHandle = FileOpen(fileName, FILE_CSV|FILE_READ|FILE_WRITE|FILE_ANSI|FILE_SHARE_READ, ",");
    
    if(fileHandle == INVALID_HANDLE)
    {
        Print("CRITICAL I/O ERROR: Cannot open file. Error: ", GetLastError());
        return(INIT_FAILED);
    }

    FileSeek(fileHandle, 0, SEEK_END);
    
    // Initialize headers if file is newly created
    if(FileSize(fileHandle) == 0)
    {
        FileWrite(fileHandle, "Timestamp", "TickVolume", "MinSpread", "AvgSpread", "MaxSpread");
    }

    currentMinute = TimeMinute(TimeCurrent());
    ResetAggregators();
    
    Print("Pro Liquidity Profiler initialized on ", Symbol());
    return(INIT_SUCCEEDED);
}

void OnDeinit(const int reason)
{
    if(fileHandle != INVALID_HANDLE)
    {
        FileClose(fileHandle);
    }
    Print("Liquidity Profiler terminated.");
}

void OnTick()
{
    int spread = (int)MarketInfo(Symbol(), MODE_SPREAD);
    int minuteNow = TimeMinute(TimeCurrent());
    
    // Boundary condition: Minute has changed, flush aggregation to disk
    if(minuteNow != currentMinute)
    {
        if(tickCount > 0)
        {
            double avgSpread = (double)cumulativeSpread / tickCount;
            // Log the time for the minute that just completed
            string timeStr = TimeToString(TimeCurrent() - 60, TIME_DATE|TIME_MINUTES);
            
            FileWrite(fileHandle, timeStr, tickCount, minSpread, DoubleToStr(avgSpread, 2), maxSpread);
            FileFlush(fileHandle); // Force write from buffer to SSD
        }
        
        currentMinute = minuteNow;
        ResetAggregators();
    }
    
    // Tick-level evaluation in memory
    tickCount++;
    cumulativeSpread += spread;
    if(spread > maxSpread) maxSpread = spread;
    if(spread < minSpread) minSpread = spread;
}

//+------------------------------------------------------------------+
//| Reset in-memory statistics for the new minute                    |
//+------------------------------------------------------------------+
void ResetAggregators()
{
    tickCount = 0;
    cumulativeSpread = 0;
    maxSpread = 0;
    minSpread = 999999;
}