Aide au codage - page 693

 
mladen:

Ray

Essayez-le maintenant

Mladen

Toujours pas de changement. Peut-on réessayer ?

C'est tout ce que j'ai fait pour le 2MA ;

double fastMA = iMA(NULL,0,FastMa,FastMaShift,FastMaMethod,FastMaPrice,i) ;
double slowMA = iMA(NULL,0,SlowMa,SlowMaShift,SlowMaMethod,SlowMaPrice,i) ;

UpH[i] = EMPTY_VALUE;
DnH[i] = EMPTY_VALUE ;
trend[i] = trend[i+1] ;

double diffu = (fastMA - slowMA) ;

double diffd = (slowMA - fastMA) ;

si (diffu > diff_Level ) trend[i] = 1 ;
si (diffd > diff_Level ) trend[i] = -1 ;


Merci

Rayon

 
traderduke:

Mladen

Toujours pas de changement. Peut-on réessayer ?

C'est tout ce que j'ai fait pour le 2MA ;

double fastMA = iMA(NULL,0,FastMa,FastMaShift,FastMaMethod,FastMaPrice,i) ;
double slowMA = iMA(NULL,0,SlowMa,SlowMaShift,SlowMaMethod,SlowMaPrice,i) ;

UpH[i] = EMPTY_VALUE ;
DnH[i] = EMPTY_VALUE ;
trend[i] = trend[i+1] ;

double diffu = (fastMA - slowMA) ;

double diffd = (slowMA - fastMA) ;

si (diffu > diff_Level ) trend[i] = 1 ;
si (diffd > diff_Level ) trend[i] = -1 ;


Merci

Rayon

Voici ce que j'obtiens lorsque j'essaie le mode multi time frame (l'indicateur du post ci-dessus)


D' après ce que je vois, tout fonctionne comme il est supposé le faire.

 
mladen:

C'est ce que j'obtiens lorsque j'essaie le mode multi time frame (l'indicateur du post ci-dessus).

ATTENTION : La vidéo doit être rechargée

ATTENTION : La vidéo doit être téléchargée à nouveau
Pour autant que je sache, tout fonctionne comme il est supposé fonctionner.

Mladen

Je m'excuse de ne pas avoir présenté mon problème avec clarté. Vous avez raison sur le diff_Levelms 0.0 qui fonctionne correctement, mais l'ajout de diff_Levelms était de permettre des changements mineurs tels que l'étendue à rejeter comme .0002 pour EURUSD ou .02 pour USDJPY. Apparemment, mon calcul de diff n'est pas utilisé par le calcul de trend1.

double diffums = (ma2[i]-ma3[i]) ; //med-slow Apparemment mon calcul
double diffdms = (ma3[i]-ma2[i]) ;//slow - med Appare mment mon calcul

si (ma1[i]>ma2[i]) trendfm[i] =1;
si (ma1[i]<ma2[i]) trendfm[i] =-1;
si (ma1[i]>ma3[i]) trendfs[i] =1;
si (ma1[i]<ma3[i]) trendfs[i] =-1;
si (ma2[i]>ma3[i] && diffums > diff_Levelms) trendms[i] =1; n'est pas utilisé par le calcul de trend1
si (ma2[i]<ma3[i] && diffdms > diff_Levelms) trendms[i] =-1; non utilisé par le calcul de la tendance 1


Merci pour votre aide.

Ray


 

L'indicateur ne se met pas à jour


J'ai téléchargé l'indicateur "Outsidebar Trendline V2" ci-joint mais pour une raison quelconque, il ne se met pas à jour sur la prochaine barre/candle.

la barre/candle suivante. Lorsque l'on change de cadre temporel, il fonctionne bien, mais sur la barre suivante, dans ce cadre temporel, il ne fonctionne plus.

Un expert pourrait-il m'aider à faire en sorte que l'indicateur se rafraîchisse également sur les barres suivantes ?

Merci beaucoup.

Lea

Dossiers :
 

mladen,

