[ARCHIVO] Cualquier pregunta de novato, para no saturar el foro. Profesionales, no pasen de largo. En ninguna parte sin ti - 3. - página 450

Nuevo comentario
 
T-G:
Sí, pero el punto de la pregunta es que la orden anterior se cerró con un menos. La función no tiene tiempo para mostrar esto, primero la orden se abre después de un par de ticks y sólo entonces la función muestra la última pérdida, pero la orden ya se ha abierto.
Escribí un esqueleto de código con la comprobación
 
Lo hice así que una vez más dice que no tiene tiempo para comprobar primero que pasa como si no hay alce abre un trato y luego le viene que había un alce
 
artmedia70:

Por qué no utilizar el parámetro de orden pendiente de caducidad.

Por supuesto, existe la posibilidad de que este parámetro no se pueda utilizar.

En algunos servidores comerciales, el tiempo de expiración de las órdenes pendientes puede estar prohibido. En este caso, se generará un error 147 (ERR_TRADE_EXPIRATION_DENIED) al intentar establecer un valor distinto de cero en el parámetro de expiración.

Esa es la única manera, por supuesto...

Cambié la línea como sugeriste y el Asesor Experto dejó de funcionar...

ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+PriceDistance*Point,3,Ask+PriceDistance*Point-StopLoss*Point,Ask+PriceDistance*Point+TakeProfit*Point, "PD",1,TimeCurrent()+10*60,Green);

Al mismo tiempo, sé con certeza que no hay ninguna prohibición.

Por favor, indique dónde puede estar el error.

 
T-G:
Lo hice así que una vez más dice que no tiene tiempo para comprobar primero que pasa como si no hay alce abre un trato y luego le viene que había un alce
Los milagros no ocurren. Deberías ver a un telépata...
 
OlegArH:

Hice cambios en la línea como sugeriste, y el Asesor Experto dejó de funcionar...

ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+PriceDistance*Point,3,Ask+PriceDistance*Point-StopLoss*Point,Ask+PriceDistance*Point+TakeProfit*Point, "PD",1,TimeCurrent()+10*60,Green);

Al mismo tiempo, sé con certeza que no hay ninguna prohibición.

Por favor, indique dónde puede estar el error.

Es poco probable que haya dejado de funcionar, pero es probable que su criterio sea erróneo. Sin el código, es difícil pensar en una razón por la que el EA no está funcionando...
 
artmedia70:
Es poco probable que haya dejado de funcionar, pero es probable que sus criterios estén cojos. Sin el código, es difícil pensar en una razón por la que el EA no funciona...

Esto es todo lo que he garabateado hasta ahora:

extern double TakeProfit = 50;
extern double StopLoss=100;
extern double PrecioDistancia = 50;
extern double Lots = 1;
extern double TrailingStop = 50;
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int inicio()
{
int cnt, ticket, total;

total=Total de pedidos();
if(total<1)
{
ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+PriceDistance*Point,3,Ask+PriceDistance*Point-StopLoss*Point,Ask+PriceDistance*Point+TakeProfit*Point, "PD",1,0,Green);
Dormir (10000);
ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-PriceDistance*Point,3,Bid-PriceDistance*Point+StopLoss*Point,Bid-PriceDistance*Point-TakeProfit*Point, "PD",2,0,Red);
}

for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderType()<=OP_SELL && // comprobar la posición abierta
OrderSymbol()==Symbol()) // comprobar el símbolo
{
if(OrderType()==OP_BUY) // se abre la posición larga
{
// ¿se debe cerrar?
if(1!=1)
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // cerrar posición
return(0); // salir
}
// comprobar el trailing stop
if(TrailingStop>0)
{
if(Bid-OrderOpenPrice()>Point*TrailingStop)
{
if(OrderStopLoss()<Bid-Point*TrailingStop)
{
OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*TrailingStop,OrderTakeProfit(),0,Green);
return(0);
}
}
}
}
si no // pasar a la posición corta
{
// ¿se debe cerrar?
if(1!=1)
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // cerrar posición
return(0); // salir
}
// comprobar el trailing stop
if(TrailingStop>0)
{
if((OrderOpenPrice()-Ask)>(Point*TrailingStop))
{
if((OrderStopLoss()>(Ask+Point*TrailingStop)) || (OrderStopLoss()==0))
{
OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,OrderTakeProfit(),0,Red);
return(0);
}
}
}
}
}
}
return(0);
}

