Servizio freelance su MQL5.com: Mix two EAs together

Lavoro terminato

Tempo di esecuzione 3 giorni

Feedback del cliente

Super job I recommend, very professionnal, thank you. :)

Feedback del dipendente

Great client! Hope to work with you in the future! thnx

Descrizione

Specifiche

Hello,
I would need to mix these two EAs together, and SUPER TAKE only works with GBPUSD


example:

once the two EAs together I want that when SUPER TAKE reaches "1"
(that the profit is 1 €) then all open positions on the GBPUSD are closed and 
only for GBPUSD.

here are the two EAs

Balbuzia, and SUPER TAKE//+------------------------------------------------------------------+
//|                                              Balbuzia_3_in_1.mq4 |
//|                                         Copyright 2018, GCN ltd. |
//|                                          http://www.it-labmd.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2018, GCN ltd."
#property link      "http://www.it-labmd.com"
#property version   "1.00"
#property strict
extern double  lots1_1          = 0.01;
extern double  lots2_1          = 0.02;
extern double  lots3_1          = 0.04;
input int      TakeProfit1_1     =   10;
input int      StopLoss1_1       =   400;
input int      TakeProfit2_1     =   10;
input int      StopLoss2_1       =   400;
input int      TakeProfit3_1     =   10;
input int      StopLoss3_1       =   400;
extern int     magic_1=000013;
extern double  Level_1=1.2885;
extern double  MaxDeviation_1=9;         // Max Deviation, points

bool RunOnce_1=false;
int last_order_check_1=false;
datetime EaStartTime_1=TimeCurrent();
double takeprofit1_1=TakeProfit1_1;
double stoploss1_1=StopLoss1_1;
double takeprofit2_1=TakeProfit2_1;
double stoploss2_1=StopLoss2_1;
double takeprofit3_1=TakeProfit3_1;
double stoploss3_1=StopLoss3_1;

extern double  lots1_2          = 0.01;
extern double  lots2_2          = 0.02;
extern double  lots3_2          = 0.04;
input int      TakeProfit1_2     =   10;
input int      StopLoss1_2       =   400;
input int      TakeProfit2_2     =   10;
input int      StopLoss2_2       =   400;
input int      TakeProfit3_2     =   10;
input int      StopLoss3_2       =   400;
extern int     magic_2=000014;
extern int     Distance_2= 10;
double  Level_2          = 0;
extern double  MaxDeviation_2=9;         // Max Deviation, points

bool RunOnce_2=false;
int last_order_check_2=false;
datetime EaStartTime_2=TimeCurrent();
double takeprofit1_2=TakeProfit1_2;
double stoploss1_2=StopLoss1_2;
double takeprofit2_2=TakeProfit2_2;
double stoploss2_2=StopLoss2_2;
double takeprofit3_2=TakeProfit3_2;
double stoploss3_2=StopLoss3_2;
int distance_2=Distance_2;

extern double  lots1_3          = 0.01;
extern double  lots2_3          = 0.02;
extern double  lots3_3          = 0.04;
input int      TakeProfit1_3     =   10;
input int      StopLoss1_3       =   400;
input int      TakeProfit2_3     =   10;
input int      StopLoss2_3       =   400;
input int      TakeProfit3_3     =   10;
input int      StopLoss3_3       =   400;
extern int     magic_3=000015;
extern int     Distance_3= 10;
double  Level_3          = 0;
extern double  MaxDeviation_3=9;         // Max Deviation, points

