Aprire l'ordine opposto - pagina 3

Nuovo commento
 
RaptorUK:

Può essere se ha un numero magico diverso daMagicNumber o se è per un simbolo diverso da quello su cui sta girando l'EA o se è un OP_SELLLIMIT o OP_BUYLIMIT . . inoltre, è necessario controllare i valori di ritorno dalle chiamate OrderDelete() .

Perché hai bisogno di chiamare RefreshRates()? Non intendo sbarazzarmi di loro, ma puoi spiegare perché stai chiamando RefreshRates() dove sei?


Cosa sono i valori di ritorno delle funzioni? Come si usano?


Ciao RaptorUK.

Per quanto ho capito il MagicNumber è lo stesso e sono OP_SELLSTOP e OP_BUYSTOP.

OrderDelete() chiama, temo di non capire cosa intendi ....

RefreshRates() l'ho appena messo dopo il problema con la chiusura.

Ora sono a Lisbona (Portogallo).

Luis

 
luisneves:


Ciao RaptorUK.

Per quanto ho capito il MagicNumber è lo stesso e sono OP_SELLSTOP e OP_BUYSTOP.

Chiamate OrderDelete() , temo di non capire cosa intendi ....

Quando chiami OrderDelete() (usando la funzione OrderDelete()) restituisce un valore, restituisce un valore bool, se il valore è true l'OrderDelete() ha funzionato, se è false l'OrderDelete() è fallito . . quindi controllate il valore di ritorno e se è falso riportate l'errore nel log usando Print() o usate Comment() o Alert() in modo da sapere che avete un problema e potete indagare.

Sulla base del tuo codice farei queste modifiche. . . . se fosse il mio codice farei ulteriori modifiche per stampare più informazioni in caso di errore, Bid, Ask, FreezeLevel, StopLevel, ecc.

void CloseAll()
   {
   int OrdType, GLError;
   
   RefreshRates();
                    
   for(int OrderPos = OrdersTotal()-1; OrderPos >= 0; OrderPos--)
      if( OrderSelect(OrderPos, SELECT_BY_POS, MODE_TRADES)
         && OrderMagicNumber() == MagicNumber 
         && OrderSymbol() == Symbol())
         {
         OrdType = OrderType();
         if(OrdType == OP_BUY || OrdType==OP_SELL)
            {
            if(!OrderClose(OrderTicket(), OrderLots(), OrderClosePrice(), UseSlippage, Yellow))
               GLError = GetLastError();
            }

         if(OrdType == OP_SELLSTOP || OrdType == OP_BUYSTOP || OrdType == OP_BUYLIMIT || OrdType == OP_SELLLIMIT)
            {
            if(!OrderDelete(OrderTicket())
               GLError = GetLastError();
            }

         if(GLError > 0) Print("Error Closing/Deleting Order, error # ", GLError, " for ticket: ", OrderTicket());         
         }
   }
 
RaptorUK:

Quando chiamate OrderDelete() (usando la funzione OrderDelete()) restituisce un valore, restituisce un valore bool, se il valore è vero OrderDelete() ha funzionato, se è falso OrderDelete() è fallito . . quindi controllate il valore di ritorno e se è falso riportate l'errore nel log usando Print() o usate Comment() o Alert() in modo da sapere che avete un problema e potete indagare.

Sulla base del tuo codice farei queste modifiche . . . . se fosse il mio codice farei ulteriori modifiche per stampare più informazioni in caso di errore, Bid, Ask, FreezeLevel, StopLevel, ecc.


Ciao RaptorUK,

La ragione per cui l'ordine pendente non è stato cancellato ha a che fare con la presa di profitto che era troppo bassa in questo caso 5 pips. La mia confusione deriva dal fatto che se avevo una routine per mettere lo stoploss, il prezzo aperto e il take profit fuori dalla freeze zone, perché questo non ha funzionato? Ok, ma ora sta funzionando.

A proposito, voglio chiudere l'ordine opposto una volta che l'altro è stato attivato, per questo ho messo questo codice extra ma (potete iniziare a ridere...) ma niente....

Qualche aiuto qui?

 while(IsTradeContextBusy()) Sleep(10);
                   RefreshRates();
         Ticket=OrderSend(Symbol(),OP_BUYSTOP,LotSize,BuyLevel,UseSlippage,BuyStopLoss,BuyTakeProfit,"Buy Stop Order",MagicNumber,0,Green);
         if(Ticket>0)
         
          int o=OrderType();
          if (o==OP_BUY)
          OrderDelete(OrderTicket());        
           {
            if(OrderSelect(Ticket,SELECT_BY_TICKET,MODE_TRADES)) Print("BUY Stop Order Opened : ",OrderOpenPrice());
           }
         //else Print("Error opening BUY Stop Order : ",GetLastError());
 
luisneves:


Ciao RaptorUK,

1. Il motivo per cui l'ordine pendente non è stato cancellato ha a che fare con la presa di profitto che era troppo bassa in questo caso 5 pips. La mia confusione deriva dal fatto che se avevo una routine per mettere lo stoploss, il prezzo aperto e il take profit fuori dalla freeze zone, perché questo non ha funzionato? Ok, ma ora sta funzionando.

2. A proposito, voglio chiudere l'ordine opposto una volta che l'altro è stato attivato. Per questo ho messo questo codice extra ma (potete iniziare a ridere...) ma niente....

Qualche aiuto qui?


1. Ah, questo è il motivo per cui è necessario controllare i valori di ritorno e stampare i codici di errore, ecc. È necessario assicurarsi che tutte le azioni di compravendita su qualsiasi ordine siano conformi alle informazioni qui:Requisiti e limitazioni nell'effettuare compravendite

2. Devi aspettare che l'ordine cambi tipo da OP_BUYSTOP a OP_BUY, potrebbe volerci del tempo, quindi devi continuare a controllare. Una volta che si è trasformato in OP_BUY allora puoi chiudere l'ordine opposto e per farlo dovrai trovare l'ordine corretto da chiudere. dovresti leggere la mia recente conversazione conWhooDoo22 che copre un argomento simile.

 

Ciao RaptorUk,

Ho seguito il link che hai fornito, ma il tema, nonostante sia interessante, è troppo lungo e con così tante opinioni divergenti che mi ci sono perso dentro.

Così, ho introdotto un codice per chiudere il contrario in sospeso e di nuovo niente e non riesco a vedere nulla nel giornale che dà un aiuto così..... cosa mi manca qui ......

grazie per qualsiasi luce.....

Luis

//Sell Pending Stop Loss & Take Profit Calculation     
     
   if(StopLoss>0)SellStopLoss=PendingSellPrice+(StopLoss*pt);
   if(TakeProfit>0)SellTakeProfit=PendingSellPrice-(TakeProfit*pt);
   
//Place Sell Pending Order
        
         while(IsTradeContextBusy()) Sleep(10);
                   RefreshRates();       
         Ticket=OrderSend(Symbol(),OP_SELLSTOP,LotSize,SellLevel,UseSlippage,SellStopLoss,SellTakeProfit,"Sell Stop Order",MagicNumber,0,Red);
         if(Ticket>0)OppositePendindDel();          
           {
            if(OrderSelect(Ticket,SELECT_BY_TICKET,MODE_TRADES)) Print("SELL Stop Order Opened : ",OrderOpenPrice());
           }
        //else Print("Error opening SELL Stop Order : ",GetLastError());
         } 
//+---------------------------------------------------------------------------+
int OppositePendindDel()
{
 int c,d,GLError;
 int e=OrdersTotal();
 
 for(c=e-1;c>=0;c--)
 {  
   OrderSelect(c,SELECT_BY_POS,MODE_TRADES);
   if(OrderType()==OP_BUY||OrderType()==OP_SELL)
   {
    for(d=e-1;d>=0;d--)
    {
     OrderSelect(d,SELECT_BY_POS,MODE_TRADES);
     
      if(OrderType()==OP_SELLSTOP)
     {
      if(!OrderDelete(OrderTicket()))
            GLError = GetLastError();
      
      return(1);
      }
      if(OrderType()==OP_BUYSTOP)
      {
       if(!OrderDelete(OrderTicket()))
             GLError = GetLastError();
       }
       if(GLError > 0) Print("Error Closing/Deleting Order, error # ", GLError, " for ticket: ", OrderTicket());
       return(1);
       }
      }
     }
    }
 
