Ea está creando múltiples órdenes pendientes/limitadas [Ayuda] - página 4

Nuevo comentario
 
cashcube:

Además, la operación inversa en órdenes detenidas tampoco funciona.

Ya te han dicho que esto no es fiable

            if(Volume[0]>1) return(0);

Esto no hace nada

//+------------------------------------------------------------------+
//| OnTick function                                                  |
//+------------------------------------------------------------------+
void OnTick(){
   static datetime timeCur; datetime timePre = timeCur; timeCur=Time[0];
   bool isNewBar = timeCur != timePre;
   if(isNewBar){ 
     return; // Once per bar
   }
   return; // every tick
}  

Devuelve si es una barra nueva y también devuelve si no lo es, por lo que siempre devuelve sin hacer nada.

Cuando encuentras una nueva barra, tienes que restablecer el valor.

void OnTick(){
   datetime timeCur=Time[0]; 
   static datetime timePre = timeCur;
   bool isNewBar = timeCur != timePre;
   if(isNewBar){ 
     timePre=timeCur;
     //Do what you want at each new bar // Once per bar
   }
   //Do other stuff that you may need to do every tick
   return; // every tick
}  

Tu código para comprobar la última orden asume que el índice más alto del historial de órdenes es el de las últimas operaciones cerradas. No estoy seguro de que esto sea siempre cierto.

 

Ok he aplicado el código...pero cuando trato de llamar a la función de inicio en cada nueva barra...su no tomar cualquier orden...

void OnTick(){
   datetime timeCur=Time[0]; 
   static datetime timePre = timeCur;
   bool isNewBar = timeCur != timePre;
   if(isNewBar){ 
     timePre=timeCur;
     //Do what you want at each new bar // Once per bar
start();
   }
   //Do other stuff that you may need to do every tick
   return; // every tick
}  

Incluso si agrego buyCall & sellcall función dentro de la zona de la nueva barra...y start() dentro de la zona de garrapatas...su creación de múltiples órdenes.

 
No deberías tener OnTick() y start(), no puedo adivinar lo que hará.
 
Aquí está el código completo para la EA.
// Init function
int init()
{

int CalcDigits = (int)MarketInfo(Symbol(),MODE_DIGITS);

if(CalcDigits == 2 || CalcDigits == 4) CalcSlippage = SlippagePips;
else if(CalcDigits == 3 || CalcDigits == 5) CalcSlippage = SlippagePips * 10;      


if(CalcDigits == 2 || CalcDigits == 3) CalcPoint1 = 0.01;
else if(CalcDigits == 4 || CalcDigits == 5) CalcPoint1 = 0.0001;
      
UsePoint = CalcPoint;
UseSlippage = (int) CalcSlippage; 
return (0);
}
//+------------------------------------------------------------------+

int start()
{

double open = iOpen(NULL,PERIOD_H1,0);        // current candles Open
int CH = TimeHour(TimeCurrent()); // current hour    
double LO = iOpen(NULL,PERIOD_H1,1);
double LC = iClose(NULL,PERIOD_H1,1);
  
//----------------------------  Calculation
double CalcDigits = MarketInfo(Symbol(),MODE_DIGITS);
      {
      if(CalcDigits == 2 || CalcDigits == 3) CalcPoint = 100;
      else if (CalcDigits == 4 || CalcDigits == 5) CalcPoint = 10000;
      }
           
///----------------------------------------------

FS = Split(open);

//-------- 2nd part of Calculation----------------//

S0 = open - (double(FS)* CalcPoint1);
S1 = open - (double((FS*2))* CalcPoint1);
S2 = open - (double((FS*4))* CalcPoint1);
S3 = open - (double((FS*8))* CalcPoint1); 
S4 = open - (double((FS*16))* CalcPoint1);
S5 = open - (double((FS*32))* CalcPoint1);
 
R0 = open + (double(FS)* CalcPoint1);
R1 = open + (double((FS*2))* CalcPoint1);
R2 = open + (double((FS*4))* CalcPoint1);
R3 = open + (double((FS*8))* CalcPoint1); 
R4 = open + (double((FS*16))* CalcPoint1); 
R5 = open + (double((FS*32))* CalcPoint1);  


//---------2nd part-------------------//
   P1 = Split(S0);
   P2 = Split(S1);
   P3 = Split(S2);
   P4 = Split(S3);
   P5 = Split(S4);
   P6 = Split(S5);
   P7 = Split(R0);
   P8 = Split(R1);
   P9 = Split(R2);
   P10 = Split(R3);
   P11 = Split(R4);
   P12 = Split(R5);

 //--------------------
   if(FS == P1 && LC > LO)  BuyCall(S0);
   if(FS == P2 && LC > LO)  BuyCall(S1);
   if(FS == P3 && LC > LO)  BuyCall(S2);
   if( FS == P4 && LC > LO) BuyCall(S3);   
   if( FS == P5 && LC > LO) BuyCall(S4);
   if( FS == P6 && LC > LO) BuyCall(S5);
   if( FS == P7 && LC < LO) SellCall(R0);
   if( FS == P8 && LC < LO) SellCall(R1);
   if( FS == P9 && LC < LO) SellCall(R2);
   if( FS == P10 && LC < LO) SellCall(R3);
   if( FS == P11 && LC < LO) SellCall(R4);                    
   if( FS == P12 && LC < LO) SellCall(R5);     
 
   //-----------------End of experiment----------

//-------------------Reverse trade for Sell
     for(xxx =OrdersHistoryTotal()-1;xxx >=0;xxx --)
     {
         if(OrderSelect(xxx, SELECT_BY_POS,MODE_HISTORY))
         {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()== MagicNumber)
          
          //for sell order reverse
          if(OrderType()==OP_SELL && OrderProfit()<0)    
          { 
             if (OrderOpenPrice()== R0 || OrderOpenPrice()== R1 ||OrderOpenPrice()== R2 ||OrderOpenPrice()== R3 ||OrderOpenPrice()== R4 ||OrderOpenPrice()== R5 )
               {
      
            BuyStopLoss = Ask - (StopLoss * CalcPoint1);
            BuyTakeProfit = Ask + (TakeProfit * CalcPoint1);
            BuyTicket = OrderSend(Symbol(),OP_BUY,LotSize,Ask,UseSlippage,BuyStopLoss,BuyTakeProfit,"Buy Reverse Order",MagicNumber,0,Green);
          }
          break; 
          }
          }
          } 
   
  //-------------Reverse trade for buy
     for(xx =OrdersHistoryTotal()-1;xx >=0;xx --)
     {
         if(OrderSelect(xx, SELECT_BY_POS,MODE_HISTORY))
         {
         if(OrderSymbol()==Symbol() && OrderMagicNumber()== MagicNumber)
           {
          //for buy order reverse
          if(OrderType()==OP_BUY && OrderProfit()<0)
          { 
           if (OrderOpenPrice()== S0 || OrderOpenPrice()== S1 ||OrderOpenPrice()== S2 ||OrderOpenPrice()== S3 ||OrderOpenPrice()== S4 ||OrderOpenPrice()== S5 )
               {         
    
            SellStopLoss = Bid + (StopLoss * CalcPoint1);
            SellTakeProfit = Bid - (TakeProfit * CalcPoint1);
            SellTicket = OrderSend(Symbol(),OP_SELL,LotSize,Bid,UseSlippage,SellStopLoss,SellTakeProfit,"Sell Reverse Order",MagicNumber,0,Red); 
          
          }
         break; 
          }
          }
          }
     } 

//------WHODER CODE for Order Close/Delete in every hour -------

for(int pos = OrdersTotal()-1; pos >= 0 ; pos--) 
if (OrderSelect(pos, SELECT_BY_POS)  &&  OrderMagicNumber() == MagicNumber &&  OrderSymbol() == Symbol() )
{   
     if(OrderType()==OP_SELL && OrderMagicNumber() == MagicNumber &&  OrderSymbol() == Symbol())
     {
     int k = (TimeHour((int)OrderOpenTime())*60) + TimeMinute((int)OrderOpenTime()); 
     int m = (TimeHour((int)TimeCurrent())*60) +  TimeMinute((int)TimeCurrent());    
     if (m >= k+59)
      bool closed = OrderClose( OrderTicket(), OrderLots(), OrderClosePrice(),UseSlippage,Blue);
     }
     //--------------
      if(OrderType()==OP_BUY && OrderMagicNumber() == MagicNumber &&  OrderSymbol() == Symbol())
     {
     int k1 = (TimeHour((int)OrderOpenTime())*60) + TimeMinute((int)OrderOpenTime()); 
    int m1 = (TimeHour((int)TimeCurrent())*60) +  TimeMinute((int)TimeCurrent());    
     if (m1 >= k1+59)
     bool closed = OrderClose( OrderTicket(), OrderLots(), OrderClosePrice(),UseSlippage,Blue);
    }        
}   

   
return(0);
}

Junto con esta función de inicio...tengo la siguiente función extra..que es llamada en la función principal.

int split(double x)

void BuyCall(double BC)

void SellCall(double SC)

y por ultimo la funcion void onTick sobre la cual estoy confundido...como establecerla de una manera..que no repita las ordenes pendientes tick por tick

...solo una secuencia de ordenes pendientes en cada hora...ademas comprobara si alguna orden pendiente se detiene

... entonces se abrirá otro comercio en la dirección opuesta ... pero sólo una secuencia por hora.

Por favor, ayúdame, estoy atascado en la misma área una y otra vez... pero obviamente quiero aprender... para no tener que hacer preguntas tontas en el futuro.

...quiero aclarar mi concepto..:(

Gracias por su tiempo.

 
Esto no asigna un valor cada vez que se produce un tic, sólo una vez al cargar.
static datetime timePre = timeCur;
simplificar
void OnTick(){
   static datetime timeCur;
   datetime timePre = timeCur; timeCur=Time[0]; 
   bool isNewBar = timeCur != timePre;
1234
Nuevo comentario