[ARCHIVIO] Qualsiasi domanda da principiante, per non ingombrare il forum. Professionisti, non passate oltre. Da nessuna parte senza di te - 3. - pagina 450

Nuovo commento
 
T-G:
Sì, ma il punto della domanda è che l'ordine precedente è stato chiuso con un meno. La funzione non ha il tempo di mostrarlo, prima l'ordine viene aperto dopo un paio di tick e solo allora la funzione mostra l'ultima perdita ma l'ordine è già stato aperto.
Ho scritto uno scheletro di codice con il controllo
 
Ho fatto così ancora una volta dire non ha il tempo di controllare prima passa come se non c'è alce apre un affare e poi viene a lui che c'era un alce
 
artmedia70:

Perché non usare il parametro Expiration pending order.

C'è ovviamente la possibilità che questo parametro non possa essere utilizzato.

Su alcuni server di trading, il tempo di scadenza degli ordini in sospeso può essere vietato. In questo caso, un errore 147 (ERR_TRADE_EXPIRATION_DENIED) sarà generato quando si cerca di impostare un valore diverso da zero nel parametro di scadenza.

Questo è l'unico modo, naturalmente...

Ho cambiato la linea come hai suggerito e l'Expert Advisor ha smesso di funzionare...

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);

Allo stesso tempo so per certo che non c'è nessun divieto.

Si prega di consigliare dove può essere l'errore.

 
T-G:
Ho fatto così ancora una volta dire non ha il tempo di controllare prima passa come se non c'è alce apre un affare e poi viene a lui che c'era un alce
I miracoli non accadono. Dovresti vedere un telepate...
 
OlegArH:

Ho fatto delle modifiche alla linea come hai suggerito, e l'Expert Advisor ha smesso di funzionare...

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);

Allo stesso tempo so per certo che non c'è nessun divieto.

Si prega di consigliare dove può essere l'errore.

È improbabile che abbia smesso di funzionare, ma è probabile che il tuo criterio sia difettoso. Senza il codice, è difficile pensare a un motivo per cui l'EA non funziona...
 
artmedia70:
È improbabile che abbia smesso di funzionare, ma i vostri criteri sono probabilmente zoppi. Senza il codice, è difficile pensare a un motivo per cui l'EA non funziona...

Ecco tutto quello che ho scarabocchiato finora:

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, totale;

total=OrdersTotal();
se(totale<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);
Dormire (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<totale;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderType()<=OP_SELL && // controlla la posizione aperta
OrderSymbol()==Symbol()) // controlla il simbolo
{
if(OrderType()==OP_BUY) // la posizione lunga è aperta
{
// dovrebbe essere chiuso?
se(1!=1)
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // chiudere la posizione
return(0); // uscire
}
// controlla il trailing stop
se(TrailingStop>0)
{
se(Bid-OrderOpenPrice()>Point*TrailingStop)
{
se(OrderStopLoss()<Bid-Point*TrailingStop)
{
OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*TrailingStop,OrderTakeProfit(),0,Green);
ritorno(0);
}
}
}
}
else // vai alla posizione corta
{
// dovrebbe essere chiuso?
se(1!=1)
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // chiudere la posizione
return(0); // uscire
}
// controlla il trailing stop
se(TrailingStop>0)
{
se((OrderOpenPrice()-Ask)>(Point*TrailingStop))
{
if((OrderStopLoss()>(Ask+Point*TrailingStop)) || (OrderStopLoss()==0))
{
OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,OrderTakeProfit(),0,Red);
ritorno(0);
}
}
}
}
}
}
ritorno(0);
}

// la fine.

Funziona così.... Ma, di conseguenza, apre i commerci all'infinito, la liana.

Grazie in anticipo!

 
OlegArH:

Ecco tutto quello che ho scarabocchiato finora:

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, totale;