// el final.

Funciona así.... Pero, en consecuencia, abre las operaciones indefinidamente, la enredadera.

Gracias de antemano.

 
OlegArH:

Esto es todo lo que he garabateado hasta ahora:

extern double TakeProfit = 50;
extern double StopLoss=100;
extern double PrecioDistancia = 50;
extern double Lots = 1;
extern double TrailingStop = 50;
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int inicio()
{
int cnt, ticket, total;

total=Total de pedidos();
if(total<1)
{
ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+PriceDistance*Point,3,Ask+PriceDistance*Point-StopLoss*Point,Ask+PriceDistance*Point+TakeProfit*Point, "PD",1,0,Green);
Dormir (10000);
ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-PriceDistance*Point,3,Bid-PriceDistance*Point+StopLoss*Point,Bid-PriceDistance*Point-TakeProfit*Point, "PD",2,0,Red);
}

for(cnt=0;cnt<total;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderType()<=OP_SELL && // comprobar la posición abierta
OrderSymbol()==Symbol()) // comprobar el símbolo
{
if(OrderType()==OP_BUY) // se abre la posición larga
{
// ¿se debe cerrar?
if(1!=1)
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // cerrar posición
return(0); // salir
}
// comprobar el trailing stop
if(TrailingStop>0)
{
if(Bid-OrderOpenPrice()>Point*TrailingStop)
{
if(OrderStopLoss()<Bid-Point*TrailingStop)
{
OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*TrailingStop,OrderTakeProfit(),0,Green);
return(0);
}
}
}
}
si no // pasar a la posición corta
{
// ¿se debe cerrar?
if(1!=1)
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // cerrar posición
return(0); // salir
}
// comprobar el trailing stop
if(TrailingStop>0)
{
if((OrderOpenPrice()-Ask)>(Point*TrailingStop))
{
if((OrderStopLoss()>(Ask+Point*TrailingStop)) || (OrderStopLoss()==0))
{
OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,OrderTakeProfit(),0,Red);
return(0);
}
}
}
}
}
}
return(0);
}

// el final.

Funciona así.... Pero, en consecuencia, abre las operaciones indefinidamente, la enredadera.

Gracias de antemano.


Aprenda a insertar código: léalo todo.
 
Roman.:

Aprenda a insertar código: léalo todo.

Roman, ¡gracias por la respuesta!
Lo que tengo que hacer es que el robot abra las operaciones por el tiempo desde que se abren automáticamente.

Por ejemplo, el robot abre una operación TARGET, establece automáticamente el tiempo de expiración +600 segundos desde el actual y eso es todo....

En este caso, la opción cuando se quita a sí mismo no encaja, ya que el TC en el que "tren" hay restricciones en la modificación de las órdenes pendientes si el precio se acercó a más de 10 puntos + Spread al precio de apertura, incluyendo los que aún no orden abierta.

Además, la cuestión es que si una orden ya está abierta, no hay que borrarla, sino que hay que dejarla "jugar" y burbujear hasta su "muerte". Y si establecemos orderdelite, la función también cerrará las órdenes que ya se hayan disparado. (?)

En cuanto al libro de texto... bueno, no soy programador por temperamento, soy un brillante humanista... ¡dibujo, modeló, compuso y no afiló para nada más!)

He tratado de entrar en él de buena fe. Algunas cosas tenían sentido y otras no.

Por eso estoy aquí.....

 
OlegArH:

Roman, ¡gracias por la respuesta!
Sólo es cuestión de conseguir que el robot abra las operaciones a tiempo desde el momento en que se abren automáticamente.

Por ejemplo, el robot abre una operación TARGET, establece automáticamente el tiempo de expiración +600 segundos desde el actual y eso es todo....

En este caso, la opción cuando se quita a sí mismo no encaja, ya que el TC en el que "tren" hay restricciones en la modificación de las órdenes pendientes si el precio se acercó a más de 10 puntos + Spread al precio de apertura, incluyendo los que aún no orden abierta.

Además, la cuestión es que si una orden ya está abierta, no debe ser eliminada, sino que se debe permitir que "juegue" y falle. Y si establecemos orderdelite, la función también cerrará las órdenes que ya se hayan disparado. (?)

En cuanto al libro de texto... bueno, no soy programador por temperamento, soy un brillante humanista... ¡dibujo, modeló, compuso y no afiló para nada más!)

He tratado de entrar en él de buena fe. Algunas cosas tenían sentido y otras no.

Por eso estoy aquí.....

Intenta describir con palabras lo que has escrito aquí:

extern double TakeProfit = 50;
extern double StopLoss=100;
extern double PriceDistance = 50;
extern double Lots = 1;
extern double TrailingStop = 50;
//+------------------------------------------------------------------+
//| |
//+------------------------------------------------------------------+
int start()
{
   int cnt, ticket, total;

   total=OrdersTotal();
   if(total<1) {
      ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+PriceDistance*Point,3,Ask+PriceDistance*Point-StopLoss*Point,
                       Ask+PriceDistance*Point+TakeProfit*Point,"PD",1,0,Green);
      Sleep (10000);
      ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-PriceDistance*Point,3,Bid-PriceDistance*Point+StopLoss*Point,
                       Bid-PriceDistance*Point-TakeProfit*Point,"PD",2,0,Red);
      }

   for(cnt=0;cnt<total;cnt++) {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if(OrderType()<=OP_SELL &&                         // check for opened position
         OrderSymbol()==Symbol()) {                      // check for symbol
         if(OrderType()==OP_BUY) {                       // long position is opened
            if(1!=1) {
               OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // close position
               return(0);                                // exit
               }
                                                         // check for trailing stop
            if(TrailingStop>0) {
               if(Bid-OrderOpenPrice()>Point*TrailingStop) {
                  if(OrderStopLoss()<Bid-Point*TrailingStop) {
                     OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*TrailingStop,OrderTakeProfit(),0,Green);
                     return(0);
                     }
                  }
               }
            }
         else {                                          // go to short position
                                                         // should it be closed?
            if(1!=1) {
               OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // close position
               return(0);                                // exit
               }
                                                         // check for trailing stop
            if(TrailingStop>0) {
               if((OrderOpenPrice()-Ask)>(Point*TrailingStop)) {
                  if((OrderStopLoss()>(Ask+Point*TrailingStop)) || (OrderStopLoss()==0)) {
                     OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,OrderTakeProfit(),0,Red);
                     return(0);
                     }
                  }
               }
            }
         }
      }
   return(0);
}

Personalmente para mí a primera vista resultó ser un rompecabezas su idea: Si uno no es igual a uno, entonces cierre el orden...

No vi el resto después de eso...

ZS y no lo intentes, ni pienses que es posible escribir un EA normal en un ciclo...

 
OlegArH:

...Y si pones orderdelite, la función también cerrará las órdenes que ya han sido activadas. (?)

...


No. Mira más de cerca. Una orden pendiente activada se convierte en una orden de mercado - esta función no tiene nada que ver.

"Borra una orden pendiente previamente establecida. Devuelve TRUE si la función se ha completado con éxito. Devuelve FALSE

si la función no se ha completado con éxito. Llame a GetLastError() para obtener información sobre el error".

1...443444445446447448449450451452453454455456457...652
Nuevo comentario
Razón de la queja: