È necessario un semplice codice per l'EA (modificare due ordini aperti) - pagina 3

Nuovo commento
 

Fondamentalmente ho impostato due ordini pendenti a un'ora specifica, in particolare alle 23:00 GMT+2 credo. Uno degli ordini pendenti è un sell stop e l'altro è un buy stop, entrambi gli ordini sono ad una distanza uguale dall'open della candela delle 23:00, in questo caso 14 pips. Entrambi hanno un TakeProfit di 28 pip (in questo caso) e uno StopLoss di 55 pip.

Ora quando entrambi gli ordini sono soddisfatti (essenzialmente salendo e scendendo di 14 pip dal prezzo aperto alla candela delle 23:00 prima che gli ordini scadano), voglio che entrambi gli ordini abbiano i loro take profit aumentati, per esempio, di 20 pip. Quindi il loro nuovo take profit è di 58 pip in questo caso. Lo stop loss invece dovrebbe essere mantenuto lo stesso per tutto il tempo. Essenzialmente quello che sto cercando di fare è una sorta di copertura.

Se due trade sono aperti, allora è probabile che il prezzo vada in una direzione abbastanza da annullare qualsiasi perdita se i take profit di entrambi i trade vengono aumentati. Per ottenere un qualsiasi profitto solo un trade dovrebbe aprirsi e raggiungere il take profit o entrambi i trade si aprono e colpiscono i take profit senza andare molto in una direzione.

Spero che questo sia chiaro, se non lo è fornirò un'immagine che dovrebbe essere più chiara.

 
WHRoeder:

Mi riferivo al tuo post direttamente precedente

madmax3 2012.03.09 14:52
Ecco il codice rivisto per l'intero EA:
Che mostra ancora i problemi che ho dichiarato.
Quella parte di codice è per un'altra parte dell'EA credo, la parte che apre gli ordini pendenti, avrebbe qualche effetto sulla parte che sto cercando di risolvere? Scusa, credo di aver confuso alcune parti del codice soprattutto nel post originale. Ho comunque fatto quello che hai detto tu alla parte del codice che mi serve specificamente.
 
madmax3:

Spero che questo sia chiaro, se non lo è fornirò un'immagine che dovrebbe essere più chiara.

È chiaro, grazie.

Quindi vuoi solo modificare questi ordini una volta... allora la risposta è semplice. Devi controllare la barra delle 23:00 e determinare i TP ai quali gli ordini avrebbero dovuto essere aperti. . . se gli ordini sono allo stesso TP allora devono essere modificati, se non sono allo stesso TP allora sono già stati modificati e non hanno bisogno di essere modificati di nuovo. . . semplice.

 
RaptorUK:

È chiaro, grazie.

Quindi vuoi solo modificare questi ordini una volta... allora la risposta è semplice. Devi controllare la barra delle 23:00 e determinare i TP a cui gli ordini avrebbero dovuto essere aperti... se gli ordini sono allo stesso TP allora devono essere modificati, se non sono allo stesso TP allora sono già stati modificati e non devono essere modificati di nuovo... semplice.

La modifica e il controllo dovrebbero avvenire solo quando ci sono due operazioni aperte, come dovrei fare? Devo aggiungere al codice che ho già o ricominciare da capo?

Quindi, essenzialmente, se ci sono due trade (stesso simbolo e numero magico) l'EA dovrebbe controllare i take profit dei trade aperti rispetto agli ordini pendenti precedentemente esistenti (che ora vengono eseguiti) e poi se sono uguali, dovrebbe essere modificato, e una volta in loop controllerà nuovamente e troverà che non sono uguali e quindi non modificherà ulteriormente i trade?
 
madmax3:
1. La modifica e il controllo dovrebbero avvenire solo quando ci sono due operazioni aperte, come dovrei fare? Devo aggiungere al codice che ho già o ricominciare da capo?

2. Quindi, essenzialmente, se ci sono due trade (stesso simbolo e numero magico) l'EA dovrebbe controllare i take profit dei trade aperti rispetto agli ordini pendenti precedentemente esistenti (che ora vengono eseguiti) e quindi se sono uguali, dovrebbe essere modificato, e una volta in loop controllerà nuovamente e troverà che non sono uguali e quindi non modificherà ulteriormente i trade?

1. Fate un loop tra gli ordini aperti, controllate il simbolo, il numero magico, quando avete una corrispondenza che non è un tipo di ordine pendente incrementate un contatore . . . quando avete finito di controllare gli ordini se ne avete contati 2 allora avete 2 ordini aperti per il simbolo corretto e il numero magico . . . quindi ora potete modificarli . . . vedi 2.