Mon ami a écrit cet EA basé sur l'indicateur vertex, nous n'avons pas été en mesure d'exécuter un backtest après qu'il l'ait créé. S'il vous plaît pouvez-vous m'aider à corriger l'erreur qui l'empêche d'être en mesure de backrest. mais il nécessite beaucoup de mise à jour une fois qu'il est nettoyé

Merci et apprciez humblement

// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
#include <stdlib.mqh>
#include <stderror.mqh> 



#property copyright "reddevil"
#property link ""
#property version "3.0";
// 19-09 minimum of 4 periods before the next order.
// v1.2 check alternate timeframe for spike
// v2.0 uses 3.01a indicator with alternate timeframe
//v3.0 red crossing blue as entry
// trailing after line cross
// ------------------------------------------------------------------------------------------------
// VARIABLES EXTERNAS
// ------------------------------------------------------------------------------------------------
//
// check for candle 

extern int magic = 668899;
 string progName="VertexPro3";
 string key = "vertex 3.0";
// Configuration

extern string CommonSettings = "---------------------------------------------";
extern int user_slippage = 2; 
extern double max_spread = 3.0;
extern int user_tp = 0; // min TP
extern int user_sl = 50; // max SL
//extern int AlternateTF = 30 ; // 30 mins
extern double Entry_line =10; // 10 sell, -10 buy
// extern double Entry_pips = 10; // from highest high or lowest low
extern string TakeProfit_trigger ="------------------------------------------";
extern int TPdefault_line =25;
extern double BBvalue1 =10.0;
extern int BBTP_line =15;

//extern bool DailyFilter=true;
extern bool NewsFilter=false;
extern int MinsBeforeNews=1440;
extern int MinsAfterNews=60;
extern int maxOrders=3; //max 3
extern string Trailing = "----------------------------------------------------";
extern int UseTrailing=2 ; // 0 - no trailing, 1- normal; 2-trail after TP line

extern int TrailStartPips=8;
extern int Trailpips=5;
extern int TrailStepPips=3;
extern string MoneyManagementSettings = "---------------------------------------------";
// Money Management
extern bool money_management = false;
extern double min_lots = 0.1;
extern int risk=1;
extern int progression = 0; // 0=none | 1:ascending | 2:martingale


extern int GMToffset=2;
int arrLgt=3;
int buy_magic[3];
int sell_magic[3];
int buy_tickets[3];
int sell_tickets[3];
// Lots
double buy_lots[3];
double sell_lots[3];
// Current Profit
double buy_profit[3];
double sell_profit[3];
//SL
double sell_sl[3];
double buy_sl[3];
//TP
double sell_tp[3];
double buy_tp[3];
// Open Price
double buy_price[3];
double sell_price[3];

datetime buy_time; // last buytime
datetime sell_time;
// Indicator
double rsi=0;
// Number of orders
int buys = 0;
int sells = 0;
double total_buy_profit=0,total_sell_profit=0;
double total_buy_lots=0, total_sell_lots=0;
double buy_max_profit=0, buy_close_profit=0;
double sell_max_profit=0, sell_close_profit=0;
// Indicator


// ------------------------------------------------------------------------------------------------
// VARIABLES GLOBALES
// ------------------------------------------------------------------------------------------------



// indicadores

// Cantidad de ordenes;
int orders = 0;
int direction= 0;
double max_profit=0, close_profit=0;
double last_order_profit=0, last_order_lots=0;
// Colores
color c=Black;
// Cuenta
double balance, equity;
int slippage=0;
// OrderReliable




int OldHist=0;
double SL,PT,_spread;
int newMagic1,newMagic2;
int curMagic;
int Tframe = PERIOD_H1;
datetime  OldTime;
int _DSTtime=0;
int pendingTicket=-1;
bool NoNews=true;
int mBefore, mAfter;

// ------------------------------------------------------------------------------------------------
// START
//
void init()
{
    if (Digits==4 || Digits==2)
  {
    slippage = user_slippage;
    PT=Point;
  }
  else if (Digits==5 || Digits==3)
  {
      slippage = 10*user_slippage;
      PT=Point*10;
  }
  
        
 
  if(maxOrders > 3)  maxOrders=3;
  
      
  newMagic1 = StrToInteger(IntegerToString(TPdefault_line) + IntegerToString(magic));
  newMagic2 = StrToInteger(IntegerToString(BBTP_line) + IntegerToString(magic)); 
}
int start()
{  
  double point = MarketInfo(Symbol(), MODE_POINT);
  double dd=0;
  
  string DST = "Yes";
  
  bool  encontrada;
  balance=AccountBalance();
  equity=AccountEquity();
  
  if(TimeCurrent() - OldTime > 25)
      {
         RefreshRates();
         OldTime=TimeCurrent();
      }

  _spread =  NormalizeDouble(MathAbs(Ask-Bid)/PT,2);
  
  if(IsTradeAllowed() == false) 
  {
    Comment("nTrade not allowed.");
    return(0);  
  }
  /*if(StringLen(DoubleToStr(TPdefault_line)) > 3 || StringLen(DoubleToStr(BBTP_line)) > 3)
  {
       Comment("nTPdefault or BBTP too long");
       return(1);
  } */
  if(BBTP_line > TPdefault_line)
   {
      Comment("nBBTP must be less than TPdefault");
      return(1);
   }
  /*if(!IsTesting())
   if (Period() != Tframe) 
   {
      Comment("\n ERROR :: Invalid Timeframe, Please Switch to "+ IntegerToString(Tframe));
      return(0);
   } */
  if(TimeDaylightSavings()==0)
    {
      DST="No";
    }
   else _DSTtime=1;
   if(!IsTesting())
   {
     
       //Comment(StringConcatenate("\nLSMA02a is running.\nNext order lots: ",CalcularVolumen(),"\nTake profit ($): ",CalcularVolumen()*10*user_tp,"\nStop loss ($): ",CalcularVolumen()*10*user_sl,"\nSpread: ",_spread, "\nDST: ",DST));
         Comment(StringConcatenate("\n",progName," is running.\nNext order lots: ",CalcularVolumen(),
           
            "\nTake profit ($): ",CalcularVolumen()*10*user_tp,
            "\nStop loss ($): ",CalcularVolumen()*10*user_sl,
            "\nSpread: ",_spread, 
            "\nDST: ",DST,
            "\nMax Orders: ",maxOrders,
           // "\nDailyFilter ",DailyFilter,
            "\nNewsFilter: ",NewsFilter,
            "\nMins Before News: ",mBefore,
            "\nMins After News: ",mAfter));
          
  }
  // Actualizamos el estado actual
  InitBuy();
  InitSell();
  UpdateVars();
 
  
  encontrada=FALSE;
  
  
  point = Point;

  Robot();
  
  return(0);
}
void InitBuy()
{
  // Reset number of buy/sell orders
  buys=0;
  
  // Reset arrays
  for(int i=0; i<arrLgt; i++)
  {
    buy_tickets[i] = 0;
    buy_lots[i] = 0;
    buy_profit[i] = 0;
    buy_price[i] = 0;
    buy_sl[i]=0;
    buy_tp[i]=0;
    buy_magic[i]=0;
    
   
      
  }
}
void InitSell()
{
  // Reset number of buy/sell orders
 
  sells=0;
  // Reset arrays
  for(int i=0; i<arrLgt; i++)
  {
   
    sell_tickets[i] = 0;
    sell_lots[i] = 0;
    sell_profit[i] = 0;
    sell_price[i] = 0;
    sell_sl[i]=0;
    sell_tp[i]=0;
    sell_magic[i]=0;
      
  }
}
void UpdateVars()
{
  int aux_buys=0, aux_sells=0;
  double aux_total_buy_profit=0, aux_total_sell_profit=0;
  double aux_total_buy_lots=0, aux_total_sell_lots=0;
  buy_time=0;
  sell_time=0;
  datetime oTime;
  // We are going to introduce data from opened orders in arrays  
  for(int i=0; i<OrdersTotal(); i++)
  {
    if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES) == true)
     if(OrderSymbol() == Symbol() && (OrderMagicNumber() == newMagic1 ||OrderMagicNumber() == newMagic2)   )
      {
         if( OrderType() == OP_BUY)
         {
           buy_tickets[aux_buys] = OrderTicket();
           buy_lots[aux_buys] = OrderLots();
           buy_profit[aux_buys] = OrderProfit()+OrderCommission()+OrderSwap();
           buy_price[aux_buys] = OrderOpenPrice();
           buy_sl[aux_buys] = OrderStopLoss();
           buy_tp[aux_buys] = OrderTakeProfit();
           aux_total_buy_profit = aux_total_buy_profit + buy_profit[aux_buys];
           aux_total_buy_lots = aux_total_buy_lots + OrderLots();
           oTime =OrderOpenTime();
           buy_magic[aux_buys]=OrderMagicNumber();
           if(oTime > buy_time)
               buy_time = oTime;
           
            aux_buys++;
         }
        else if( OrderType() == OP_SELL)
         {
           sell_tickets[aux_sells] = OrderTicket();
           sell_lots[aux_sells] = OrderLots();
           sell_profit[aux_sells] = OrderProfit()+OrderCommission()+OrderSwap();
           sell_price[aux_sells] = OrderOpenPrice();
           sell_sl[aux_sells] = OrderStopLoss();
           sell_tp[aux_sells] = OrderTakeProfit();
           aux_total_sell_profit = aux_total_sell_profit + sell_profit[aux_sells];
           aux_total_sell_lots = aux_total_sell_lots + OrderLots();
            oTime =OrderOpenTime();
            sell_magic[aux_sells]=OrderMagicNumber();
            if(oTime > sell_time)
               sell_time = oTime;
           aux_sells++;
         }
    }
  }
  
  // Update global vars
  buys = aux_buys;
  sells = aux_sells;
  total_buy_profit = aux_total_buy_profit;
  total_sell_profit = aux_total_sell_profit;
  total_buy_lots = aux_total_buy_lots;
  total_sell_lots = aux_total_sell_lots;
}


 

Et c'est la suite

 // ------------------------------------------------------------------------------------------------
// INICIALIZAR VARIABLES
// ------------------------------------------------------------------------------------------------


// ------------------------------------------------------------------------------------------------
// ACTUALIZAR ORDENES
// ------------------------------------------------------------------------------------------------

// ------------------------------------------------------------------------------------------------
// CALCULAR VOLUMEN
// ------------------------------------------------------------------------------------------------
double CalcularVolumen()
{ 
   double aux= 0 ; 
   int n;
  
   if (money_management== 0 )
  {
    aux=min_lots;
  }
   else
  {    
     if (progression== 0 ) 
    { 
      aux = risk* AccountFreeMargin ();
      aux= aux/ 100000 ;
      n = ( int ) MathFloor (aux/min_lots);
      
      aux = n*min_lots;                   
    }  
  
     if (progression== 1 )
    {
       if (last_order_profit< 0 )
      {
        aux = last_order_lots+min_lots;
      }
       else 
      {
        aux = last_order_lots-min_lots;
      }  
    }        
    
     if (progression== 2 )
    {
       if (last_order_profit< 0 )
      {
        aux = last_order_lots* 2 ;
      }
       else 
      {
         aux = risk* AccountFreeMargin ();
         aux= aux/ 100000 ;
         n = ( int ) MathFloor (aux/min_lots);
         
         aux = n*min_lots;         
      }  
    }     
    
     if (aux<min_lots)
        aux=min_lots;
     
     if (aux> MarketInfo ( Symbol (), MODE_MAXLOT ))
      aux= MarketInfo ( Symbol (), MODE_MAXLOT );
      
     if (aux< MarketInfo ( Symbol (), MODE_MINLOT ))
      aux= MarketInfo ( Symbol (), MODE_MINLOT );
  }
  
   return (aux);
}

// ------------------------------------------------------------------------------------------------
// CALCULA VALOR PIP
// ------------------------------------------------------------------------------------------------
double CalculaValorPip( double lotes)
{ 
   double aux_mm_valor= 0 ;
   
   double aux_mm_tick_value = MarketInfo ( Symbol (), MODE_TICKVALUE );
   double aux_mm_tick_size = MarketInfo ( Symbol (), MODE_TICKSIZE );
   int aux_mm_digits = ( int ) Digits ;   
   double aux_mm_veces_lots = 1 /lotes;
      
   if (aux_mm_digits== 5 )
   {
     aux_mm_valor=aux_mm_tick_value* 10 ;
   }
   else if (aux_mm_digits== 4 )
   {
     aux_mm_valor = aux_mm_tick_value;
   }
   
   if (aux_mm_digits== 3 )
   {
     aux_mm_valor=aux_mm_tick_value* 10 ;
   }
   else if (aux_mm_digits== 2 )
   {
     aux_mm_valor = aux_mm_tick_value;
   }
   
   aux_mm_valor = aux_mm_valor/aux_mm_veces_lots;
   
   return (aux_mm_valor);
}


// ------------------------------------------------------------------------------------------------
// CALCULA SIGNAL
// ------------------------------------------------------------------------------------------------


int CalculaSignal()
{
   int aux= 0 ;
 
   if ( MathAbs ( Bid - Ask )/PT > max_spread)
       return (aux);
   double v1 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 0 , 1 );
   double v2 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 0 , 2 );
   double v3 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 0 , 3 );
   double v4 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 0 , 4 );
   double b1 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 1 , 1 );
   double b2 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 1 , 2 );
  
      
   
   double bb;
   int stCount= 0 ;
  
  
   if (v2 > Entry_line && v2 > b2 && v1 < b1)
   {
      stCount= 2 ;
   
   }
   else if (v3 > Entry_line && (  v2 > b2 && v1 < b1) )
      {
      stCount= 3 ;
      
    }
 
   else if (v4 > Entry_line && (  v2 > b2 && v1 < b1) )
      stCount= 4 ;  
   if (stCount > 0 )
  {
     
         
               aux= 2 ;
              
               bb = iCustom ( NULL , 0 , "vertex_mod_3.01" , 2 ,stCount);
               if (bb > BBvalue1)
                  curMagic=newMagic2;
               else
                  curMagic=newMagic1;
               
            
      
  }
   else
  {
     
     if (v2 < Entry_line*(- 1 ) &&  v2 < b2 && v1 > b1)
       {
         stCount= 2 ;
         
       }
     else if (v3 < Entry_line*(- 1 ) &&  v2 < b2 && v1 > b1)
       {
         stCount= 3 ;
       }
     else if (v4 < Entry_line*(- 1 ) &&  v2 < b2 && v1 > b1)
         stCount= 4 ; 
         
         
     if (stCount > 0 )
      {
             
                  
              aux= 1 ;
              
               bb = iCustom ( NULL , 0 , "vertex_mod_3.01" , 3 ,stCount);
               if (bb < BBvalue1 *(- 1 ))
                  curMagic=newMagic2;
               else
                  curMagic=newMagic1;
           
                 
         
       }
   }
    
   
     
   
   return (aux);  
}

// ------------------------------------------------------------------------------------------------
// ROBOT
// ------------------------------------------------------------------------------------------------

void Robot()
{
   int ticket=- 1 ;
   int signal= 0 ;
   double newSL= 0 ;
   double newTP= 0 ;
   int tpvalue;
   double v1,v2;
   bool clOrder= false ;
   bool setTrail= false ;
 
   int i;
  

 
 
             if (NoNews || NewsFilter== False )
            {
                   ObjectDelete ( "NFP" );
                  
                  signal = CalculaSignal();
             }
             else
            {
                     ObjectCreate ( "NFP" , OBJ_LABEL , 0 , 0 , 0 , 0 , 0 );      
                     ObjectSet ( "NFP" , OBJPROP_CORNER , 2 );      
                     ObjectSet ( "NFP" , OBJPROP_YDISTANCE , 45 );      
                     ObjectSet ( "NFP" , OBJPROP_XDISTANCE , 10 );      
                     ObjectSetText ( "NFP" , "NO trade News time" , 20 , "Tahoma" , Red); 
            }
    
   
     if (signal== 1 && buys < maxOrders)
          
    {
           
           if (user_tp > 0 )
               newTP = NormalizeDouble ( Ask + user_tp*PT, Digits );
          
             SL = NormalizeDouble ( Ask - (user_sl*PT), Digits );
             ticket = OrderSend ( Symbol (), OP_BUY ,CalcularVolumen(), Ask ,slippage,SL,newTP,key,curMagic, 0 ,Blue);
       
    }
    
     if (signal== 2 && sells < maxOrders)
      {
             
         
           if (user_tp> 0 )
             newTP = NormalizeDouble ( Bid - user_tp*PT, Digits );
          
            SL = NormalizeDouble ( Bid + (user_sl*PT), Digits );
            ticket = OrderSend ( Symbol (), OP_SELL ,CalcularVolumen(), Bid ,slippage,SL,newTP,key,curMagic, 0 ,Red);
       
               
      
      } 
      
      
      v2 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 0 , 1 );
       if (buys > 0   )
      {
         if (v2 > Entry_line )
         {
            CloseOrder( OP_BUY );
         }
         else
          {
             if (UseTrailing == 2 || UseTrailing== 0 )
             {
                v1 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 3 , 1 );
                 if (v1 > (- 1 )*TPdefault_line/ 10 || v1 > (- 1 )*BBTP_line/ 10 )
                 {
                     setTrail= false ;
                     for (i= 0 ;i<buys;i++)
                      {
                        clOrder= false ;
                        tpvalue = StringToInteger ( StringSubstr (buy_magic[i], 0 , 2 ));
                         if (tpvalue == BBTP_line && v1 > (- 1 )* BBTP_line/ 10 )
                           clOrder= true ;
                         else if (tpvalue == TPdefault_line && v1 > (- 1 )* TPdefault_line/ 10 )
                            clOrder= true ;
                            
                         if (clOrder)
                         {
                           if (UseTrailing== 0 )
                           ticket = OrderClose (buy_tickets[i],buy_lots[i], Bid ,user_slippage, clrBlue );
                           else
                           {
                              trailProc( OP_BUY ,i);
                           }
                         }
                       }
                 }
             }      
               if (UseTrailing== 1 )
               {
                   for ( i= 0 ; i< buys; i++)
                  {
                    trailProc( OP_BUY ,i);
                  }
                  
               }
          }
      }
     else if (sells > 0 )
     {
   
         if (v2 < Entry_line*(- 1 ))
         {
            CloseOrder( OP_SELL );
         }
       else
       {
           
           if (UseTrailing == 2 || UseTrailing== 0 )
            {  
             v1 = iCustom ( NULL , 0 , "vertex_mod_3.01" , 2 , 1 );
                 if (v1 < TPdefault_line/ 10 || v1 < BBTP_line/ 10 )
                 {
                     setTrail= false ;
                     for (i= 0 ;i<sells;i++)
                      {
                        clOrder= false ;
                        tpvalue = StringToInteger ( StringSubstr (sell_magic[i], 0 , 2 ));
                         if (tpvalue == BBTP_line && v1 < BBTP_line/ 10 )
                           clOrder= true ;
                         else if (tpvalue == TPdefault_line && v1 < TPdefault_line/ 10 )
                            clOrder= true ;
                            
                         if (clOrder)
                        {
                           if (UseTrailing== 0 )
                           ticket = OrderClose (sell_tickets[i],sell_lots[i], Bid ,user_slippage, clrRed );
                           else
                          {
                              trailProc( OP_SELL ,i);
                          
                          }
                        
                       }
                      }
                } 
             }
               if (UseTrailing == 1 ) 
              { 
                   for ( i= 0 ; i< sells; i++)
                  {
                    trailProc( OP_SELL ,i);
                  }
              }
         }
      }
            
        
             
        
  }
  
   void trailProc( int _type, int i)
  {
   double newSL= 0 ;
   int ticket;
   if (_type == OP_BUY )
    {
                   newSL= 0 ;
                     if ( Bid - buy_price[i] > TrailStartPips*PT)
                    {
                     if ( Bid - buy_sl[i] > (Trailpips + TrailStepPips)*PT && buy_sl[i] > buy_price[i])
                      {
                        newSL = NormalizeDouble ( Bid - Trailpips*PT, Digits );
                      }
                     else if (buy_sl[i] < buy_price[i])
                      {
                        newSL = NormalizeDouble ( Bid - Trailpips*PT, Digits );
                      }
                      
                       if (newSL > 0 && newSL > buy_sl[i])
                        ticket = OrderModify (buy_tickets[i],buy_price[i],newSL,buy_tp[i], 0 , clrBlue );
                   }
    }
   else
    {
                  newSL= 0 ;
                     if ( sell_price[i] - Ask > TrailStartPips*PT)
                    {
                     if ( sell_sl[i] - Ask > (Trailpips + TrailStepPips)*PT && sell_sl[i] > sell_price[i])
                      {
                        newSL = NormalizeDouble ( Ask + Trailpips*PT, Digits );
                      }
                     else if (sell_sl[i] < sell_price[i])
                      {
                        newSL = NormalizeDouble ( Ask + Trailpips*PT, Digits );
                      }
                      
                       if (newSL > 0 && newSL < sell_sl[i])
                        ticket = OrderModify (sell_tickets[i],sell_price[i],newSL,sell_tp[i], 0 , clrBlue );
                    }
    
    
    } 
  
  }
   void CloseOrder( int _type)
  {
     int resp;
     int i;
       if (_type== OP_BUY )
      {
         for ( i= 0 ; i< buys; i++)
         {
         
            resp= OrderClose (buy_tickets[i],buy_lots[i], Bid , 2 , clrBlue );
         }
         InitBuy();
         
      }
     else    if (_type== OP_SELL )
      {
         for ( i= 0 ; i< sells; i++)
         {
         
            resp= OrderClose (sell_tickets[i],sell_lots[i], Ask , 2 , clrRed );
         }
         InitSell();
         
      }           
  }
  
  
 
MECMAN:

Et voici la suite

Veuillez joindre le fichier mq4 - de cette façon, les utilisateurs ne peuvent pas le tester facilement et ils ne peuvent pas vous aider.
 

HEY MLADEN

Je suis nouveau sur ce site, et je peux voir votre bon travail, continuez comme ça mon frère. Cependant, j'aimerais que vous puissiez m'aider à coder un indicateur pour en faire un EA.

Tout ce dont j'ai besoin est que l'EA achète ou vende lorsque le signal apparaît.

L'idée est d'aller sur un timeframe plus élevé, 4hrs tf et trouver la tendance du marché (juste pour connaître la tendance) et trader sur un tf plus bas (15-5mins). Donc si c'est court, nous ne le faisons que jusqu'au changement de tendance de l'image temporelle supérieure.

Merci d'avance.

 
mladen:
Veuillez joindre le fichier mq4 - de cette façon, les utilisateurs ne peuvent pas le tester facilement et ne peuvent pas vous aider.
Uploaded , s'il vous plaît quelqu'un peut-il regarder dans ce code pour savoir pourquoi il ne peut pas back test, les résultats peuvent ne pas être rentables mais je serai reconnaissant.
Dossiers :
VPro3.mq4  21 kb
 
MECMAN:
Uploaded , s'il vous plaît quelqu'un peut regarder dans ce code pour savoir pourquoi il ne peut pas back test, les résultats peuvent ne pas être rentable, mais je serai reconnaissant.

Cela fonctionne (tant que vous avez l'indicateur "vertex_mod_3.01" dans le dossier indicateurs).