FreelanceSections

Need errors to be fixed on my mql5 language mt5 code

MQL5 Indicateurs Experts Forex Trading robot/indicator debugging

Tâche terminée

Temps d'exécution 4 heures
Commentaires de l'employé
Nice working with you, No stress :)
Commentaires du client
very fast and good to work with

Spécifications

heres the code (#include <Trade\Trade.mqh>  // Include the CTrade class
CTrade trade;  // Declare an instance of CTrade

// Symbols to trade
string SYMBOLS[] = {"XAUUSDm", "US30m", "GBPUSDm", "USTECm", "EURUSDm"};

// Parameters for 15-minute scalping and integrated strategy
double MIN_LOT_SIZE = 0.01;  // Minimum lot size for most brokers
double TRAILING_STOP_LOSS = 5;      // Trailing stop loss (points)
double RISK_PERCENTAGE = 0.5;        // Risk per trade in percentage (smaller for scalping)
int MA_PERIOD_M5 = 10;              // Moving average period for M15
int MA_PERIOD_D1 = 100;              // Moving average period for D1 (longer-term trend)
int ATR_PERIOD = 5;                  // ATR period for volatility filter
double MIN_ATR_THRESHOLD = 0.0002;   // Minimum ATR value for high volatility (tighter for scalping)
int trade_count = 0;                 // Counter to track the number of trades
datetime last_trade_time = 0;        // Track last trade time for session filtering

// Variables to store the last detected pattern and trend
struct TradeSetup {
    string trend;
    string pattern;
};
TradeSetup last_setup[ArraySize(SYMBOLS)]; // Array to store last setup for each symbol


// Function declarations
double calculate_lot_size(double risk_percentage, double stop_loss_distance);
void log_trade(string symbol, double entry_price, double exit_price, string type);
double adjust_stop_loss(double atr_value);
int execute_trade(string symbol, string type, double lot_size);

// Function to calculate lot size based on risk percentage and stop loss distance
double calculate_lot_size(double risk_percentage, double stop_loss_distance) {
    double account_balance = AccountInfoDouble(ACCOUNT_BALANCE);
    double risk_amount = account_balance * (3 / 100);
    double lot_size = risk_amount / stop_loss_distance;
    return NormalizeDouble(lot_size, 2); // Adjust to the broker's lot size precision
}

// Function to adjust stop loss based on ATR value
double adjust_stop_loss(double atr_value) {
    return atr_value * 1.5; // Adjust this multiplier as needed
}

// Function to log trade details
void log_trade( double entry_price, double exit_price, string type) {
    Print("Trade executed: ", symbol, " Entry: ", entry_price, " Exit: ", exit_price, " Type: ", type);
}

void IntegratedStrategy(double price, double support, double resistance, 
                        double demandZone, double supplyZone,
                        bool isBullishPattern, bool isBearishPattern,
                        bool isBreakout, bool isBreakdown,
                        bool isFalseBreakout, bool isReversal,
                        bool isUptrend, bool isDowntrend,
                        double volume, double rsi)

 //--- Pure Price Action: Reversal at Key Levels
        if (isReversal) {
            // Buying Reversal at Support or Demand Zone
            if (SymbolInfoDouble(symbol, SYMBOL_BID) <= support || SymbolInfoDouble(symbol, SYMBOL_BID) <= demandZone) {
                // Confirmations: Bullish candlestick pattern, volume increase, RSI not overbought
                if (bullishSignal == "bullish_engulfing" && volume > 0 && rsi < 70) {
                    request.action = TRADE_ACTION_DEAL;
                    request.symbol = symbol;
                    request.volume = LOT_SIZE; // You can adjust lot size here
                    request.type = ORDER_TYPE_BUY;
                    request.price = SymbolInfoDouble(symbol, SYMBOL_ASK);
                    request.sl = 3; // Define stop loss (modify as needed)
                    request.tp = 15; // Define take profit (modify as needed)
                    request.deviation = 3;
                    request.comment = "Buy Reversal at Support/Demand";
                    if (!execute_trade(request, result)) {
                    Print("Failed to place Buy order at Supoort/Demand.");
                }
            }

            // Selling Reversal at Resistance or Supply Zone
            if (SymbolInfoDouble(symbol, SYMBOL_BID) >= resistance || SymbolInfoDouble(symbol, SYMBOL_BID) >= supplyZone) {
                // Confirmations: Bearish candlestick pattern, volume increase, RSI overbought
                if (bearishSignal == "bearish_engulfing" && volume > 0 && rsi > 70) {
                    request.action = TRADE_ACTION_DEAL;
                    request.symbol = symbol;
                    request.volume = LOT_SIZE; // You can adjust lot size here
                    request.type = ORDER_TYPE_SELL;
                    request.price = SymbolInfoDouble(symbol, SYMBOL_BID);
                    request.sl = 3; // Define stop loss (modify as needed)
                    request.tp = 15; // Define take profit (modify as needed)
                    request.deviation = 3;
                    request.comment = "Sell Reversal at Resistance/Supply";
                    if (!execute_trade(request, result)) {
                    Print("Failed to place Sell order at Resistance/Supply.");
                }
            }
        }

        //--- Price Action: Breakout or Breakdown
        if (isBreakout && SymbolInfoDouble(symbol, SYMBOL_BID) > resistance) {
            // Buy on confirmed breakout with strong volume
            if (volume > 0 && rsi < 70) {
                request.action = TRADE_ACTION_DEAL;
                request.symbol = symbol;
                request.volume = LOT_SIZE; // You can adjust lot size here
                request.type = ORDER_TYPE_BUY;
                request.price = SymbolInfoDouble(symbol, SYMBOL_ASK);
                request.deviation = 3;
                request.comment = "Buy Breakout";
                if (!execute_trade(request, result)) {
                    Print("Failed to place Buy order at Breakout.");
            }
        }

        if (isBreakdown && SymbolInfoDouble(symbol, SYMBOL_BID) < support) {
            // Sell on confirmed breakdown with strong volume
            if (volume > 0 && rsi > 70) {
                request.action = TRADE_ACTION_DEAL;
                request.symbol = symbol;
                request.volume = LOT_SIZE; // You can adjust lot size here
                request.type = ORDER_TYPE_SELL;
                request.price = SymbolInfoDouble(symbol, SYMBOL_BID);
                request.deviation = 3;
                request.comment = "Sell Breakdown";
                if (!execute_trade(request, result)) {
                    Print("Failed to place Sell order at Breakdown.");
            }
        }

        //--- False Breakout: Sell After False Breakout at Resistance or Buy After False Breakout at Support
        if (isFalseBreakout) {
            if (SymbolInfoDouble(symbol, SYMBOL_BID) > resistance && bearishSignal == "bearish_engulfing" && volume > 0 && rsi > 70) {
                request.action = TRADE_ACTION_DEAL;
                request.symbol = symbol;
                request.volume = LOT_SIZE; // You can adjust lot size here
                request.type = ORDER_TYPE_SELL;
                request.price = SymbolInfoDouble(symbol, SYMBOL_BID);
                request.deviation = 3;
                request.comment = "Sell False Breakout at Resistance";
                if (!execute_trade(request, result)) {
                    Print("Failed to place Sell order at Resistance.");
            }

            if (SymbolInfoDouble(symbol, SYMBOL_BID) < support && bullishSignal == "bullish_engulfing" && volume > 0 && rsi < 30) {
                request.action = TRADE_ACTION_DEAL;
                request.symbol = symbol;
                request.volume = LOT_SIZE; // You can adjust lot size here
                request.type = ORDER_TYPE_BUY;
                request.price = SymbolInfoDouble(symbol, SYMBOL_ASK);
                request.deviation = 3;
                request.comment = "Buy False Breakout at Support";
                if (!execute_trade(request, result)) {
                    Print("Failed to place Buy order at Support.");
            }
        }

        //--- Trend Continuation: Buy in Uptrend at Demand Zone or Support, Sell in Downtrend at Supply Zone or Resistance
        if (isUptrend) {
            if (SymbolInfoDouble(symbol, SYMBOL_BID) <= demandZone || SymbolInfoDouble(symbol, SYMBOL_BID) <= support) {
                if (bullishSignal == "bullish_engulfing" && volume > 0 && rsi < 70) {
                    request.action = TRADE_ACTION_DEAL;
                    request.symbol = symbol;
                    request.volume = LOT_SIZE; // You can adjust lot size here
                    request.type = ORDER_TYPE_BUY;
                    request.price = SymbolInfoDouble(symbol, SYMBOL_ASK);
                    request.deviation = 3;
                    request.comment = "Buy in Uptrend at Demand/Support";
                    if (!execute_trade(request, result)) {
                    Print("Failed to place Buy order at Demand/Support.");
                }
            }
        }

        if (isDowntrend) {
            if (SymbolInfoDouble(symbol, SYMBOL_BID) >= supplyZone || SymbolInfoDouble(symbol, SYMBOL_BID) >= resistance) {
                if (bearishSignal == "bearish_engulfing" && volume > 0 && rsi > 70) {
                    request.action = TRADE_ACTION_DEAL;
                    request.symbol = symbol;
                    request.volume = LOT_SIZE; // You can adjust lot size here
                    request.type = ORDER_TYPE_SELL;
                    request.price = SymbolInfoDouble(symbol, SYMBOL_BID);
                    request.deviation = 3;
                    request.comment = "Sell in Downtrend at Supply/Resistance";
                    if (!execute_trade(request, result)) {
                    Print("Failed to place Sell order at Supply/Resistance.");
                }
            }
        }
    }
}

//--- Function to execute trade with error checking
bool execute_trade(MqlTradeRequest &request, MqlTradeResult &result) {
    if (!OrderSend(request, result)) {
        Print("OrderSend failed with error ", GetLastError());
        return false;
    }
    if (result.retcode != TRADE_RETCODE_DONE) {
        Print("OrderSend failed, return code: ", result.retcode);
        return false;
    }
    Print("Order placed successfully with ticket ", result.order);
    return true;
}

//--- Event handler
void OnTick() {
    strategy_execution(); // Execute strategy on every tick
}
 
// Trailing stop-loss function
void apply_trailing_stop(int ticket, double trail_distance) {
    double current_price = SymbolInfoDouble(Symbol(), SYMBOL_BID);
    double stop_loss = PositionGetDouble(POSITION_SL);

    if (PositionSelectByTicket(ticket) && current_price - trail_distance > stop_loss) {
        MqlTradeRequest request;
        MqlTradeResult result;
        ZeroMemory(request);
        request.action = TRADE_ACTION_SLTP;
        request.position = ticket;
        request.sl = current_price - trail_distance;

        if (!OrderSend(request, result)) {
            Print("Trailing stop modification failed with error ", GetLastError());
        } else if (result.retcode != TRADE_RETCODE_DONE) {
            Print("Trailing stop modification failed, return code: ", result.retcode);
        } else {
            Print("Trailing stop updated successfully for ticket ", ticket);
        }
    }
}

 
// Moving average calculation for trend detection
double calculate_moving_average(string symbol, int period, int timeframe)
{
   double ma[];
   if (CopyBuffer(iMA(symbol, PERIOD_M15, period, 0, MODE_SMA, PRICE_CLOSE), 0, 0, 1, ma) > 0)
      return ma[0];
   return 0;
}

// ATR calculation for volatility filter
double calculate_atr(string symbol, int timeframe, int period)
{
   double atr[];
   if (CopyBuffer(iATR(symbol, PERIOD_M15, period), 0, 0, 1, atr) > 0)
      return atr[0];
   return 0;
}

// Detect trend based on 15-minute and daily charts
string detect_trend(string symbol)
{
   // Calculate moving averages
   double ma_m15 = calculate_moving_average(symbol, MA_PERIOD_M15, PERIOD_M15);
   double ma_d1 = calculate_moving_average(symbol, MA_PERIOD_D1, PERIOD_D1);

   // Retrieve the current price
   double price = iClose(symbol, PERIOD_M15, 0);  // Using M15 period

   // Determine trend based on the price and moving averages
   if (price > ma_m15 && price > ma_d1)
      return "uptrend";
   else if (price < ma_m15 && price < ma_d1)
      return "downtrend";

   return "";  // No clear trend
}


        // Calculate ATR and stop loss distance
        double atr_value = calculate_atr(symbol, PERIOD_M15, atr_period);
        double stop_loss_distance = adjust_stop_loss(atr_value);
        double lot_size = calculate_lot_size(risk_percentage, stop_loss_distance);


// ATR Volatility filter for M15
bool is_volatile(string symbol)
{
   double atr_value = calculate_atr(symbol, PERIOD_M15, ATR_PERIOD);
   return (atr_value >= MIN_ATR_THRESHOLD);
}

// Candlestick pattern detection (e.g., engulfing pattern)
string detect_bullish_engulfing(double &open[], double &close[])
{
   if (close[1] < open[1] && close[0] > open[0] && close[0] > open[1] && open[0] < close[1])
      return "bullish_engulfing";
   return "";
}

string detect_bearish_engulfing(double &open[], double &close[])
{
   if (close[1] > open[1] && close[0] < open[0] && close[0] < open[1] && open[0] > close[1])
      return "bearish_engulfing";
   return "";
}

// Fetch data function
bool get_data(string symbol, int timeframe, int bars, double &high[], double &low[], double &close[], double &open[])
{
   MqlRates rates[];  // Declare an array of MqlRates structures

   // Use CopyRates to fetch the data
   int copied = CopyRates(symbol, PERIOD_M15, 0, bars, rates);

   // Check if rates were successfully copied
   if (copied <= 0)
   {
      Print("Failed to copy rates for ", symbol, " on timeframe ", timeframe);
      return false;
   }

   // Resize the arrays based on the number of bars copied
   ArrayResize(high, copied);
   ArrayResize(low, copied);
   ArrayResize(close, copied);
   ArrayResize(open, copied);

   // Ensure the array is accessed from newest to oldest
   ArraySetAsSeries(rates, true);

   // Copy data into the respective arrays
   for (int i = 0; i < copied; i++)
   {
      high[i] = rates[i].high;
      low[i] = rates[i].low;
      close[i] = rates[i].close;
      open[i] = rates[i].open;
   }

   // Return true if data was successfully copied
   return true;
}

int execute_trade(string symbol, string type, double lot_size) {
    MqlTradeRequest request;
    MqlTradeResult result;
    ZeroMemory(request);
    
    request.action = TRADE_ACTION_DEAL;
    request.symbol = symbol;
    request.volume = lot_size;
    request.type = (type == "buy") ? ORDER_TYPE_BUY : ORDER_TYPE_SELL;
    request.price = (type == "buy") ? SymbolInfoDouble(symbol, SYMBOL_ASK) : SymbolInfoDouble(symbol, SYMBOL_BID);
    request.deviation = 3; // Adjust deviation as needed
    request.comment = type + " trade executed";

    if(OrderSend(request, result)) {
        trade_count++; // Increment trade count on successful trade
        return result.handle; // Return the ticket number
    } else {
        Print("Error executing trade: ", GetLastError());
        return -1; // Return -1 on failure
    }
}

// Function to check if the current time is within trading session hours
bool is_trading_session() {
    datetime current_time = TimeCurrent();
    int hour = TimeHour(current_time);
    // Example: London session (9:00 - 17:00) and New York session (15:00 - 22:00)
    return (hour >= 9 && hour < 17) || (hour >= 15 && hour < 22);
}


// Main trading loop
void OnTick() {
    if(trade_count >= 4)  // Stop execution once trade limit is reached
    {
        Print("Trading halted after opening 4 trades.");
        return;
    }

    for(int i = 0; i < ArraySize(SYMBOLS); i++) {
        string symbol = SYMBOLS[i];
        double high[1000], low[1000], close[1000], open[1000];
        int bars = 1000;  // Number of bars to retrieve

        // Retrieve data, handling the case where it fails
        if (!get_data(symbol, PERIOD_M15, bars, high, low, close, open)) {
            Print("Failed to get data for ", symbol);
            continue;  // Skip to the next symbol if data retrieval fails
        }

        
        // Perform trend detection and get candlestick patterns
        string trend = detect_trend(symbol);
        string bullishSignal = detect_bullish_engulfing(open, close);
        string bearishSignal = detect_bearish_engulfing(open, close);

        // Check if there is volatility and if we're within the trading session
        if (!is_volatile(symbol) || !is_trading_session()) {
            Print("Skipping ", symbol, " due to low volatility or out of trading session.");
            continue;
        }

        // Check if the current setup matches the last one
        if (trend == "uptrend" && bullishSignal == "bullish_engulfing") {
            // If the setup is the same as the last one, skip the trade
            if (last_setup[i].trend == trend && last_setup[i].pattern == bullishSignal) {
                Print("Skipping trade for ", symbol, " as the setup is the same as the last trade.");
                continue;
            }

            // Execute a buy trade
            int ticket = execute_trade(symbol, "buy", MIN_LOT_SIZE);
            log_trade(symbol, SymbolInfoDouble(symbol, SYMBOL_ASK), "BUY");
            apply_trailing_stop(ticket, TRAILING_STOP_LOSS);

            // Update last setup
            last_setup[i].trend = trend;
            last_setup[i].pattern = bullishSignal;
        }
        
        else if (trend == "downtrend" && bearishSignal == "bearish_engulfing") {
            // If the setup is the same as the last one, skip the trade
            if (last_setup[i].trend == trend && last_setup[i].pattern == bearishSignal) {
                Print("Skipping trade for ", symbol, " as the setup is the same as the last trade.");
                continue;
            }

            // Execute a sell trade
            int ticket = execute_trade(symbol, "sell", MIN_LOT_SIZE);
            log_trade(symbol, SymbolInfoDouble(symbol, SYMBOL_BID), "SELL");
            apply_trailing_stop(ticket, TRAILING_STOP_LOSS);

            // Update last setup
            last_setup[i].trend = trend;
            last_setup[i].pattern = bearishSignal;
        }
    }
)

Répondu

1
Développeur 1
Évaluation
(45)
Projets
53
57%
Arbitrage
2
100% / 0%
En retard
1
2%
Gratuit
Publié : 5 codes
2
Développeur 2
Évaluation
(5)
Projets
5
0%
Arbitrage
5
0% / 40%
En retard
0
Gratuit
3
Développeur 3
Évaluation
(51)
Projets
71
37%
Arbitrage
4
25% / 75%
En retard
1
1%
Gratuit
Publié : 1 code
4
Développeur 4
Évaluation
(15)
Projets
20
35%
Arbitrage
3
0% / 100%
En retard
0
Gratuit
Publié : 1 code
5
Développeur 5
Évaluation
Projets
4
0%
Arbitrage
2
0% / 100%
En retard
2
50%
Gratuit
6
Développeur 6
Évaluation
(634)
Projets
741
34%
Arbitrage
49
53% / 39%
En retard
14
2%
Chargé
7
Développeur 7
Évaluation
(7)
Projets
8
0%
Arbitrage
4
0% / 100%
En retard
3
38%
Gratuit
8
Développeur 8
Évaluation
Projets
0
0%
Arbitrage
3
0% / 100%
En retard
0
Travail
9
Développeur 9
Évaluation
(14)
Projets
15
20%
Arbitrage
1
100% / 0%
En retard
0
Gratuit
10
Développeur 10
Évaluation
(69)
Projets
146
34%
Arbitrage
13
8% / 62%
En retard
26
18%
Gratuit
Publié : 6 codes
Commandes similaires
Fix and Optimize Forex Expert Advisor for USDJPY and GBPUSD 30 - 120 USD
Requirements Specification: Debug & Error Fixing: Review the entire source code of the MQL expert advisor. Identify and fix all logical errors, bugs, and performance issues that cause trades to close prematurely or yield extremely low profits. Strategy Restructuring & Optimization: Fully analyze and optimize the current entry and exit strategy for USDJPY and GBPUSD. Modify, upgrade, or completely rewrite the entry
Independent MQL5 Code Audit for an Existing MT5 EA 100 - 200 USD
I am looking for an MQL5 developer to independently review an existing EA’s execution and position management logic. The review should focus on duplicate orders, trade isolation by symbol and magic number, broker price and volume constraints, error handling, and recovery after a terminal restart. This order is for an audit report. Please do not modify the source or change the trading strategy. For each finding
Integrate an Existing MT5 Trading Robot with Broker FIX API 50 - 150 USD
I have an existing compiled MetaTrader 5 Expert Advisor (EX5) designed for automated XAUUSD scalping. I want an experienced developer to assess and implement a solution to execute the EA’s original trading strategy through my broker’s FIX API. Requirements: Confirm the technical feasibility of connecting an existing MT5 EA to a broker FIX API. Explain how to obtain FIX API access and credentials from the broker
Experienced MQL5 Developer Wanted — Fast XAUUSD Scalping EA 300 - 981 USD
I’m looking for an experienced developer to build a fully automated XAUUSD scalping EA for MT5. Requirements: * Fast entries targeting small, profitable moves after trading costs. * Configurable fixed-target and trailing-stop modes. A $1 gold price move can trigger profit protection instead of closing the trade. * Once the profit trigger is reached, move the stop to cover costs and lock in a small net profit, then
​Custom MT5 EA - Multi-Timeframe SMC Fusion Strategy 50 - 110 USD
Project Description: I need an MQL5 Expert Advisor built based on a precise Smart Money Concepts (SMC) multi-timeframe strategy. The bot must analyze the 1-Hour chart for institutional bias and execute trades on the 3-Minute chart following strict structural rules. 1. Inputs & Parameters (Customizable) - Risk Model: Fixed dollar risk of $20.00 for every $100.00 of account balance (20% per trade for personal capital
Looking for a Complete Forex & Gold Signal System — Telegram Automation + Performance Tracking 100 - 2000 USD
Looking for a Complete Forex & Gold Signal System — Telegram Automation + Performance Tracking I’m looking for a complete automated trading signal solution for Forex pairs, including EUR/USD, GBP/USD and others, as well as gold (XAU/USD). Requirements: • An average of 2–3 quality signals per day across the selected instruments. Quality matters more than generating signals just to meet a quota. • A high win rate
I need forex trading robot (EA) that is 100% automated 30 - 35 USD
I need a robot that will grow small accounts to bigger amounts like this one in this link, https://youtu.be/d38pMbJihew?si=3NeIOVyrlwDr4X_o. Please click the link and watch how this EA grow small accounts. Then create a robot like that. I will test it on demo first then if it does what i want, i will take it. Please it must be simply to use. It must set targets, for example, once it reaches $500 profit, it must
Risk 1/3 reward automatic buy sell tarde 80 to 90% reward din mein 30+ USD
Here is a professional, detailed requirements specification draft for your MQL5 freelance order based on your prompt: ​ Strategy Objective: Develop an automated Expert Advisor (EA) featuring a 1:3 Risk-to-Reward ratio optimized for a small starting budget. ​ Core Trading Logic: ​Execute automatic Buy and Sell trades using high-probability entry signals. ​Target a strict 90% theoretical win-rate structure through
Fix gold martingal RSI EA MT5 - Daily 200 and new filter 30+ USD
i want to fix my gold martingale bot MT5. RSI 14 ENTRY 30 BUY 70 SELL Lot 0.02 0.04 0.07 TP 150 for all SL 90 30 30 once total daily profit is 200$ stop trading stop trading once 2 consecutives total losses stop trading if spread exceeded 30 and between hour 15 & 17 PM Move SL to breakeven point once the profit exceeded 50 from from breakeven thanks
MarketMind Breakout Pro XAUUSD H1 — Donchian Breakout EA 30 - 200 USD
MarketMind Breakout Pro XAUUSD H1 — Donchian Breakout EA Project type: Personal EA development and backtesting Platform: MetaTrader 5 Instrument: XAUUSD Timeframe: H1 Strategy: Donchian Channel breakout with EMA 200 Project overview This project evaluates a Donchian breakout trading strategy for XAUUSD on the H1 timeframe. The system uses channel-based breakout conditions and an EMA 200 trend filter. Historical

Informations sur le projet

Budget
30+ USD
Délais
de 1 à 2 jour(s)