total=OrdersTotal();
se(totale<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);
Dormire (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<totale;cnt++)
{
OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
if(OrderType()<=OP_SELL && // controlla la posizione aperta
OrderSymbol()==Symbol()) // controlla il simbolo
{
if(OrderType()==OP_BUY) // la posizione lunga è aperta
{
// dovrebbe essere chiuso?
se(1!=1)
{
OrderClose(OrderTicket(),OrderLots(),Bid,3,Violet); // chiudere la posizione
return(0); // uscire
}
// controlla il trailing stop
se(TrailingStop>0)
{
se(Bid-OrderOpenPrice()>Point*TrailingStop)
{
se(OrderStopLoss()<Bid-Point*TrailingStop)
{
OrderModify(OrderTicket(),OrderOpenPrice(),Bid-Point*TrailingStop,OrderTakeProfit(),0,Green);
ritorno(0);
}
}
}
}
else // vai alla posizione corta
{
// dovrebbe essere chiuso?
se(1!=1)
{
OrderClose(OrderTicket(),OrderLots(),Ask,3,Violet); // chiudere la posizione
return(0); // uscire
}
// controlla il trailing stop
se(TrailingStop>0)
{
se((OrderOpenPrice()-Ask)>(Point*TrailingStop))
{
if((OrderStopLoss()>(Ask+Point*TrailingStop)) || (OrderStopLoss()==0))
{
OrderModify(OrderTicket(),OrderOpenPrice(),Ask+Point*TrailingStop,OrderTakeProfit(),0,Red);
ritorno(0);
}
}
}
}
}
}
ritorno(0);
}

// la fine.

Funziona così.... Ma, di conseguenza, apre i commerci all'infinito, la liana.

Grazie in anticipo!


Impara come inserire il codice - leggi tutto.
 
Roman.:

Impara come inserire il codice - leggi tutto.

Roman, grazie per la risposta!
Quello che devo fare è fare in modo che il robot apra i trade per il tempo dal momento in cui vengono aperti automaticamente.

Per esempio, il robot apre un trade TARGET, imposta automaticamente la scadenza a +600 sec da quella attuale e questo è tutto....

In questo caso, l'opzione quando li rimuove se stesso non si adatta, poiché TC su cui "treno" ci sono restrizioni sulla modifica degli ordini pendenti se il prezzo è venuto più vicino di 10 punti + Spread al prezzo di apertura, compresi quelli non ancora aperto ordine.

Inoltre, il punto è che se un ordine è già aperto, non dovrebbe essere cancellato, ma dovremmo lasciarlo "giocare" e bollire fino alla sua "morte". E se impostiamo orderdelite, la funzione chiuderà anche gli ordini che sono già scattati. (?)

Per quanto riguarda il libro di testo - beh, non sono un programmatore per temperamento, sono un brillante umanitario - disegno, modello, compongo, e non affilo per altro!)

Ho cercato di entrarci in buona fede. Alcune cose avevano senso e altre no.

Ecco perché sono qui.....

 
OlegArH:

Roman, grazie per la risposta!
Si tratta solo di fare in modo che il robot apra i trade in tempo dal momento in cui vengono aperti automaticamente.

Per esempio, il robot apre un trade TARGET, imposta automaticamente la scadenza a +600 sec da quella attuale e questo è tutto....

In questo caso, l'opzione quando li rimuove se stesso non si adatta, poiché TC su cui "treno" ci sono restrizioni sulla modifica degli ordini pendenti se il prezzo è venuto più vicino di 10 punti + Spread al prezzo di apertura, compresi quelli non ancora aperto ordine.

Inoltre, il punto è che se un ordine è già aperto, non dovrebbe essere cancellato, ma dovrebbe essere permesso di "giocare" e fallire. E se impostiamo orderdelite, la funzione chiuderà anche gli ordini che sono già scattati. (?)

Per quanto riguarda il libro di testo - beh, non sono un programmatore per temperamento, sono un brillante umanitario - disegno, modello, compongo, e non affilo per altro!)

Ho cercato di entrarci in buona fede. Alcune cose avevano senso e altre no.

Ecco perché sono qui.....

Prova a descrivere a parole quello che hai scritto qui:

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 per me al primo sguardo si è rivelato un rompicapo la vostra idea: se uno non è uguale a uno, allora chiudete l'ordine...

Non ho guardato il resto dopo quello...

ZS e non provate, non pensate nemmeno che sia possibile scrivere un EA normale in un solo ciclo...

 
OlegArH:

...E se metti orderdelite, la funzione chiuderà anche gli ordini che sono già stati attivati. (?)

...


No, guarda meglio. Un ordine pendente attivato diventa un ordine a mercato - questa funzione non ha nulla a che fare con esso.

"Cancella un ordine pendente precedentemente impostato. Restituisce TRUE se la funzione è stata completata con successo. Restituire FALSO

se la funzione non è stata completata con successo. Chiama GetLastError() per ottenere informazioni sugli errori".

1...443444445446447448449450451452453454455456457...652
Nuovo commento