forex-scalping.com

Code: Select all

using System;
using System.Diagnostics;
using System.IO;
using cAlgo.API;

namespace cAlgo.Robots
{
    [Robot(TimeZone = TimeZones.UTC, AccessRights = AccessRights.FullAccess)]
    public class ExecutionLoggerAuto : Robot
    {
        [Parameter("Min Interval (Minutes)", DefaultValue = 15)]
        public int MinInterval { get; set; }

        [Parameter("Max Interval (Minutes)", DefaultValue = 120)]
        public int MaxInterval { get; set; }

        private string _filePath;
        private Random _random = new Random();
        private DateTime _nextTradeTime;

        protected override void OnStart()
        {
            string docsPath = Environment.GetFolderPath(Environment.SpecialFolder.MyDocuments);
            _filePath = Path.Combine(docsPath, "ExecutionLog_cTrader.csv");
            
            if (!File.Exists(_filePath))
                File.AppendAllText(_filePath, "Timestamp,Symbol,Type,IntendedPrice,FillPrice,Slippage(Pips),Latency(ms)\n");

            ScheduleNextTrade();
            Timer.Start(1); // Check the clock every 1 second
        }

        protected override void OnTimer()
        {
            // Only fire if the market is open and the random time has arrived
            if (Server.Time >= _nextTradeTime && Symbol.MarketHours.IsOpened())
            {
                // Alternate between Buy and Sell to randomize the order book side
                TradeType side = _random.Next(0, 2) == 0 ? TradeType.Buy : TradeType.Sell;
                ExecuteTestTrade(side, Symbol.VolumeInUnitsMin);
                
                ScheduleNextTrade();
            }
        }

        private void ScheduleNextTrade()
        {
            int minutesToAdd = _random.Next(MinInterval, MaxInterval + 1);
            _nextTradeTime = Server.Time.AddMinutes(minutesToAdd);
            Print($"Next test trade scheduled in {minutesToAdd} minutes.");
        }

        private void ExecuteTestTrade(TradeType tradeType, double volume)
        {
            double intendedPrice = tradeType == TradeType.Buy ? Symbol.Ask : Symbol.Bid;
            
            Stopwatch sw = Stopwatch.StartNew();
            TradeResult result = ExecuteMarketOrder(tradeType, SymbolName, volume, "LatencyTest");
            sw.Stop();

            if (result.IsSuccessful)
            {
                double fillPrice = result.Position.EntryPrice;
                double slippage = tradeType == TradeType.Buy ? (fillPrice - intendedPrice) : (intendedPrice - fillPrice);
                double slippageInPips = slippage / Symbol.PipSize;

                string logLine = $"{Server.Time:yyyy-MM-dd HH:mm:ss.fff},{SymbolName},{tradeType},{intendedPrice},{fillPrice},{slippageInPips:F1},{sw.ElapsedMilliseconds}\n";
                File.AppendAllText(_filePath, logLine);

                // Close instantly to eliminate market risk
                ClosePosition(result.Position);
            }
        }
    }
}

Code: Select all

#property strict

input int MinIntervalMinutes = 15;
input int MaxIntervalMinutes = 120;
input double TestVolume = 0.01;

int file_handle;
datetime next_trade_time;

int OnInit() {
    file_handle = FileOpen("ExecutionLog_MT5.csv", FILE_CSV|FILE_READ|FILE_WRITE|FILE_ANSI, ",");
    if(file_handle != INVALID_HANDLE) {
        FileSeek(file_handle, 0, SEEK_END);
        if(FileSize(file_handle) == 0) {
            FileWrite(file_handle, "Timestamp", "Symbol", "Type", "IntendedPrice", "FillPrice", "Slippage(Points)", "Latency(ms)");
        }
    }
    
    // Seed the random number generator using system uptime
    MathSrand(GetTickCount());
    ScheduleNextTrade();
    
    return(INIT_SUCCEEDED);
}

void OnDeinit(const int reason) {
    if(file_handle != INVALID_HANDLE) FileClose(file_handle);
}

void OnTick() {
    if(TimeCurrent() >= next_trade_time) {
        // Randomize Buy (0) or Sell (1)
        ENUM_ORDER_TYPE side = (MathRand() % 2 == 0) ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
        ExecuteTestTradeAndClose(side, TestVolume);
        
        ScheduleNextTrade();
    }
}

void ScheduleNextTrade() {
    int range = MaxIntervalMinutes - MinIntervalMinutes;
    int random_mins = MinIntervalMinutes + (MathRand() % (range + 1));
    next_trade_time = TimeCurrent() + (random_mins * 60);
    Print("Next test trade scheduled in ", random_mins, " minutes.");
}

void ExecuteTestTradeAndClose(ENUM_ORDER_TYPE orderType, double volume) {
    MqlTradeRequest request={0};
    MqlTradeResult result={0};
    
    request.action = TRADE_ACTION_DEAL;
    request.symbol = _Symbol;
    request.volume = volume;
    request.type = orderType;
    request.price = (orderType == ORDER_TYPE_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_ASK) : SymbolInfoDouble(_Symbol, SYMBOL_BID);
    request.deviation = 50; 
    
    ulong start_time = GetMicrosecondCount();
    bool success = OrderSend(request, result);
    ulong latency_us = GetMicrosecondCount() - start_time;
    
    if(success && result.retcode == TRADE_RETCODE_DONE) {
        // 1. Log the entry execution
        double slippage = (orderType == ORDER_TYPE_BUY) ? (result.price - request.price) : (request.price - result.price);
        double slippage_points = slippage / _Point;
        double latency_ms = latency_us / 1000.0;
        
        string timestamp = TimeToString(TimeCurrent(), TIME_DATE|TIME_SECONDS);
        FileWrite(file_handle, timestamp, _Symbol, EnumToString(orderType), request.price, result.price, slippage_points, latency_ms);
        
        // 2. Immediately send an opposite order to close the position
        MqlTradeRequest close_req={0};
        MqlTradeResult close_res={0};
        
        close_req.action = TRADE_ACTION_DEAL;
        close_req.symbol = _Symbol;
        close_req.volume = volume;
        close_req.type = (orderType == ORDER_TYPE_BUY) ? ORDER_TYPE_SELL : ORDER_TYPE_BUY;
        close_req.price = (close_req.type == ORDER_TYPE_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_ASK) : SymbolInfoDouble(_Symbol, SYMBOL_BID);
        close_req.position = result.deal; // Target the specific deal to close
        close_req.deviation = 50;
        
        OrderSend(close_req, close_res);
    }
}