2. No, non puoi vedere il TP degli ordini pendenti se sono stati attivati e ora non sono più pendenti. L'EA dovrebbe controllare la barra delle 23:00 e capire quali sarebbero stati i TP originali... poi confrontarli con i TP dei 2 ordini aperti... da questa informazione si può decidere se modificare o meno.

 
RaptorUK:

1. Fate un loop tra gli ordini aperti, controllate il simbolo, il numero magico, quando avete una corrispondenza che non è un tipo di ordine pendente incrementate un contatore . . . quando avete finito di controllare gli ordini se ne avete contati 2 allora avete 2 ordini aperti per il simbolo corretto e il numero magico . . . quindi ora potete modificarli . . . vedi 2.

2. No, non puoi vedere il TP degli ordini pendenti se sono stati attivati e ora non sono più pendenti. L'EA dovrebbe controllare la barra delle 23:00 e capire quali sarebbero stati i TP originali... poi confrontarli con i TP dei 2 ordini aperti... da questa informazione si può decidere se modificare o meno.

Ah ho capito, credo che questo sia quello che ho cercato di fare per tutto il tempo. Finora uno degli ordini viene modificato (in particolare quello di acquisto che è l'ordine 2 nei miei test) ma continua a essere modificato, devo usare 'break' per evitare che si ripeta? Inoltre, come faccio a contare e modificare solo gli ordini aperti quando e solo quando ce ne sono due aperti? Ho provato a usare OrdersTotal() per questo, ma non funziona, non credo di dover fare due pezzi di codice separati per ogni ordine, giusto?
Solo gli ordini aperti di numero pari vengono modificati e come ho detto vengono ripetutamente modificati, ho provato varie combinazioni per OrderSelect() ma non riesco ancora a capirlo, come ho detto sono un noob totale in MQL e questo EA è quasi finito quindi vorrei solo finirlo. Ho letto questohttps://book.mql4.com/trading/ordermodify potrebbe avere qualcosa a che fare con la mia situazione? È per uno stop loss ma ne ho bisogno per un take profit essenzialmente.

Cosa sto facendo di sbagliato qui?

     for(int iPos = OrdersTotal()-1; iPos >= 1 ; iPos--) if (
        OrderSelect(iPos, SELECT_BY_POS)                    // Only my orders w/
    &&  OrderMagicNumber()  == MagicNumber                 // my magic number
    &&  OrderSymbol()       == "EURUSD"                // and my pair.
    && (OrderType() == OP_BUY)
    ){OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),Ask+((TakeProfit+20)*Point),0,Blue);}
    return(0);
    
  if (
        OrderSelect(iPos-1, SELECT_BY_POS-1)                    
    &&  OrderMagicNumber()  == MagicNumber                
    &&  OrderSymbol()       == "EURUSD"                
    && (OrderType() == OP_SELL)
    ){OrderModify(OrderTicket(),OrderOpenPrice(),OrderStopLoss(),Ask+((TakeProfit-20)*Point),0,Blue);}
return(0);
  }

Come potrei verificare se il TP è lo stesso della candela delle 23:00? Sarebbe necessario in quanto tale, dato che finché gli ordini aperti vengono modificati quando ce ne sono 2 si ottiene lo stesso effetto? O questo è solo per evitare che l'ordine venga continuamente modificato e sì, ho controllato la documentazione.

Grazie,

madmax3

 

Il tuo return(0) ti porta fuori da start() prima che il 2° ordine sia modificato.

Tutto quello che stai facendo è selezionare l'ordine per posizione, controllare che abbia il numero Magic corretto, controllare che sia il simbolo corretto e controllare che sia OP_BUY . . . . poi lo modifichi, dove stai determinando se è già stato modificato o meno?

Il tuo EA deve essere in grado di recuperare dopo essere stato interrotto... se i tuoi ordini vengono piazzati e MT4 si blocca, deve essere in grado di riprendere da dove ha lasciato quando viene riavviato.

Questo è il motivo per cui è necessario determinare se l'ordine è già stato modificato o deve essere modificato... come?

"Ho impostato due ordini pendenti a un'ora specifica, precisamente alle 23:00 GMT+2 credo. Uno degli ordini pendenti è un sell stop e l'altro è un buy stop, entrambi gli ordini sono ad una distanza uguale dall'open della candela delle 23:00, in questo caso 14 pips. Entrambi hanno un TakeProfit di 28 pip (in questo caso) e uno StopLoss di 55 pip".

Puoi calcolare dove era il TP originale in riferimento alla candela delle 23:00, controllare l'ordine e vedere se è ancora impostato sul TP originale, se lo è allora può essere modificato... se non lo è allora è già stato modificato quindi non modificarlo di nuovo.

Ci sono altri modi di registrare che l'ordine è stato modificato, tenere traccia del numero del ticket, scrivere le informazioni in un file quando è stato modificato, quando si sta per modificarlo di nuovo aprire il file e controllare il numero del ticket, ecc ... Penso che controllare rispetto al TP originale sia molto più semplice.

 

Finora ho questo,

//+------------------------------------------------------------------+
//|                                                  TimeBasedEA.mq4 |
//|                      Copyright © 2008, MetaQuotes Software Corp. |
//|                                       http://www.metaquotes.net/ |
//+------------------------------------------------------------------+
//changed by:       "forex4capital@yahoo.ca"
//changed again by: madmax3

// Time frame: M5 and higher

extern int     MagicNumber = 20080122;
extern double DistancefromAsk;
extern double DistancefromBid;
extern double  TakeProfit  = 28;
extern double  StopLoss    = 55;
extern double  Lots        = 0.1;
extern int     StartHour   = 2300;      // Open Trade time
extern bool    OpenBuy     = true;
extern bool    OpenSell    = true;
extern int     NumBuys     = 1;
extern int     NumSells    = 1;
extern int     Slippage    = 2;

//+------------------------------------------------------------------+
//|                        S T A R T                                 |
//+------------------------------------------------------------------+
int start()
  {
   int cnt, ticket, total;
      if (TimeDayOfWeek(TimeCurrent())==5 && TimeCurrent()>=StrToTime("22:59")) { CloseAll(); return(0); }
   int ct;
//-------------------------------------+
   if(Bars<100)
     {
      Print("bars less than 100");
      return(0);  
     }
//-------------------------------------+

//-------------------------------------+
   if(TakeProfit<10)
     {
      Print("TakeProfit less than 10");
      return(0);  // check TakeProfit
     }
//-------------------------------------+

   ct = Hour() * 100 + Minute();
   total=OrdersTotal();
   if(total<1) 
     {
      // no opened orders identified
      if(AccountFreeMargin()<(1000*Lots))
        {
         Print("We have no money. Free Margin = ", AccountFreeMargin());
         return(0);  
        }
      // check for long position (BUY) possibility
      if(ct == StartHour && Close[1]>Open[1] && OpenBuy)
      //if(ct == StartHour && High[1]<Open[0] && OpenBuy)
        {
         for ( cnt = 0; cnt < NumBuys; cnt++)
         {
           ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+(DistancefromAsk*Point),Slippage,Bid-(StopLoss*Point),Ask+(TakeProfit*Point),"",MagicNumber,TimeCurrent()+39600,CLR_NONE);
           ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-(DistancefromBid*Point),Slippage,Ask+(StopLoss*Point),Bid-(TakeProfit*Point),"",MagicNumber,TimeCurrent()+39600,CLR_NONE); 
           if(ticket>0)
           {
            if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES)) Print("BUY order opened : ",OrderOpenPrice());
           }

          
           else Print("Error opening BUY order : ",GetLastError()); 
           

         }
         return; 
        }
      // check for short position (SELL) possibility
      if(ct == StartHour && Close[1]<Open[1] && OpenSell)
      //if(ct == StartHour && Low[1]>Open[0] && OpenSell)
        {
         for ( cnt = 0; cnt < NumSells; cnt++)
         {
           ticket=OrderSend(Symbol(),OP_SELLSTOP,Lots,Bid-(DistancefromAsk*Point),Slippage,Ask+(StopLoss*Point),Bid-(TakeProfit*Point),"",MagicNumber,TimeCurrent()+39600,CLR_NONE);
           ticket=OrderSend(Symbol(),OP_BUYSTOP,Lots,Ask+(DistancefromBid*Point),Slippage,Bid-(StopLoss*Point),Ask+(TakeProfit*Point),"",MagicNumber,TimeCurrent()+39600,CLR_NONE);
           if(ticket>0)
           {
            if(OrderSelect(ticket,SELECT_BY_TICKET,MODE_TRADES)) Print("SELL order opened : ",OrderOpenPrice());
           }
           else Print("Error opening SELL order : ",GetLastError());
         } 
         return; 
        
    
}
//---------------------------------------------------------------

 int Handle,                         // File descriptor
   Qnt_Symb;                           // Number of recorded symbols
   string File_Name="check.csv";        // File name
   
    Handle=FileOpen(File_Name,FILE_CSV|FILE_WRITE|FILE_READ,";");//File opening
   

         FileWrite(Handle,"Ticket","Magic","OTime","Type","Lots","Symbol","OPrice","S/L","T/P"); 
         
          for(int iPos = OrdersTotal()-1; iPos >= 1 ; iPos--)
      {       
       OrderSelect(iPos,SELECT_BY_POS) ;
       FileWrite(
         Handle,
         OrderTicket(),                //int
         OrderMagicNumber(),           //int
         TimeToStr(OrderOpenTime()),   //datetime
         
         OrderLots(),                  //double
         OrderSymbol(),                //string
         OrderOpenPrice(),             //double
         OrderStopLoss(),              //double
         OrderTakeProfit(),            //double
         TimeToStr(OrderCloseTime())  //int
       
        ) ; //end file write
           }   }
           
}
//---------------------------------------------------------------   
 
     
     
  void CloseAll()
{
   for(int cnt=OrdersTotal()-1;cnt>=0;cnt--)
   {
      OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
      if (OrderMagicNumber()!=MagicNumber) continue;
         
      //
      //
      //
      //
      //
         
      if (OrderType()==OP_BUY || OrderType()==OP_SELL)
      {
         for(int c=0; c<3; c++)
         {
            RefreshRates();
            if (OrderType()==OP_BUY)
                  { double cp = Bid;}  
            else  {        cp = Ask;}
               
            OrderClose(OrderTicket(),OrderLots(),cp,0,Yellow);
               int err=GetLastError();
               if(err==4 || err==136 || err==137 || err==138 || err==146)
               {
                  Sleep(5000); continue;
               }  
               break;                     
         }
         break;
      }
      }
      }
   
// the end.

Il codice di scrittura del file come incluso in sopra è,

//---------------------------------------------------------------

 int Handle,                         // File descriptor
   Qnt_Symb;                           // Number of recorded symbols
   string File_Name="check.csv";        // File name
   
    Handle=FileOpen(File_Name,FILE_CSV|FILE_WRITE|FILE_READ,";");//File opening
   

         FileWrite(Handle,"Ticket","Magic","OTime","Type","Lots","Symbol","OPrice","S/L","T/P"); 
         
          for(int iPos = OrdersTotal()-1; iPos >= 1 ; iPos--)
      {       
       OrderSelect(iPos,SELECT_BY_POS) ;
       FileWrite(
         Handle,
         OrderTicket(),                //int
         OrderMagicNumber(),           //int
         TimeToStr(OrderOpenTime()),   //datetime
         
         OrderLots(),                  //double
         OrderSymbol(),                //string
         OrderOpenPrice(),             //double
         OrderStopLoss(),              //double
         OrderTakeProfit(),            //double
         TimeToStr(OrderCloseTime())  //int
       
        ) ; //end file write
          	 FileClose(Handle); }   }
           
}
//---------------------------------------------------------------  

Sto ricevendo questi errori però,

2012.04.04 15:30:06 2012.01.16 06:25 TimeBasedEA Versione 2: FileOpen - troppi file aperti

2012.04.04 15:30:06 2012.01.16 06:25 TimeBasedEA Versione 2: handle -1 non valido in FileWrite

Cosa c'è di strano?

 

Perché mai hai scelto la più difficile delle due opzioni?

Quando hai finito di scrivere sul file devi chiuderlo... se è già aperto non hai bisogno di aprirlo di nuovo.

//---------------------------------------------------------------

int Handle,                         // File descriptor
    Qnt_Symb;                           // Number of recorded symbols
string File_Name="check.csv";        // File name
   
Handle=FileOpen(File_Name,FILE_CSV|FILE_WRITE|FILE_READ,";");//File opening    File opened here, outside the loop
   

FileWrite(Handle,"Ticket","Magic","OTime","Type","Lots","Symbol","OPrice","S/L","T/P"); 
         
for(int iPos = OrdersTotal()-1; iPos >= 1 ; iPos--)
   {       
   OrderSelect(iPos,SELECT_BY_POS);
   FileWrite(
         Handle,
         OrderTicket(),                //int
         OrderMagicNumber(),           //int
         TimeToStr(OrderOpenTime()),   //datetime   //  this is a string - Time  to  String
         
         OrderLots(),                  //double
         OrderSymbol(),                //string
         OrderOpenPrice(),             //double
         OrderStopLoss(),              //double
         OrderTakeProfit(),            //double
         TimeToStr(OrderCloseTime() )  //int     //  this is a string - Time  to  String
       
        ) ; //end file write

   FileClose(Handle);      //  why close the file inside the loop when it was opened outside the loop ?
   }   
}    //  what is this code inside of ?
           
}  // end of start
//---------------------------------------------------------------

Il tuo ciclo for è sbagliato ... la posizione dell'ultimo ordine è 0 e non 1

 
RaptorUK:

Perché mai hai scelto la più difficile delle due opzioni?

Non è questo il modo di fare la modifica e il controllo usando il file? O devo combinare entrambi i codici, la modifica (il mio post prima dell'ultimo) e il codice del file (che è solo per assicurarsi che non avvengano altre modifiche) ?
12345
Nuovo commento