ForoSecciones

Ayuda a la codificación - página 693

Nuevo comentario
mladen:

Ray

Pruébalo ahora

Mladen

Todavía no hay cambios. ¿Podemos probar de nuevo?

Esto es todo lo que hice para el 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;


Gracias

Rayo

traderduke:

Mladen

Todavía no hay cambios. ¿Podemos probar de nuevo?

Esto es todo lo que hice para el 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;


Gracias

Rayo

Esto es lo que obtengo cuando pruebo el modo multi time frame (el indicador del post anterior)


Por lo que veo, todo funciona como se supone que debe funcionar

mladen:

Esto es lo que obtengo cuando pruebo el modo multi time frame (el indicador del post anterior)

ATENCIÓN: El vídeo debe volver a cargarse

ATENCIÓN: El vídeo debe ser recargado
Por lo que veo, todo funciona como se supone que debe funcionar

Mladen

Me disculpo por no presentar mi problema con claridad. Tienes razón en que el diff_Levelms 0.0 funciona correctamente, pero la adición de diff_Levelms fue para permitir que los cambios menores, como los rangos, sean descartados como .0002 para el EURUSD o .02 para el USDJPY. Aparentemente mi cálculo de diff no está siendo utilizado por el cálculo de trend1

double diffums = (ma2[i]-ma3[i]); //med-slow Aparentemente mi cálculo
double diffdms = (ma3[i]-ma2[i]); /slow- med Aparentemente mi cálculo

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; no se utiliza para el cálculo de trend1
si (ma2[i]<ma3[i] && diffdms > diff_Levelms) trendms[i] =-1; no se utiliza en el cálculo de trend1


Gracias

ray


El indicador no se actualiza


He descargado el indicador "Outsidebar Trendline V2" adjunto, pero por alguna razón no se actualiza en

la siguiente barra/candela. Al cambiar de marco temporal funciona bien, pero en la siguiente barra en ese marco temporal ya no.

¿Podría algún experto de ustedes ayudar para que el indicador se actualice también en las siguientes barras?

Muchas gracias

Lea

Archivos adjuntos:
OutsideBar TrendLine v2.mq4  28 kb
[Eliminado]

mladen,

Mi amigo escribió este EA basado en el indicador de vértice, no hemos sido capaces de ejecutar un backtest después de que lo creó. Por favor puedes ayudarme a arreglar el error que impide que sea capaz de backrest. pero requiere mucha actualización una vez que se limpia

Gracias y humildemente apreciado

// ------------------------------------------------------------------------------------------------
// ------------------------------------------------------------------------------------------------
#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;
}
[Eliminado]

y esta es la continuacion

 // ------------------------------------------------------------------------------------------------
// 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:

Y esta es la continuación

Por favor, adjunte el archivo mq4 - de esta manera los usuarios no pueden probarlo fácilmente y luego no pueden ayudarle
[Eliminado]

HEY MLADEN

Soy nuevo en este sitio web, y puedo ver sus buenos trabajos, sigue así hermano. Sin embargo, me gustaría que me pueda ayudar con un poco de codificación en la conversión de un indicador en un EA.

Todo lo que realmente necesito es que el EA para comprar o vender cuando aparece la señal.

La idea es ir a un marco de tiempo más alto, 4 horas tf y encontrar la tendencia del mercado (sólo para conocer la tendencia) y el comercio en tf inferior (15-5mins). Así que si es corto, sólo corto hasta el cambio de tendencia el marco de tiempo más alto.

Gracias por adelantado.

[Eliminado]
mladen:
Por favor, adjunte el archivo mq4 - de esta manera los usuarios no pueden probarlo fácilmente y luego no pueden ayudarle
Subido, por favor, ¿puede alguien mirar en este código para saber por qué no puede volver a la prueba, los resultados no pueden ser rentables, pero voy a estar agradecido
Archivos adjuntos:
VPro3.mq4  21 kb
MECMAN:
Subido, por favor, puede alguien mirar en este código para saber por qué no puede volver a la prueba, los resultados pueden no ser rentables, pero voy a estar agradecido

Funciona (siempre y cuando tenga el indicador "vertex_mod_3.01" en la carpeta de indicadores)


1...686687688689690691692693694695696697698699700...786
Nuevo comentario