luisneves:

Ciao RaptorUk,

Ho seguito il link che hai fornito, ma il tema, nonostante sia interessante, è troppo lungo e con così tante opinioni divergenti che mi ci sono perso dentro.

Così, ho introdotto un codice per chiudere il contrario in sospeso e di nuovo niente e non riesco a vedere nulla nella rivista che dà un aiuto così..... cosa mi manca qui ......

RaptorUK:

2. Devi aspettare che l'ordine cambi tipo da OP_BUYSTOP a OP_BUY, potrebbe volerci del tempo,quindi devi continuare a controllare... una volta che si è trasformato in OP_BUY allora puoi chiudere l'ordine opposto e per farlo devi trovare l'ordine corretto da chiudere.

 
RaptorUK:



Ciao RaptorUK ,

Ok, ora sembra che stia cancellando l'ordine pendente opposto dopo che unordine pendente è scattato, ma ora alcuni ordini arrivano in doppio, il che significa che l'ea mette una vendita e un acquisto allo stesso tempo e la dimensione del lotto è la stessa per i due ordini quando deve mettere un ordine alla volta. Ho iniziato a diventare pazzo.....

Qualsiasi aiuto qui, per favore!!!!

File:
pendingyorderzecnfv9.mq4  13 kb
 
luisneves:


Ciao RaptorUK ,

Ok, ora sembra che stia cancellando l'ordine pendente opposto dopo che un ordine pendente è scattato, ma ora alcuni ordini arrivano in doppio, il che significa che l'ea mette una vendita e un acquisto allo stesso tempo e la dimensione del lotto è la stessa per i due ordini quando deve mettere un ordine alla volta. Ho iniziato a diventare pazzo.....

Qualsiasi aiuto qui, per favore!!!!

Guardando il tuo codice trovo molto difficile seguire quello che stai cercando di fare, vedo pochissimi commenti per aiutarmi, la tua funzione start() non mi mostra cosa stai cercando di fare su ogni tick, non hai un layout coerente di indentazione.

Cosa dovrebbe fare la funzione GoToClose()? Se avete fatto alcuni commenti all'inizio della funzione che descrivono ciò che dovrebbe fare, allora potrei vedere se sta effettivamente facendo ciò che dovrebbe fare, attualmente ciò che fa è chiamare unaCloseAll(); se una singola operazione che corrisponde al vostro simbolo e numero magico è in profitto di qualsiasi importo, o se avete più di 7 operazioni per qualsiasi simbolo e qualsiasi numero magico. CloseAll() chiude solo le operazioni per ilvostro simbolo e numero magico, quindi se avete 7 operazioni per un diverso simbolo o numero magico GoToClose() continuerà a chiamare CloseAll() e non succederà nient'altro.


Se tu piazzassi un trade manuale sul tuo conto demo e poi lanciassi il tuo EA non farebbe nulla... vedrebbe il trade ma non lo ignorerebbe, lo conterebbe e di conseguenza non piazzerebbe un suo trade, né chiuderebbe questo trade aperto. Cosa dovrebbe fare il tuo EA in questa situazione? E se ci fosse un trade piazzato da un altro EA con un numero magico diverso?

Hai bisogno di avere un quadro chiaro di ciò che stai cercando di fare, commenta la tua funzione start() in modo che il flusso e il processo sia chiaro, commenta ogni funzione in modo che sia chiaro ciò che ognuna di esse deve fare. Quando avrai fatto questo potresti anche capire dove sta il tuo problema.

 
RaptorUK:

Guardando il tuo codice trovo molto difficile seguire quello che stai cercando di fare, vedo pochissimi commenti che mi aiutano, la tua funzione start() non mi mostra cosa stai cercando di fare su ogni tick, non hai un layout coerente di indentazione.

