Problema con la cantidad total de órdenes abiertas - página 4

Nuevo comentario
 

Hola a todos

Lo siento, pero he hablado demasiado pronto. Aunque añadir RefreshRates() parece marcar la diferencia, sigo teniendo el mismo problema. A veces abre las dos órdenes pendientes, a veces sólo una de las dos, y a veces ninguna. Sigo recibiendo el error 130 cuando no abre una orden, o las dos, pero no hay errores cuando se abren las dos. También me he dado cuenta de que en aquellos pares en los que mis entradas están por debajo de MODE_STOPLEVEL, nunca abre una orden y siempre tengo el error 130, a pesar de que el programa ajusta mis entradas como se solicita. Estoy imprimiendo los valores y se ajustan como se espera. Así que estoy tratando de averiguar por qué mi OrderSend no funciona realmente.

En un par como el EURUSD, donde el nivel de parada es 5, suele enviar ambas órdenes, pero no siempre, pero en un par como el EURAUD, donde el nivel de parada es 10, nunca envía una orden.

extern int TrailingStart=20;
extern int TrailingStop=5;

extern int Hedge=10;
extern double Multiplier=3;

extern int StopLossOriginal=11;

extern int StopLossHedge=9;

extern double Percentage=1;
extern double Lotsize=0.01;
extern double MyMaxlots=30;

extern datetime StartTime1 = D'2016.03.25 16:50';

extern int Pipmove=5;
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int init()
//---
  {
   int TS=TrailingStart-TrailingStop;
   double stoplevel=(MarketInfo(Symbol(),MODE_STOPLEVEL))/10;
   if(StopLossOriginal<stoplevel || StopLossHedge<stoplevel || TS<stoplevel)
     {
      MessageBox("Please note: Your inputs for StopLossOriginal, StopLossHedge and/or"+
                 "\nTrailingStop are below the minimum levels required by your broker,"+
                 "\nand have been increased automatically to "+StringConcatenate(stoplevel)+" Pips");
     }
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int deinit()
  {
   return(0);
  }
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
int start()
  {
   int TS=TrailingStart-TrailingStop;
   Print("TS = ",TS);
   int sloss=StopLossOriginal-Pipmove;
   int stoplevel=(MarketInfo(Symbol(),MODE_STOPLEVEL))/10;
   Print("stoplevel = ",stoplevel);
     
   double Lots = NormalizeDouble(AccountEquity()*Percentage*Lotsize/100, 2),
          point=Point*10,
          Price=Pipmove*point,
          SL=(StopLossOriginal-Pipmove)*point,
          MinLots = MarketInfo(Symbol(),MODE_MINLOT),
          MaxLots = MarketInfo(Symbol(),MODE_MAXLOT),
          HedgeLots=NormalizeDouble(OrderLots()*Multiplier,2);
          
   if(sloss<=stoplevel) SL=stoplevel*point;
   Print("SL = ",SL);
   if(StopLossHedge<=stoplevel) StopLossHedge=stoplevel;
   Print("StopLossHedge = ",StopLossHedge);
   if(TS<=stoplevel) TrailingStart=(stoplevel+TrailingStop); 
   Print("TrailingStart = ",TrailingStart);     
          
   datetime time1=StartTime1-3300;      

   if(Lots>MaxLots) Lots=MaxLots;
   if(Lots<MinLots) Lots=MinLots;
   if(HedgeLots>MaxLots) HedgeLots=MaxLots;
   if(Lots>MaxLots || Lots<MinLots || HedgeLots>MaxLots)
     {
      MessageBox("Lotsize have been adjusted automatically");
     }

   int buy_ticket=0, sell_ticket=0, buystop_ticket=0, sellstop_ticket=0, total=0;
   for(int i= OrdersTotal()-1; i>= 0; i--)
      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber()==magic && OrderSymbol()==Symbol())
        {
         total++;
         if(OrderType()==OP_BUYSTOP) buystop_ticket=OrderTicket();
         if(OrderType()==OP_SELLSTOP) sellstop_ticket=OrderTicket();
         if(OrderType()==OP_BUY) buy_ticket=OrderTicket();
         if(OrderType()==OP_SELL) sell_ticket=OrderTicket();
        }

   if(total==0 && Time[0]==time1)
     {
      buy_ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+Price,30,0,0,"Pending",magic,0,Lime);
      OrderModify(OrderTicket(),OrderOpenPrice(),Ask-SL,OrderTakeProfit(),Yellow);
      Print("Buystop = ",GetLastError());
      Sleep(1000);
      RefreshRates();
      Sleep(1000);
      sell_ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-Price,30,0,0,"Pending",magic,0,Red);
      OrderModify(OrderTicket(),OrderOpenPrice(),Bid+SL,OrderTakeProfit(),Yellow);
      Print("Sellstop = ",GetLastError());
     }

También lo he probado así, pero no hay diferencia:

buy_ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+Price,30,Ask-SL,0,"Pending",magic,0,Lime);
      RefreshRates();
sell_ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-Price,30,Bid+SL,0,"Pending",magic,0,Red);

Y aunque haga esto no hay diferencia:

if(total==0) // && (Time[0]==time1)
 

Gracias por toda la ayuda a todos. Finalmente conseguí que funcionara. La única forma en que pude conseguir que funcionara de forma consistente fue cambiándolo por esto:

 if(total==0)
     {
      buystop_ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+Price,30,Ask-SL,0,"Pending",magic,0,Lime);
      Print("buystop = ",GetLastError());
      RefreshRates();
     }
   if(total==1)
     {
      sellstop_ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-Price,30,Bid+SL,0,"Pending",magic,0,Red);
      Print("sellstop = ",GetLastError());
     }

También descubrí que el nivel de Pipmove antes de que se active la orden pendiente también debe ser mayor que stoplevel. Así que todo parece funcionar ahora... Gracias

 
Trader3000:

Gracias por toda la ayuda a todos. Finalmente conseguí que funcionara. La única forma en que pude conseguir que funcionara de forma consistente fue cambiándolo por esto:

También descubrí que el nivel de Pipmove antes de que se active la orden pendiente también debe ser mayor que stoplevel. Así que todo parece funcionar ahora... Gracias

Nope esto tampoco funciona porque ahora continuará abriendo un sell_stop mientras haya una operación abierta
 
La respuesta sencilla es no intentar abrir órdenes pendientes tan cerca del precio actual. 5 Puntos es normalmente medio pip
 
GumRai:
La respuesta sencilla es no intentar abrir órdenes pendientes tan cerca del precio actual. 5 Puntos es normalmente medio pip

Gracias por la respuesta. Mi cálculo es en realidad en pips, por lo que las órdenes pendientes están al menos a 50 puntos (5 pips de distancia del precio actual), sin embargo, parece que funciona si lo muevo al menos 1 pip más lejos del stoplevel, que es de 50 puntos en el EURUSD. Parece que ahora abre ambas operaciones excepto la primera después de arrastrarla al gráfico. Pero estoy bien con esto por ahora. Mi código ahora se ve así:

extern int TrailingStart=20;
extern int TrailingStop=5;
extern int Hedge=10;
extern double Multiplier=3;
extern int StopLossOriginal=11;
extern int StopLossHedge=9;
extern double Percentage=1;
extern double Lotsize=0.01;
extern double MyMaxlots=30;
extern datetime StartTime1 = D'2016.03.25 14:50';
extern int Pipmove=5;
int i,TS=TrailingStart-TrailingStop,stoplevel=(MarketInfo(Symbol(),MODE_STOPLEVEL))/10; //stoplevel has been converted from points to pips (/10)

int start()
  {
   double Lots = NormalizeDouble(AccountEquity()*Percentage*Lotsize/100, 2),
          point=Point*10,
          Price=Pipmove*point,
          SL=StopLossOriginal*point,
          MinLots = MarketInfo(Symbol(),MODE_MINLOT),
          MaxLots = MarketInfo(Symbol(),MODE_MAXLOT),
          HedgeLots=NormalizeDouble(OrderLots()*Multiplier,2);

   if(StopLossHedge<stoplevel) StopLossHedge=stoplevel;
   if(TS<stoplevel) TrailingStart=(stoplevel+TrailingStop);
   if(Pipmove<stoplevel+1) Pipmove=stoplevel+1;
   if(StopLossOriginal<=StopLossHedge) StopLossOriginal=StopLossHedge+1;

   datetime time1=StartTime1-300;

   int buy_ticket=0,sell_ticket=0,buystop_ticket=0,sellstop_ticket=0,total=0;
   for(i=OrdersTotal()-1; i>=0; i--)
      if(OrderSelect(i,SELECT_BY_POS) && OrderMagicNumber()==magic && OrderSymbol()==Symbol())
        {
         total++;
         if(OrderType()==OP_BUYSTOP) buystop_ticket=OrderTicket();
         if(OrderType()==OP_SELLSTOP) sellstop_ticket=OrderTicket();
         if(OrderType()==OP_BUY) buy_ticket=OrderTicket();
         if(OrderType()==OP_SELL) sell_ticket=OrderTicket();
        }

   if(total<1 && Time[0]==time1)
     {
      buystop_ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+Price,30,Ask-SL,0,"Pending",magic,0,Lime);
      RefreshRates();
      sellstop_ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-Price,30,Bid+SL,0,"Pending",magic,0,Red);
     }

Me encontré con un problema separado pero similar. Una vez que una de las órdenes pendientes se activa, una de dos cosas podría suceder. O bien activa el TrailingStop en cuyo momento la otra orden pendiente se elimina. o si ese comercio va en contra de mí debe abrir una cobertura en la dirección opuesta. Dependiendo de cómo escribo el código, se abrirá más de una cobertura o ninguna cobertura en absoluto. He intentado todo incluyendo los dos siguientes:

if(OrderSelect(buy_ticket,SELECT_BY_TICKET) && OrderType()==OP_BUY)
     {
      if(Bid-OrderOpenPrice()>TrailingStart*point)
        {
         if(OrderStopLoss()<Bid-TrailingStop*point)
           {
            if(OrderModify(OrderTicket(),OrderOpenPrice(),Bid-TrailingStop*point,OrderTakeProfit(),Blue))
              {
               if(OrderSelect(sellstop_ticket,SELECT_BY_TICKET) && OrderType()==OP_SELLSTOP)
                 {
                  if(OrderDelete(sellstop_ticket,Orange))
                     return(0);
                 }
              }
           }
        }
      if(OrderOpenPrice()>Bid+Hedge*point && buy_ticket==1 && sell_ticket<=1)
            {
              sell_ticket=OrderSend(Symbol(),OP_SELL,HedgeLots,Bid,3,Bid+StopLossHedge*point,0,"Hedge",magic,0,Red);
            }  
        }
//Same for Sell

O:


//Same up to here:
else if(total<=2 && OrderOpenPrice()>Bid+Hedge*point)
        {
         sell_ticket=OrderSend(Symbol(),OP_SELL,HedgeLots,Bid,3,Bid+StopLossHedge*point,0,"Hedge",magic,0,Red);
        }

¿Debo utilizar un bucle for separado para esto? Gracias

 

Hola a todos

Llevo semanas intentándolo y todavía no he hecho ningún progreso. Todo funciona ahora, excepto que bajo ciertas condiciones el EA abre más de una operación de cobertura sobre la operación original. El SL de la operación original es de 11 pips y el SL de la operación de cobertura es de 9 pips. A veces la operación de cobertura se detiene en 9 pips mientras la operación original sigue abierta. Entonces abrirá una segunda operación de cobertura e incluso una tercera y cuarta mientras la operación original sigue abierta. Simplemente quiero limitar la cantidad de operaciones de cobertura a una y si se detiene, simplemente esperar y ver qué pasa con la operación original.

Este es el tipo de resultados que obtengo:

576 2015.01.15 11:39 buy stop 29 0.48 1.16786 1.16616 0.00000 0.00 4834.24

577 2015.01.15 11:39 vender stop 30 0.48 1.16642 1.16812 0.00000 0.00 4834.24

578 2015.01.15 11:39 vender 30 0.48 1.16642 1.16812 0.00000 0.00 4834.24

579 2015.01.15 11:39 borrar 29 0.48 1.16786 1.16616 0.00000 0.00 4834.24

580 2015.01.15 11:42 comprar 31 1.44 1.16743 1.16653 0.00000 0.00 4834.24

581 2015.01.15 11:42 s/l 31 1.44 1.16653 1.16653 0.00000 -129.60 4704.64

582 2015.01.15 11:44 comprar 32 1.44 1.16742 1.16652 0.00000 0.00 4704.64

583 2015.01.15 11:44 s/l 30 0.48 1.16812 1.16812 0.00000 -81.60 4623.04

584 2015.01.15 11:48 modificar 32 1.44 1.16742 1.16893 0.00000 0.00 4623.04

Las órdenes buystop y sellstop (29 y 30) se abren como es debido. A continuación, el precio cae y la orden de venta (30) se ejecuta mientras que la buystop (29) se elimina. El precio vuelve a subir y la orden de cobertura (martingala) (31) se activa (3*tamaño de lote). A continuación, el precio vuelve a bajar y la orden de cobertura (31) se interrumpe, pero como la 30 sigue abierta, se activa otra orden de cobertura (32), etc. ¿Cómo puedo evitar que se active la orden 32? Gracias


 

Hola a todos. Hace ya más de un mes que intento resolver esto y empiezo a pensar que es programáticamente imposible de codificar. Así que si alguien me lo confirma por favor, podré dejarlo estar y seguir adelante. ¿No es posible establecer un nivel profundo para el número de órdenes de cobertura (martingala) como se explica en el post anterior? Gracias.

Lo mejor que tengo hasta ahora es:

int start()
{
   int buy_ticket=0;
   int sell_ticket=0;
   int total=0;
   for(int i= OrdersTotal()-1; i>= 0; i--)
      if(OrderSelect(i,SELECT_BY_POS) && OrderSymbol()==Symbol())
     {
         total++;
         if(OrderType()==OP_BUY) buy_ticket=OrderTicket();
         if(OrderType()==OP_SELL) sell_ticket=OrderTicket();
        }
   /*if(total==1 && OrderSelect(buy_ticket,SELECT_BY_TICKET) && OrderType()==OP_BUY) <------- this blocked out code is irrelevant, but I want to put it here for completeness
     {
      if(Bid-OrderOpenPrice()>TrailingStart*point)
        {
         if(OrderStopLoss()<Bid-TrailingStop*point)
           {
            if(OrderModify(OrderTicket(),OrderOpenPrice(),Bid-TrailingStop *point,OrderTakeProfit(),Blue))
               return(0);
           }
        }*/
      else if(OrderOpenPrice()>Bid+Hedge*point)
        {
         sell_ticket=OrderSend(Symbol(),OP_SELL,HedgeLots,Bid,3,Bid+StopLossHedge*point,0,"Hedge",magic,0,Blue);
         return(0);
        }
     }
  }
 

Hay diferentes maneras de conseguirlo.

Cuando se abra la cobertura, cree una Variable Global del terminal del cliente.

Dele un nombre que incluya el número de ticket de la operación principal.

Dele un valor que actúe como indicador de que se ha abierto una operación de cobertura para ese número de ticket, o un recuento de cobertura si es necesario.

Compruebe el GV antes de abrir una cobertura.


La operación de cobertura y la principal tienen tamaños de lote diferentes.

Antes de abrir una cobertura, compruebe las órdenes abiertas y el historial para ver si se ha abierto una orden opuesta con el tamaño de lote correspondiente con una OrderOpenTime() posterior a la hora de apertura de la operación principal.

 
GumRai:

Hay diferentes maneras de conseguirlo.

Cuando se abra la cobertura, cree una Variable Global del terminal del cliente.

Darle un nombre que incluya el número de ticket de la operación principal.

Darle un valor que actúe como indicador de que se ha abierto una operación de cobertura para ese número de ticket, o un recuento de cobertura si es necesario.

Compruebe el GV antes de abrir una cobertura.


La operación de cobertura y la principal tienen tamaños de lote diferentes.

Antes de abrir una cobertura, compruebe las órdenes abiertas y el historial para ver si se ha abierto una orden opuesta con el tamaño de lote correspondiente con una OrderOpenTime() posterior a la hora de apertura de la operación principal.

Muchas gracias, miraré estas opciones y os lo haré saber.
 

Así que traté de lograr esto a través de una Variable Global, pero desde la adición de este código, no es la apertura de un comercio de cobertura en absoluto. Creo que el problema es que el EA está haciendo un GlobalVariableCheck, pero ya que ninguno se ha creado todavía, no va a continuar. Sin embargo, selecciona e imprime la entrada correcta no. Tal vez lo estoy haciendo mal. Aquí está el código correspondiente:

//+------------------------------------------------------------------+
//|  Hedge                                                           |
//+------------------------------------------------------------------+
void Hedgetrade(){
int buy_hedge=0,sell_hedge=0,total=0;
double Pip=Point*10,HedgeLots=NormalizeDouble(OrderLots()*Multiplier,2),SLHedge=StopLossHedge*Pip;
   for(int i=OrdersTotal()-1; i>=0; i--){
      if(OrderSelect(i,SELECT_BY_POS,MODE_TRADES)&& OrderSymbol()==Symbol()){
      total++;
      int ticket=OrderTicket();
      Print("ticket = ",ticket);
     }          
         if(OrderType()==OP_BUY){
            if(buy_hedge==0 && sell_hedge==0 && OrderOpenPrice()>Bid+Hedge*Pip)
               GlobalVariableCheck(ticket);
               sell_hedge=OrderSend(Symbol(),OP_SELL,HedgeLots,Bid,3,Bid+SLHedge,0,"Hedge",0,0,Blue);
                  GlobalVariableSet(ticket,1);
                 }
         if(OrderType()==OP_SELL){
            if(sell_hedge==0 && buy_hedge==0 && OrderOpenPrice()<Ask-Hedge*Pip)
               GlobalVariableCheck(ticket);
               buy_hedge=OrderSend(Symbol(),OP_BUY,HedgeLots,Ask,3,Ask-SLHedge,0,"Hedge",0,0,Red);
                  GlobalVariableSet(ticket,1);
              }
            }
          }
12345
Nuevo comentario