bool RunOnce_3=false;
int last_order_check_3=false;
datetime EaStartTime_3=TimeCurrent();
double takeprofit1_3=TakeProfit1_3;
double stoploss1_3=StopLoss1_3;
double takeprofit2_3=TakeProfit2_3;
double stoploss2_3=StopLoss2_3;
double takeprofit3_3=TakeProfit3_3;
double stoploss3_3=StopLoss3_3;
int distance_3=Distance_3;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- create timer

   MathSrand(GetTickCount());
   if(Digits==5 || Digits==3)
     {
      takeprofit1_1  =TakeProfit1_1*10;
      stoploss1_1    =StopLoss1_1*10;
      takeprofit2_1  =TakeProfit2_1*10;
      stoploss2_1    =StopLoss2_1*10;
      takeprofit3_1  =TakeProfit3_1*10;
      stoploss3_1    =StopLoss3_1*10;
      takeprofit1_2=TakeProfit1_2*10;
      stoploss1_2    =StopLoss1_2*10;
      takeprofit2_2  =TakeProfit2_2*10;
      stoploss2_2    =StopLoss2_2*10;
      takeprofit3_2  =TakeProfit3_2*10;
      stoploss3_2    =StopLoss3_2*10;
      distance_2=Distance_2*10;
      takeprofit1_3=TakeProfit1_3*10;
      stoploss1_3    =StopLoss1_3*10;
      takeprofit2_3  =TakeProfit2_3*10;
      stoploss2_3    =StopLoss2_3*10;
      takeprofit3_3  =TakeProfit3_3*10;
      stoploss3_3    =StopLoss3_3*10;
      distance_3=Distance_3*10;
     }
   Level_2=Level_1+Point()*distance_2;
   Level_3=Level_1-Point()*distance_3;
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   OnTick_1();
   OnTick_2();
   OnTick_3();
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick_1()
  {
   if(IsLastOrderClose(magic_1,EaStartTime_1))
     {
      OnInit();
      Print("Ea Closed Manually ");
      EaStartTime_1=TimeCurrent();
     }
   int ticet;
   int t=MathRand();
   double MA_Fast1,MA_Low1;
   if(CountVsego(magic_1)==0)
     {
      MA_Fast1=iMA( NULL,0,5, 0, MODE_SMA, PRICE_TYPICAL, 0);
      MA_Low1=iMA( NULL, 0, 14, 0, MODE_SMA, PRICE_CLOSE, 1);

      if(Counts(magic_1,EaStartTime_1,RunOnce_1)==0 && MA_Fast1>MA_Low1 && (RunOnce_1 || (Ask>=Level_1 && Ask<=Level_1+(MaxDeviation_1*_Point) && Level_1!=0)))
        {
         ticet=OrderSend(Symbol(),OP_BUY,lots1_1,Ask,3,Bid-stoploss1_1*Point,Ask+takeprofit1_1*Point,"1.1",magic_1,0,clrGreen);
        }

      if(Counts(magic_1,EaStartTime_1,RunOnce_1)==0 && MA_Fast1<MA_Low1 && (RunOnce_1 || (Bid<=Level_1 && Bid>=Level_1-(MaxDeviation_1*_Point) && Level_1!=0)))
        {
         ticet=OrderSend(Symbol(),OP_SELL,lots1_1,Bid,3,Ask+stoploss1_1*Point,Bid-takeprofit1_1*Point,"1.1",magic_1,0,clrRed);
        }

      if(Counts(magic_1,EaStartTime_1,RunOnce_1)==1)
        {
         if(getLastOrderCloseType(magic_1)==1) ticet=OrderSend(Symbol(),OP_BUY,lots2_1,Ask,3,Bid-stoploss2_1*Point,Ask+takeprofit2_1*Point,"1.2",magic_1,0,clrGreen);
         if(getLastOrderCloseType(magic_1)==0) ticet=OrderSend(Symbol(),OP_SELL,lots2_1,Bid,3,Ask+stoploss2_1*Point,Bid-takeprofit2_1*Point,"1.2",magic_1,0,clrRed);
        }

      if(Counts(magic_1,EaStartTime_1,RunOnce_1)==2)
        {
         if(getLastOrderCloseType(magic_1)==1) ticet=OrderSend(Symbol(),OP_BUY,lots3_1,Ask,3,Bid-stoploss3_1*Point,Ask+takeprofit3_1*Point,"1.3",magic_1,0,clrGreen);
         if(getLastOrderCloseType(magic_1)==0) ticet=OrderSend(Symbol(),OP_SELL,lots3_1,Bid,3,Ask+stoploss3_1*Point,Bid-takeprofit3_1*Point,"1.3",magic_1,0,clrRed);
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnTick_2()
  {
   if(IsLastOrderClose(magic_2,EaStartTime_2))
     {
      OnInit();
      Print("Ea Closed Manually ");
      EaStartTime_2=TimeCurrent();
     }
   int ticet;
   int t=MathRand();
   double MA_Fast1,MA_Low1;
   if(CountVsego(magic_2)==0)
     {
      MA_Fast1=iMA( NULL,0,5, 0, MODE_SMA, PRICE_TYPICAL, 0); 
      MA_Low1=iMA( NULL, 0, 14, 0, MODE_SMA, PRICE_CLOSE, 1);
      if(Counts(magic_2,EaStartTime_2,RunOnce_2)==0 && MA_Fast1>MA_Low1 && (RunOnce_2 || (Ask>=Level_2 && Ask<=Level_2+(MaxDeviation_2*_Point) && Level_2!=0)))
        {
         ticet=OrderSend(Symbol(),OP_BUY,lots1_2,Ask,3,Bid-stoploss1_2*Point,Ask+takeprofit1_2*Point,"2.1",magic_2,0,clrGreen);
        }
      if(Counts(magic_2,EaStartTime_2,RunOnce_2)==0 && MA_Fast1<MA_Low1 && (RunOnce_2 || (Bid<=Level_2 && Bid>=Level_2-(MaxDeviation_2*_Point) && Level_2!=0)))
        {
         ticet=OrderSend(Symbol(),OP_SELL,lots1_2,Bid,3,Ask+stoploss1_2*Point,Bid-takeprofit1_2*Point,"2.1",magic_2,0,clrRed);
        }
      if(Counts(magic_2,EaStartTime_2,RunOnce_2)==1)
        {
         if(getLastOrderCloseType(magic_2)==1) ticet=OrderSend(Symbol(),OP_BUY,lots2_2,Ask,3,Bid-stoploss2_2*Point,Ask+takeprofit2_2*Point,"2.2",magic_2,0,clrGreen);
         if(getLastOrderCloseType(magic_2)==0) ticet=OrderSend(Symbol(),OP_SELL,lots2_2,Bid,3,Ask+stoploss2_2*Point,Bid-takeprofit2_2*Point,"2.2",magic_2,0,clrRed);
        }

      if(Counts(magic_2,EaStartTime_2,RunOnce_2)==2)
        {
         if(getLastOrderCloseType(magic_2)==1) ticet=OrderSend(Symbol(),OP_BUY,lots3_2,Ask,3,Bid-stoploss3_2*Point,Ask+takeprofit3_2*Point,"2.3",magic_2,0,clrGreen);
         if(getLastOrderCloseType(magic_2)==0) ticet=OrderSend(Symbol(),OP_SELL,lots3_2,Bid,3,Ask+stoploss3_2*Point,Bid-takeprofit3_2*Point,"2.3",magic_2,0,clrRed);
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
void OnTick_3()
  {
   if(IsLastOrderClose(magic_3,EaStartTime_3))
     {
      OnInit();
      Print("Ea Closed Manually ");
      EaStartTime_3=TimeCurrent();
     }
   int ticet;
   int t=MathRand();
   double MA_Fast1,MA_Low1;
   if(CountVsego(magic_3)==0)
     {
      MA_Fast1=iMA( NULL,0,5, 0, MODE_SMA, PRICE_TYPICAL, 0); // áûñòðàÿ ÌÀ
      MA_Low1=iMA( NULL, 0, 14, 0, MODE_SMA, PRICE_CLOSE, 1); // ìåäëåííàÿ ÌÀ 
      if(Counts(magic_3,EaStartTime_3,RunOnce_3)==0 && MA_Fast1>MA_Low1 && (RunOnce_3 || (Ask>=Level_3 && Ask<=Level_3+(MaxDeviation_3*_Point) && Level_3!=0)))
        {
         ticet=OrderSend(Symbol(),OP_BUY,lots1_3,Ask,3,Bid-stoploss1_3*Point,Ask+takeprofit1_3*Point,"3.1",magic_3,0,clrGreen);
        }
      if(Counts(magic_3,EaStartTime_3,RunOnce_3)==0 && MA_Fast1<MA_Low1 && (RunOnce_3 || (Bid<=Level_3 && Bid>=Level_3-(MaxDeviation_3*_Point) && Level_3!=0)))
        {
         ticet=OrderSend(Symbol(),OP_SELL,lots1_3,Bid,3,Ask+stoploss1_3*Point,Bid-takeprofit1_3*Point,"3.1",magic_3,0,clrRed);
        }
      if(Counts(magic_3,EaStartTime_3,RunOnce_3)==1)
        {
         if(getLastOrderCloseType(magic_3)==1) ticet=OrderSend(Symbol(),OP_BUY,lots2_3,Ask,3,Bid-stoploss2_3*Point,Ask+takeprofit2_3*Point,"3.2",magic_3,0,clrGreen);
         if(getLastOrderCloseType(magic_3)==0) ticet=OrderSend(Symbol(),OP_SELL,lots2_3,Bid,3,Ask+stoploss2_3*Point,Bid-takeprofit2_3*Point,"3.2",magic_3,0,clrRed);
        }
      if(Counts(magic_3,EaStartTime_3,RunOnce_3)==2)
        {
         if(getLastOrderCloseType(magic_3)==1) ticet=OrderSend(Symbol(),OP_BUY,lots3_3,Ask,3,Bid-stoploss3_3*Point,Ask+takeprofit3_3*Point,"3.3",magic_3,0,clrGreen);
         if(getLastOrderCloseType(magic_3)==0) ticet=OrderSend(Symbol(),OP_SELL,lots3_3,Bid,3,Ask+stoploss3_3*Point,Bid-takeprofit3_3*Point,"3.3",magic_3,0,clrRed);
        }
     }
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int getLastOrderCloseType(int magic)
  {
   datetime t=0;
   int tick=-1;
   int i,total=OrdersHistoryTotal();
   for(i=0; i<total; i++)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==magic)
           {
            if(t<OrderCloseTime())
              {
               t=OrderCloseTime();
               tick=OrderTicket();
              }
           }
        }
     }

   for(i=0; i<total; i++)
     {
      if(OrderSelect(tick,SELECT_BY_TICKET))
        {
         return OrderType();
        }
     }

   return tick;
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountSELL(int magic)
  {
   int count=0;
   int i;
   for(i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==magic && OrderType()==OP_SELL)
            count++;
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountBUY(int magic)
  {
   int count=0;
   int i;
   for(i=OrdersTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==magic && OrderType()==OP_BUY)
            count++;
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
int Counts(int magic,datetime &EaStartTime,bool &RunOnce)
  {
   int count=0,i;

   for(i=OrdersHistoryTotal()-1;i>=0;i--)
     {
      if(OrderSelect(i,SELECT_BY_POS,MODE_HISTORY))
        {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()==magic && OrderOpenTime()>=EaStartTime)
           {
            if(OrderProfit()<0)
              {
               if(count==0)
                 {
                  OnInit();
                  EaStartTime=TimeCurrent();
                  RunOnce=true;
                  return(count);
                 }
              }
            else
              {
               count++;
              }
           }
         if(count>2)
           {
            OnInit();
            EaStartTime=TimeCurrent();
            RunOnce=true;
            return(count);
           }
        }
     }
   return(count);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int CountVsego(int magic)
  {
   int Vsego;
   Vsego=CountBUY(magic)+CountSELL(magic);

   return(Vsego);
  }
//+------------------------------------------------------------------+
bool IsLastOrderClose(int magic,datetime &EaStartTime)
  {
   bool signal=false;
   for(int i=OrdersHistoryTotal()-1;i>=0;i--)
     {
      bool select=OrderSelect(i,SELECT_BY_POS,MODE_HISTORY);
      if(select && OrderSymbol()==_Symbol && OrderMagicNumber()==magic)
        {
         if(OrderType()==OP_BUY && OrderOpenTime()>=EaStartTime)
           {
            if(OrderClosePrice()>OrderStopLoss() && OrderClosePrice()<OrderTakeProfit())
              {
               signal=true;
              }
            break;
           }
         else if(OrderType()==OP_SELL && OrderOpenTime()>=EaStartTime)
           {
            if(OrderClosePrice()<OrderStopLoss() && OrderClosePrice()>OrderTakeProfit())
              {
               signal=true;
              }
            break;
           }
        }
     }
   return(signal);
  }
//+------------------------------------------------------------------+
SUPER TAKE


//+------------------------------------------------------------------+
//|                    TakeProfit 1 |
//+------------------------------------------------------------------+

#property copyright ""
#property link      ""


                                       
extern double My_Money_Equity_Target=1;  
                                         
int Slippage=4;                                        
int i;

double   EquityTarget;
//+------------------------------------------------------------------+
                                  
//+------------------------------------------------------------------+
int init()
  {
//---- 
   EquityTarget = AccountEquity()+My_Money_Equity_Target;
//----
   return(0);
  }
//+------------------------------------------------------------------+
                               
//+------------------------------------------------------------------+
int deinit()
  {
//---- 
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
                                         
//+------------------------------------------------------------------+


int start()
{
if (AccountEquity()>= EquityTarget)

   {
    for(i=OrdersTotal()-1;i>=0;i--)
       {
         if(OrderSelect(i,SELECT_BY_POS))
         {
            bool Res=false;
            if(OrderType()==OP_BUY)
            {
               Res = OrderClose(OrderTicket(),OrderLots(),MarketInfo(OrderSymbol(),MODE_BID),Slippage,clrNONE);
            }else if(OrderType()==OP_SELL)
            {
               Res = OrderClose(OrderTicket(),OrderLots(),MarketInfo(OrderSymbol(),MODE_ASK),Slippage,clrNONE);
            }else
            {
               Res = OrderDelete(OrderTicket());
            }
         } 
       }
      Print ("Equity reached to ",DoubleToStr(AccountEquity(),2));
      if(!Res)    return(0);
      EquityTarget = AccountEquity()+My_Money_Equity_Target;
   }  
   
   Comment("Balance: ",AccountBalance(),", Account Equity: ",AccountEquity(),", Account Profit: ",AccountProfit(),
           "\nMy Account Equity Target: ",EquityTarget);
   
  return(0);
}

Con risposta

Valutazioni

(204)

Progetti

326

43%

Arbitraggio

32% / 29%

In ritardo

25%

Gratuito

Ordini simili

I need an Expert Advisor that trades by signal of ADX and Moving Average indicators. It must check and correctly process possible errors in trading operations. The main criteria of opening and closing positions , direction of Moving Average, Price of last bar . Set the number of lots to trade as an input parameter

I need an Expert Advisor based on Vantage signals.It must have check and handling of trade operation errors. The main criteria for opening and closing a position: moving average direction the price is higher the previous bar Trade lots is an input parameter

I need you to develop an MT5 Expert Advisor (EA) in MQL5 specifically for BTCUSD , primarily trading on the 1-minute timeframe (M1) . The goal is to build a professional, rule-based automated trading system that trades strong impulsive BTCUSD moves in the direction of the trend , while using strict risk and money management. 1. CORE STRATEGY The EA should NOT randomly buy or sell. The basic sequence should be: Trend

Expert Needs to integrate Volume Density ( Ticks Per Point ) Adaptive Volume Baseline ( Apply with experience ) , Order Flow Tick Volume Based ( required integration is for smooth execution ) , Every other requirement already exists by the expert , True Objective : To identify the true transition from Accumulation to Expansion/Distribution leading to Breakout capturing participation while eliminating false breakouts

I need a professional XAUUSD signal indicator for MetaTrader 5, written entirely in MQL5 (.mq5). IMPORTANT: This is NOT an auto-trading EA. It must never open, close or modify trades. It only analyzes XAUUSD and generates signals + MT5 push notifications. 1. Multi-timeframe analysis: H4 → H1 → M30 → M15 → M10 → M5 → M1. 2. Detect market structure: - Swing High / Swing Low - BOS - MSS - CHOCH - Bullish/Bearish HTF

Hi. I am looking for an experienced MQL5 developer for an advanced XAUUSD MT5 indicator. Before choosing a developer, I would like to see a small proof-of-concept or an example of a similar indicator you have already developed. My final indicator must be written from scratch in MQL5 and I must receive the complete .mq5 source code + compiled .ex5 . Main requirements: XAUUSD MT5 / MQL5 Indicator only — NO AutoTrading

Title: Advanced XAUUSD MT5 Indicator – MQL5 Source Code Required I need a professional MT5 indicator written from scratch in MQL5 (.mq5) for XAUUSD. The indicator must be signals/analysis only — AutoTrading must remain OFF . I need the complete editable .mq5 source code, not only an .ex5 file. The system should analyze multiple timeframes: H4 → H1 → M30 → M15 → M5 → M1 . Required logic: Higher-timeframe

Hello, Before I select a developer, please confirm that you can implement the complete MT5 EA exactly according to my specification. The most important requirements are: 1. Strict NO-REPAINT / NO-HINDSIGHT logic. 2. Sweep, MSS/BOS, Displacement, FVG, Order Block and POI must be defined algorithmically before coding. 3. M1 and M5 confirmation logic. 4. Zero-Float Entry logic. 5. MT5 terminal alerts and immediate MT5

I would like to create a tradingview robot that will sync with tradovate. My strategy is as follows: Chart Setup - MES on left and MNQ on right. The MES chart has quarter levels on it. The MNQ has the volume indicator. Trading Session is from 9:30AM EST - 11:00AM EST If most recent price action has crossed *up* a quarter level on MES, I look for *sells* on MNQ. My trigger for a sell is a bearish engulfing candlestick

Informazioni sul progetto

Budget

30+ USD

Scadenze

a 2 giorno(i)

Qualità delle specifiche
Qualità del controllo dei risultati
Disponibilità e capacità di comunicazione