FreelanceKategorien

TrendPullbackEA.mq5

MQL5 Experten Forex Debugging eines Roboters/Indikators C++

Spezifikation


#property strict
#property version   "1.00"
#property description "EMA Trend + Pullback + Engulfing EA"

// Include the standard MT5 trade library.
#include <Trade/Trade.mqh>

CTrade trade;

//==============================================================
// INPUT SETTINGS
//==============================================================

// Trend indicators
input int FastEMA = 20;
input int SlowEMA = 50;

// Pullback settings
input int PullbackBars = 5;

// Stop-loss settings
// 0 = recent swing high/low
// 1 = ATR-based stop loss
input int    SL_Mode = 0;
input int    ATR_Period = 14;
input double ATR_Multiplier = 1.5;

// Take-profit setting
input double RiskReward = 2.0;

// Money management
input bool   UseFixedLot = true;
input double FixedlotSize = 0.10;
input double RiskPercent = 1.0;

// Trading controls
input ulong MagicNumber = 20261029;
input int   TradeStartHour = 8;
input int   TradeEndHour = 17;

// Debug messages in the Experts tab
input bool DebugMode = true;

//==============================================================
// GLOBAL VARIABLES
//==============================================================

// Indicator handles are created once and reused.
int fastEMAHandle = INVALID_HANDLE;
int slowEMAHandle = INVALID_HANDLE;
int atrHandle     = INVALID_HANDLE;

// Remember the opening time of the current candle.
// This ensures that signals are checked only once per candle.
datetime lastBarTime = 0;

//==============================================================
// DEBUGGING HELPER
//==============================================================
void DebugPrint(string message)
{
   if(DebugMode)
      Print("[TrendPullbackEA] ", message);
}

//==============================================================
// INITIALIZATION
//==============================================================
int OnInit()
{
   // Validate settings before starting.
   if(FastEMA <= 0 || SlowEMA <= 0 ||
      FastEMA >= SlowEMA ||
      PullbackBars < 1 ||
      ATR_Period <= 0 ||
      ATR_Multiplier <= 0 ||
      RiskReward <= 0 ||
      SL_Mode < 0 || SL_Mode > 1 ||
      FixedlotSize <= 0 ||
      RiskPercent <= 0 ||
      TradeStartHour < 0 || TradeStartHour > 23 ||
      TradeEndHour < 0 || TradeEndHour > 23)
   {
      Print("Invalid EA input settings. Check the Inputs tab.");
      return INIT_PARAMETERS_INCORRECT;
   }

   // Create the EMA indicator handles for the chart timeframe.
   fastEMAHandle = iMA(_Symbol, _Period, FastEMA,
                       0, MODE_EMA, PRICE_CLOSE);

   slowEMAHandle = iMA(_Symbol, _Period, SlowEMA,
                       0, MODE_EMA, PRICE_CLOSE);

   // Create the ATR handle, used when SL_Mode = 1.
   atrHandle = iATR(_Symbol, _Period, ATR_Period);

   // Stop if any indicator could not be initialized.
   if(fastEMAHandle == INVALID_HANDLE ||
      slowEMAHandle == INVALID_HANDLE ||
      atrHandle == INVALID_HANDLE)
   {
      Print("Failed to create indicator handles. Error: ",
            GetLastError());
      return INIT_FAILED;
   }

   // Configure the trade object.
   trade.SetExpertMagicNumber(MagicNumber);
   trade.SetTypeFillingBySymbol(_Symbol);
   trade.SetAsyncMode(false);

   // Initialize the current candle time.
   lastBarTime = iTime(_Symbol, _Period, 0);

   DebugPrint("EA initialized successfully.");

   return INIT_SUCCEEDED;
}

//==============================================================
// SHUTDOWN
//==============================================================
void OnDeinit(const int reason)
{
   // Release indicator resources when the EA is removed.
   if(fastEMAHandle != INVALID_HANDLE)
      IndicatorRelease(fastEMAHandle);

   if(slowEMAHandle != INVALID_HANDLE)
      IndicatorRelease(slowEMAHandle);

   if(atrHandle != INVALID_HANDLE)
      IndicatorRelease(atrHandle);

   DebugPrint("EA stopped.");
}

//==============================================================
// NEW CANDLE DETECTION
//==============================================================
bool IsNewBar()
{
   datetime currentBarTime = iTime(_Symbol, _Period, 0);

   if(currentBarTime == 0)
      return false;

   if(currentBarTime != lastBarTime)
   {
      lastBarTime = currentBarTime;
      return true;
   }

   return false;
}

//==============================================================
// TRADING HOURS
//==============================================================
bool IsTradingTime()
{
   // Uses broker/server time, not your computer's local time.
   MqlDateTime currentTime;
   TimeToStruct(TimeTradeServer(), currentTime);

   int hour = currentTime.hour;

   // Equal start and end hours means trading all day.
   if(TradeStartHour == TradeEndHour)
      return true;

   // Normal session, for example 08:00 to 17:00.
   if(TradeStartHour < TradeEndHour)
   {
      return (hour >= TradeStartHour &&
              hour < TradeEndHour);
   }

   // Overnight session, for example 22:00 to 06:00.
   return (hour >= TradeStartHour ||
           hour < TradeEndHour);
}

//==============================================================
// CHECK FOR AN EXISTING POSITION ON THIS SYMBOL
//==============================================================
bool HasOpenPosition()
{
   // Check all open positions.
   // This prevents another trade on the symbol, even if another
   // EA or a manual trade opened the existing position.
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);

      if(ticket == 0)
         continue;

      if(PositionGetString(POSITION_SYMBOL) == _Symbol)
         return true;
   }

   return false;
}

//==============================================================
// LOAD INDICATOR VALUES
//==============================================================
bool GetIndicatorValue(int handle, int shift, double &value)
{
   double buffer[1];

   // Copy one indicator value from the requested candle.
   if(CopyBuffer(handle, 0, shift, 1, buffer) != 1)
      return false;

   value = buffer[0];

   return (value != EMPTY_VALUE);
}

//==============================================================
// PULLBACK DETECTION
//==============================================================
bool HasPullback()
{
   // Search completed candles BEFORE the engulfing candle.
   // Shift 1 is the signal candle, so start from shift 2.
   for(int shift = 2; shift <= PullbackBars + 1; shift++)
   {
      double fastEMA, slowEMA;

      if(!GetIndicatorValue(fastEMAHandle, shift, fastEMA) ||
         !GetIndicatorValue(slowEMAHandle, shift, slowEMA))
      {
         return false;
      }

      double candleHigh = iHigh(_Symbol, _Period, shift);
      double candleLow  = iLow(_Symbol, _Period, shift);

      // The area between the two EMAs.
      double zoneHigh = MathMax(fastEMA, slowEMA);
      double zoneLow  = MathMin(fastEMA, slowEMA);

      // The candle range overlaps the EMA zone.
      if(candleLow <= zoneHigh && candleHigh >= zoneLow)
         return true;
   }

   return false;
}

//==============================================================
// BULLISH ENGULFING PATTERN
//==============================================================
bool IsBullishEngulfing()
{
   // Candle 1 is the most recently completed candle.
   // Candle 2 is the completed candle immediately before it.
   double open1  = iOpen(_Symbol, _Period, 1);
   double close1 = iClose(_Symbol, _Period, 1);
   double open2  = iOpen(_Symbol, _Period, 2);
   double close2 = iClose(_Symbol, _Period, 2);

   // Previous candle must be bearish.
   // Signal candle must be bullish and engulf the previous body.
   return (close2 < open2 &&
           close1 > open1 &&
           open1 <= close2 &&
           close1 >= open2);
}

//==============================================================
// BEARISH ENGULFING PATTERN
//==============================================================
bool IsBearishEngulfing()
{
   double open1  = iOpen(_Symbol, _Period, 1);
   double close1 = iClose(_Symbol, _Period, 1);
   double open2  = iOpen(_Symbol, _Period, 2);
   double close2 = iClose(_Symbol, _Period, 2);

   // Previous candle must be bullish.
   // Signal candle must be bearish and engulf the previous body.
   return (close2 > open2 &&
           close1 < open1 &&
           open1 >= close2 &&
           close1 <= open2);
}

//==============================================================
// FIND RECENT SWING STOP-LOSS PRICE
//==============================================================
double GetSwingStopLoss(bool isBuy)
{
   // Include the signal candle and recent candles before it.
   // This is a simple rolling swing approximation, not a
   // specialized market-structure swing-point detector.
   int lookback = PullbackBars + 1;

   double swingPrice = isBuy
                       ? iLow(_Symbol, _Period, 1)
                       : iHigh(_Symbol, _Period, 1);

   for(int shift = 2; shift <= lookback + 1; shift++)
   {
      if(isBuy)
      {
         double candleLow = iLow(_Symbol, _Period, shift);

         if(candleLow < swingPrice)
            swingPrice = candleLow;
      }
      else
      {
         double candleHigh = iHigh(_Symbol, _Period, shift);

         if(candleHigh > swingPrice)
            swingPrice = candleHigh;
      }
   }

   return swingPrice;
}

//==============================================================
// NORMALIZE LOT SIZE TO BROKER REQUIREMENTS
//==============================================================
double NormalizeVolume(double volume)
{
   double minLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   double maxLot = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);
   double step   = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_STEP);

   if(step <= 0 || minLot <= 0 || maxLot <= 0)
      return 0.0;

   // Do not increase an undersized risk-based lot to the broker's
   // minimum, because that could exceed the intended risk.
   if(volume < minLot)
      return 0.0;

   volume = MathMin(volume, maxLot);

   // Round DOWN to a valid volume step.
   volume = MathFloor(volume / step + 1e-9) * step;

   if(volume < minLot)
      return 0.0;

   // Derive the number of decimal places from the volume step.
   int digits = 0;
   double checkStep = step;

   while(digits < 8 &&
         MathAbs(checkStep - MathRound(checkStep)) > 1e-8)
   {
      checkStep *= 10.0;
      digits++;
   }

   return NormalizeDouble(volume, digits);
}

//==============================================================
// CALCULATE LOT SIZE
//==============================================================
double CalculateLotSize(bool isBuy, double entryPrice,
                        double stopLoss)
{
   // Fixed-lot mode: use the user-defined lot size.
   if(UseFixedLot)
      return NormalizeVolume(FixedlotSize);

   // Risk-based mode: calculate risk as a percentage of equity.
   double equity = AccountInfoDouble(ACCOUNT_EQUITY);
   double riskMoney = equity * RiskPercent / 100.0;

   if(equity <= 0 || riskMoney <= 0)
      return 0.0;

   // Ask MT5 to estimate the monetary result for one lot
   // if the stop-loss price is reached.
   double profitAtSL = 0.0;

   ENUM_ORDER_TYPE orderType = isBuy ? ORDER_TYPE_BUY
                                     : ORDER_TYPE_SELL;

   if(!OrderCalcProfit(orderType, _Symbol, 1.0,
                       entryPrice, stopLoss, profitAtSL))
   {
      DebugPrint("OrderCalcProfit failed. Error: " +
                 IntegerToString(GetLastError()));
      return 0.0;
   }

   double lossPerLot = MathAbs(profitAtSL);

   if(lossPerLot <= 0)
      return 0.0;

   double rawLots = riskMoney / lossPerLot;

   return NormalizeVolume(rawLots);
}

//==============================================================
// VALIDATE STOP LOSS AND TAKE PROFIT DISTANCES
//==============================================================
bool ValidateStops(bool isBuy, double entryPrice,
                   double stopLoss, double takeProfit)
{
   // Check that prices are on the correct sides of entry.
   if(isBuy && (stopLoss >= entryPrice ||
                takeProfit <= entryPrice))
      return false;

   if(!isBuy && (stopLoss <= entryPrice ||
                 takeProfit >= entryPrice))
      return false;

   // Respect the broker's minimum stop distance.
   long stopsLevel = SymbolInfoInteger(_Symbol,
                                       SYMBOL_TRADE_STOPS_LEVEL);

   double minimumDistance = stopsLevel * _Point;

   if(isBuy)
   {
      if(entryPrice - stopLoss < minimumDistance ||
         takeProfit - entryPrice < minimumDistance)
         return false;
   }
   else
   {
      if(stopLoss - entryPrice < minimumDistance ||
         entryPrice - takeProfit < minimumDistance)
         return false;
   }

   return true;
}

//==============================================================
// OPEN A TRADE
//==============================================================
void OpenTrade(bool isBuy)
{
   MqlTick tick;

   if(!SymbolInfoTick(_Symbol, tick))
   {
      DebugPrint("Unable to obtain current market prices.");
      return;
   }

   // A market order fills at the current ask for a buy
   // and at the current bid for a sell.
   double entryPrice = isBuy ? tick.ask : tick.bid;

   double stopLoss = 0.0;

   // Select the requested stop-loss method.
   if(SL_Mode == 0)
   {
      stopLoss = GetSwingStopLoss(isBuy);
   }
   else
   {
      double atrValue;

      if(!GetIndicatorValue(atrHandle, 1, atrValue) ||
         atrValue <= 0)
      {
         DebugPrint("ATR value unavailable.");
         return;
      }

      double distance = atrValue * ATR_Multiplier;

      stopLoss = isBuy ? entryPrice - distance
                       : entryPrice + distance;
   }

   // Normalize SL to the symbol's price precision.
   stopLoss = NormalizeDouble(stopLoss, _Digits);

   // Check that the stop-loss is valid before sizing the trade.
   if((isBuy && stopLoss >= entryPrice) ||
      (!isBuy && stopLoss <= entryPrice))
   {
      DebugPrint("Invalid stop-loss price.");
      return;
   }

   // The target is based on the distance from entry to SL.
   double riskDistance = MathAbs(entryPrice - stopLoss);

   double takeProfit = isBuy
                       ? entryPrice + riskDistance * RiskReward
                       : entryPrice - riskDistance * RiskReward;

   takeProfit = NormalizeDouble(takeProfit, _Digits);

   // Do not send orders that violate broker stop-distance rules.
   if(!ValidateStops(isBuy, entryPrice, stopLoss, takeProfit))
   {
      DebugPrint("Trade skipped: stop distances are invalid "
                 "or too close to market price.");
      return;
   }

   // Calculate volume only after the final stop-loss is known.
   double lots = CalculateLotSize(isBuy, entryPrice, stopLoss);

   if(lots <= 0)
   {
      DebugPrint("Trade skipped: calculated lot size is invalid "
                 "or below the broker minimum.");
      return;
   }

   // Send the market order with SL and TP attached.
   bool sent = false;

   if(isBuy)
   {
      sent = trade.Buy(lots, _Symbol, 0.0,
                       stopLoss, takeProfit,
                       "EMA Pullback Buy");
   }
   else
   {
      sent = trade.Sell(lots, _Symbol, 0.0,
                        stopLoss, takeProfit,
                        "EMA Pullback Sell");
   }

   // A successful method call does not always mean the broker
   // executed the order, so inspect the trade result retcode.
   uint retcode = trade.ResultRetcode();

   if(sent &&
      (retcode == TRADE_RETCODE_DONE ||
       retcode == TRADE_RETCODE_DONE_PARTIAL ||
       retcode == TRADE_RETCODE_PLACED))
   {
      DebugPrint(string(isBuy ? "BUY" : "SELL") +
                 " request accepted. Lots=" +
                 DoubleToString(lots, 4) +
                 ", SL=" + DoubleToString(stopLoss, _Digits) +
                 ", TP=" + DoubleToString(takeProfit, _Digits));
   }
   else
   {
      DebugPrint("Trade failed. Retcode=" +
                 IntegerToString((int)retcode) +
                 ", description=" + trade.ResultRetcodeDescription());
   }
}

//==============================================================
// MAIN EA LOGIC
//==============================================================
void OnTick()
{
   // Check signals once per new candle, not on every tick.
   if(!IsNewBar())
      return;

   // Ensure enough chart history is available.
   int requiredBars = MathMax(SlowEMA, ATR_Period)
                      + PullbackBars + 5;

   if(Bars(_Symbol, _Period) < requiredBars)
   {
      DebugPrint("Waiting for more candle history.");
      return;
   }

   // Do not open another position on this symbol.
   if(HasOpenPosition())
   {
      DebugPrint("Position already exists on this symbol.");
      return;
   }

   // Restrict new entries to the selected trading hours.
   if(!IsTradingTime())
   {
      DebugPrint("Outside trading hours.");
      return;
   }

   // Read EMA values from the most recently closed candle.
   double fastEMA, slowEMA;

   if(!GetIndicatorValue(fastEMAHandle, 1, fastEMA) ||
      !GetIndicatorValue(slowEMAHandle, 1, slowEMA))
   {
      DebugPrint("Unable to read EMA values.");
      return;
   }

   // Determine trend direction.
   bool uptrend   = (fastEMA > slowEMA);
   bool downtrend = (fastEMA < slowEMA);

   // Confirm that a pullback occurred before the signal candle.
   bool pullback = HasPullback();

   if(!pullback)
   {
      DebugPrint("No pullback into the EMA zone.");
      return;
   }

   // Evaluate the completed signal candle.
   if(uptrend && IsBullishEngulfing())
   {
      DebugPrint("Bullish engulfing after pullback. Buy signal.");
      OpenTrade(true);
   }
   else if(downtrend && IsBearishEngulfing())
   {
      DebugPrint("Bearish engulfing after pullback. Sell signal.");
      OpenTrade(false);
   }
   else
   {
      DebugPrint("No valid engulfing signal.");
   }
}

Bewerbungen

1
Entwickler 1
Bewertung
(111)
Projekte
184
25%
Schlichtung
25
16% / 76%
Frist nicht eingehalten
16
9%
Frei
2
Entwickler 2
Bewertung
(402)
Projekte
521
24%
Schlichtung
61
57% / 25%
Frist nicht eingehalten
60
12%
Beschäftigt
3
Entwickler 3
Bewertung
(1)
Projekte
2
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
Veröffentlicht: 15 Beispiele
4
Entwickler 4
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
5
Entwickler 5
Bewertung
(62)
Projekte
90
29%
Schlichtung
24
13% / 58%
Frist nicht eingehalten
7
8%
Arbeitet
6
Entwickler 6
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
7
Entwickler 7
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
8
Entwickler 8
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
9
Entwickler 9
Bewertung
(29)
Projekte
36
39%
Schlichtung
0
Frist nicht eingehalten
2
6%
Frei
10
Entwickler 10
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
Veröffentlicht: 1 Beispiel
11
Entwickler 11
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
12
Entwickler 12
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
13
Entwickler 13
Bewertung
(1)
Projekte
1
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
Veröffentlicht: 4 Beispiele
14
Entwickler 14
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
15
Entwickler 15
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
16
Entwickler 16
Bewertung
(2)
Projekte
2
0%
Schlichtung
1
0% / 100%
Frist nicht eingehalten
0
Frei
17
Entwickler 17
Bewertung
(319)
Projekte
574
35%
Schlichtung
83
31% / 45%
Frist nicht eingehalten
207
36%
Frei
18
Entwickler 18
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
Veröffentlicht: 10 Beispiele
19
Entwickler 19
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
20
Entwickler 20
Bewertung
(5)
Projekte
6
83%
Schlichtung
0
Frist nicht eingehalten
0
Frei
Veröffentlicht: 2 Beispiele
21
Entwickler 21
Bewertung
(8)
Projekte
8
0%
Schlichtung
2
50% / 0%
Frist nicht eingehalten
1
13%
Arbeitet
22
Entwickler 22
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
Veröffentlicht: 4 Beispiele
23
Entwickler 23
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
24
Entwickler 24
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
25
Entwickler 25
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
Veröffentlicht: 1 Beispiel
26
Entwickler 26
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
27
Entwickler 27
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
28
Entwickler 28
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
29
Entwickler 29
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
30
Entwickler 30
Bewertung
(13)
Projekte
21
38%
Schlichtung
0
Frist nicht eingehalten
1
5%
Arbeitet
31
Entwickler 31
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
32
Entwickler 32
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
Veröffentlicht: 1 Beispiel
33
Entwickler 33
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
34
Entwickler 34
Bewertung
(6)
Projekte
8
38%
Schlichtung
1
0% / 100%
Frist nicht eingehalten
0
Frei
35
Entwickler 35
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
Veröffentlicht: 1 Beispiel
36
Entwickler 36
Bewertung
Projekte
0
0%
Schlichtung
0
Frist nicht eingehalten
0
Frei
Ähnliche Aufträge
Fast Scalper EA for multiple Pairs and Gold 30 - 100 USD
USD54 Applications The bot should open trades when the price breaks out of the band by a specified percentage, for example, 0.10%. If the price breaks above the band, the bot should open a long position. If the price breaks below the band, it should open a short position. The bot should also open trades when the price touches a band: Bullish band cross: When a bullish cross occurs between the bands, the bot should
Ea trades per movement but covers spread 30 - 40 USD
Hi there great developers I need someone who can create an trading ea that can open order per movement but it must cover up the spread first if it going to place an order the ea should read the spread it can use and indicator that can calculate the market point using atr if the spread is 20 points then the ea calculation the next price if it will go more then 20 points it can automatically place orders and close in
Best trader robot 499 - 550 USD
Objective: Develop a robust and highly profitable Expert Advisor (EA) for MetaTrader based on a precise custom trading strategy to achieve a high win rate. ​ Instrument & Timeframe: XAUUSD (Gold), optimized for M5 / M15 timeframes. ​ Entry Strategy: Open Buy/Sell orders based on strict confirmation signals (e.g., Moving Average crossover combined with Price Action or RSI threshold). ​ Lot Size & Risk Management
Sviluppo EA XAUUSD M1 con Buy/Sell Stop e trailing stop 30 - 150 USD
Titolo: Cerco sviluppatore per EA su XAUUSD M1 per conto reale Cerco uno sviluppatore MQL5 per creare un Expert Advisor per MetaTrader 5 su XAUUSD M1, da utilizzare su conto reale con deposito iniziale di 100–200 €. La strategia prevede un Buy Stop a 1,00 sopra l’Ask e un Sell Stop a 1,00 sotto il Bid, entrambi con stop loss iniziale di 1,00 e senza take profit fisso. I pendenti devono restare fermi: quando uno viene
Title: Development of Prop Firm Compliant XAUUSD MT5 EA (Full MQ5 Source Code 500+ USD
I am looking for a skilled MQL5 developer to create a robust, institutional-grade Expert Advisor for MT5, optimized for Gold (XAUUSD). The EA must comply strictly with prop firm rules. Key Requirements: Asset: XAUUSD (Gold) on MT5 Risk Management: Strict Stop-Loss & Take-Profit on every order. Absolute daily max loss, overall max drawdown guard, and percentage risk per trade. No High Risk: NO Martingale, Grid, or
Master Scalping EA 30+ USD
// Meta Scalper EA - RSI + Breakout + Lot Management #property strict #include <Trade\Trade.mqh> CTrade trade; input int RSI_Period=14; input double RSI_Overbought=70; input double RSI_Oversold=30; input int Breakout_Period=20; input int ATR_Period=14; input double ATR_Multiplier_SL=1.5; input double ATR_Multiplier_TP=3.0; input bool UseRiskPercent=true; input double RiskPercent=2.0; input double FixedLot=0.1; input
News trading made simple 30+ USD
Hello lovies, I’m reaching out because I’m working on a specialized macroeconomic intelligence service focused on major economic releases and their potential impact on gold (XAUUSD), the US dollar, and the wider financial markets. My approach goes beyond simply following the economic calendar. I focus on understanding the information behind upcoming events, market expectations, and the potential implications for
EA for XAUUSD and possibly currencies 1000 - 5000 USD
MT5 Expert Advisor Development Brief — Forex Project objective I am looking for an experienced MQL5 developer to build a bespoke, fully automated Expert Advisor for MetaTrader 5. The EA will be used on both proprietary trading firm (prop-firm) accounts and my own live trading account. My priorities, in order, are: 1. Low drawdown and robust risk management. 2. Consistent, repeatable profitability. 3. Reliable
Convert tradingview pinescript to mt5 ea 30+ USD
Platform: MT5 only (no MT4 needed). Deliverable: an MT5 Expert Advisor with full source code (.mq5) that replicates the attached TradingView strategy (Pine Script v6, based on LuxAlgo's "ICT Killzones Toolkit" order blocks) as exactly as possible. Pasting the code into TradingView shows how it operates. I normally trade GBPUSD on the 5-minute chart Expected behavior: - Order block detection must match the Pine code
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

Projektdetails

Budget
30+ USD

Kunde

Veröffentlichte Aufträge1
Anzahl der Schlichtungen0