Cosa dovrebbe fare la funzione GoToClose()? Se avete fatto alcuni commenti all'inizio della funzione che descrivono ciò che dovrebbe fare, allora potrei vedere se sta effettivamente facendo ciò che dovrebbe fare, attualmente ciò che fa è chiamare unaCloseAll(); se una singola operazione che corrisponde al vostro simbolo e numero magico è in profitto di qualsiasi importo, o se avete più di 7 operazioni per qualsiasi simbolo e qualsiasi numero magico. CloseAll() chiude solo le operazioni per ilvostro simbolo e numero magico, quindi se avete 7 operazioni per un diverso simbolo o numero magico GoToClose() continuerà a chiamare CloseAll() e non succederà nient'altro.


Se tu piazzassi un trade manuale sul tuo conto demo e poi lanciassi il tuo EA non farebbe nulla... vedrebbe il trade ma non lo ignorerebbe, lo conterebbe e di conseguenza non piazzerebbe un suo trade, né chiuderebbe questo trade aperto. Cosa dovrebbe fare il tuo EA in questa situazione? E se ci fosse un trade piazzato da un altro EA con un numero magico diverso?

Hai bisogno di avere un quadro chiaro di ciò che stai cercando di fare, commenta la tua funzione start() in modo che il flusso e il processo siano chiari, commenta ogni funzione in modo che sia chiaro ciò che ognuna di esse deve fare. Quando avrai fatto questo potresti capire dove si trova il tuo problema.


Ciao RaptorUK,

Scusa per il disordine. In questo momento sembra che l'EA stia facendo quello che ci si aspetta da lui, eccetto questo problema;

L'EA dovrebbe aprire un ordine opposto ogni volta che l'ordine precedente non prende il TakeProfit con un incremento di dimensione del lotto e con lo stesso importo di TakeProfit e lo fa, il problema è che deve mettere un solo ordine per volta e ne mette più di uno. Dando un'occhiata al report si può vedere che l'ordine 6 e 7 sono entrambi di vendita e l'ordine 7 dovrebbe essere di acquisto.

Ora ho messo il codice per funzione. La ragione per cui ho tutte quelle chiamate nulle è che voglio avere un funzionamento completo di blocchi indipendenti e qui so che ho problemi a sistemare questo Il Go to Open e go to Close è solo un modo per dire che se non abbiamo ordini aperti i primi vanno ad aprire se no vanno a chiudere (è un casino devo lavorare su questo...) Sto usando simbolo e numero magico per garantire che l'ea si occupi solo dei propri ordini.

La strategia principale è (e i blocchi sono da questo ordine);

1- Due ordini pendenti sono sopra e sotto il prezzo. Una volta che il prezzo innesca uno di essi, il pendente opposto viene cancellato. Questo funziona.

2- Se il prezzo prende il TakeProfit allora l'ordine viene chiuso e l'EA riprende a mettere due ordini pendenti e il processo ricomincia. Questo funziona

2- se il prezzo non sceglie il TakeProfit e rimbalza una volta che il TakeProfit è sceso (per gli ordini di acquisto), allora si dovrebbe aprire un ordine di vendita opposto con lo stesso TakeProfit e con un lotto maggiore del precedente. Questo funziona, tranne per il fatto che mette più di un ordine e dal Report si può vedere che gli ordini 6 e 7 sono entrambi ordini di vendita e dovrebbero essere solo uno, il 7 dovrebbe essere un ordine di acquisto.

3- Una volta che l'ultimo ordine prende un profitto, tutti gli ordini aperti dovrebbero chiudersi. E il processo inizia a guadagnare.

4- In questo ping pong ci si deve aspettare che al massimo 7 volte un ordine prenda il TakeProfit se non lo fa allora questi ordini vengono chiusi.

5-Per aprire l'opportunità di un aumento del profitto si dovrebbe usare un break even o un minimum profit trailing stop. per esempio, se vogliamo TakeProfit 2 pips allora aspettiamo che il prezzo raggiunga 3 pips e poi una di queste funzioni (break even o minimum profit trailing stop) mette una linea di stop al livello di 2 pips. Se il prezzo sale (per l'acquisto) allora la linea di stop andrà con esso e una volta che il prezzo rimbalza indietro di 1 pip l'ordine si chiude e perché ha un profitto tutti gli ordini aperti sono chiusi. Qui non sono sicuro che questo possa funzionare correttamente.

Grazie

Luis

 
luisneves:


Ciao RaptorUK,

Scusate il disordine. In questo momento sembra che l'EA stia facendo quello che ci si aspetta da lui, eccetto questo problema;

L'EA dovrebbe aprire un ordine opposto ogni volta che l'ordine precedente non prende il TakeProfit con un incremento della dimensione del lotto e con lo stesso importo di TakeProfit e lo fa, il problema è che deve mettere solo un ordine alla volta e ne mette più di uno. Dando un'occhiata al report si può vedere che l'ordine 6 e 7 sono entrambi di vendita e l'ordine 7 dovrebbe essere di acquisto.

Ora ho messo il codice per funzione. La ragione per cui ho tutte quelle chiamate nulle è che voglio avere un funzionamento completo di blocchi indipendenti e qui so che ho problemi a sistemare questo Il Go to Open e go to Close è solo un modo per dire che se non abbiamo ordini aperti i primi vanno ad aprire se no vanno a chiudere (è un casino devo lavorare su questo...) Sto usando simbolo e numero magico per garantire che l'ea si occupi solo dei propri ordini.

La strategia principale è (e i blocchi sono da questo ordine);

1- Due ordini pendenti sono sopra e sotto il prezzo. Una volta che il prezzo innesca uno di essi, il pendente opposto viene cancellato. Questo funziona.

2- Se il prezzo prende il TakeProfit allora l'ordine viene chiuso e l'EA riprende a mettere due ordini pendenti e il processo ricomincia. Questo funziona

2- se il prezzo non sceglie il TakeProfit e rimbalza una volta che il TakeProfit è sceso (per gli ordini di acquisto), allora si dovrebbe aprire un ordine di vendita opposto con lo stesso TakeProfit e con un lotto maggiore del precedente. Questo funziona, tranne per il fatto che mette più di un ordine e dal Report si può vedere che gli ordini 6 e 7 sono entrambi ordini di vendita e dovrebbero essere solo uno, il 7 dovrebbe essere un ordine di acquisto.

3- Una volta che l'ultimo ordine prende un profitto, tutti gli ordini aperti dovrebbero chiudersi. E il processo inizia a guadagnare.

4- In questo ping pong ci si deve aspettare che al massimo 7 volte un ordine prenda il TakeProfit se non lo fa allora questi ordini vengono chiusi.

5-Per aprire l'opportunità di un aumento del profitto si dovrebbe usare un break even o un minimum profit trailing stop. per esempio, se vogliamo TakeProfit 2 pips allora aspettiamo che il prezzo raggiunga 3 pips e poi una di queste funzioni (break even o minimum profit trailing stop) mette una linea di stop al livello di 2 pips. Se il prezzo sale (per l'acquisto) allora la linea di stop andrà con esso e una volta che il prezzo rimbalza indietro di 1 pip l'ordine si chiude e poiché ha un profitto tutti gli ordini aperti vengono chiusi. Qui non sono sicuro che questo possa funzionare correttamente.

Grazie

Luis

Ok, penso di aver trovato ciò che è sbagliato con l'apertura di diversi ordini. Ho dovutoincludere questi nel codice (Negrito Italic);

Open Opposite Order
 
   double  MartingaleBuyPrice = Ask+StopLevel;
   if(MartingaleBuyPrice<UpperStopLevel)MartingaleBuyPrice=UpperStopLevel+MinStop*pt;
   
   double MartingaleSellPrice= Bid-StopLevel;
   if(MartingaleSellPrice>LowerStopLevel)MartingaleSellPrice=LowerStopLevel-MinStop*pt;
   
   int Op;  
   
   for(int Counter = OrdersTotal()-1; Counter >= 0; Counter--)
      {
      if(OrderSelect(Counter,SELECT_BY_POS,MODE_TRADES))  
         {
         if(OrderSymbol() == Symbol()&& OrderMagicNumber() == MagicNumber)
            {
            Op = OrderType();

            if(Op == OP_BUY && ((OrderOpenPrice()-OrderClosePrice())/pt)> ReturnDist && SellTicket==0)
               {                
               Sell Ticket = OrderSend(Symbol(), OP_SELL, mlots, MartingaleSellPrice, UseSlippage, 0, 0, "Sell Order", MagicNumber, 0, Red);
               if(Sell Ticket > 0) 
                  {
                  Print("Opposite Sell order placed # ", SellTicket);
                  AddLimitsSell();
                  }
               else
                  {
                  Print("Order Send failed, error # ", GetLastError() );
                  }
               }
               
            if(Op == OP_SELL && (OrderClosePrice()-OrderOpenPrice()/pt)> ReturnDist && BuyTicket==0)
               {               
               Buy Ticket = OrderSend(Symbol(), OP_BUY, mlots, MartingaleBuyPrice, UseSlippage, 0, 0, "Buy Order", MagicNumber, 0, Green);
               if(Buy Ticket > 0)
                  {
                  Print("Opposite Buy order placed # ", BuyTicket);
                  AddLimitsBuy();
                  }
               else
                  {  
                  Print("Order Send failed, error # ", GetLastError());
                  }   
               }
            }
         }
      }
   }
//+------------------------------------------------------------------+  
void AddLimitsBuy()
                  {
                  OrderSelect(Buy Ticket,SELECT_BY_TICKET);
                  OpenPrice = OrderOpenPrice();
                  StopLevel = MarketInfo(Symbol(),MODE_STOPLEVEL)*Point;
                                       RefreshRates();  
                                      UpperStopLevel = Ask + StopLevel;
                                      LowerStopLevel = Bid - StopLevel;
                                      
                                      
                                      if(StopLoss > 0) BuyStopLoss   = OpenPrice - (StopLoss * pt);
                  if(TakeProfit > 0)BuyTakeProfit = OpenPrice + (TakeProfit * pt);
                                      
                                      if(BuyStopLoss > 0 && BuyStopLoss > LowerStopLevel) 
                                              {                                 
                                                    BuyStopLoss = LowerStopLevel - MinStop*pt;
                                              }
                                      
                                      if(BuyTakeProfit > 0 && BuyTakeProfit < UpperStopLevel) 
                                              {
                                                     BuyTakeProfit = UpperStopLevel + MinStop*pt;
                                              }

                                      if(IsTradeContextBusy())Sleep(10);        

                  if(BuyStopLoss > 0 || BuyTakeProfit > 0) 
                     {          
                      OrderModify(Ticket,OP_BUY,BuyStopLoss,BuyTakeProfit,0);                            
                     }
                    } 
//+------------------------------------------------------------------+
void AddLimitsSell()
                  {
                  OrderSelect(Sell Ticket,SELECT_BY_TICKET);                 
                  OpenPrice = OrderOpenPrice();
                  StopLevel = MarketInfo(Symbol(),MODE_STOPLEVEL)*Point;
                                      RefreshRates();   
                                      UpperStopLevel = Ask + StopLevel;
                                      LowerStopLevel = Bid - StopLevel;
                                      
                                      
                                      if(StopLoss > 0) SellStopLoss = OpenPrice + (StopLoss*pt);
                                      if(TakeProfit > 0) SellTakeProfit = OpenPrice - (TakeProfit*pt);
                                    
                                      if(SellStopLoss > 0 && SellStopLoss < UpperStopLevel) 
                                              {                                 
                                                    SellStopLoss = UpperStopLevel + MinStop*pt;
                                              }
                                      if(SellTakeProfit> 0 && SellTakeProfit > LowerStopLevel) 
                                              {
                                                    SellTakeProfit = LowerStopLevel - MinStop*pt;
                                              }
                                            
                                      if(IsTradeContextBusy()) Sleep(10);       

                  if(SellStopLoss > 0 || SellTakeProfit > 0) 
                    {           
                      OrderModify(Ticket,OP_SELL,SellStopLoss,SellTakeProfit,0);
                    }                    
                   }  


File di rapporto mancante
1234
Nuovo commento
Motivazione: