Controllo della candela aperta - pagina 4

Nuovo commento
 
GumRai:

Piccolo cambiamento in quanto stava controllando di chiudere un ordine quando non ce n'era uno.

Secondo il codice non c'è motivo che una vendita venga aperta immediatamente dopo la chiusura di un acquisto.

La condizione per uscire da un acquisto non è la stessa di quella per aprire una vendita.

Ricorda che siccome stai controllando solo l'apertura della candela, Close[0] sarà il valore dell'offerta del primo tick ricevuto per la candela.

Ciao GumRai,

Mi chiedevo se saresti in grado/volontario di aiutarmi un po' di più con il mio codice? Se potessi solo dirmi quali codici dovrei cercare, proverò a codificarlo da solo prima e poi tornerò con tutte le domande.

Quello che voglio è che una volta piazzato un trade, metta uno Stop loss a, diciamo, 50 pips (che è quello che fa ora). Tuttavia, una volta che il prezzo si muove di 60 pip nella direzione del trade, si sposta SL a pareggio, e più avanti diventa un trailing stop a 70 pip di distanza dal trade.

Come dovrei procedere per fare questo? Come sempre, qualsiasi aiuto sarebbe molto apprezzato.

 

Per il break-even, sposto sempre lo SL al break-even + 1 punto almeno. Questo evita ogni possibile problema di confronto dei doppi ai controlli successivi

Si tratta semplicemente di verificare 2 condizioni (per un acquisto)

OrderOpenPrice()>OrderStopLoss()

e

OrderClosePrice()-OrderOpenPrice>=BreakEvenPoints*Point

poi modificare l'ordine in modo che lo SL sia il prezzo aperto +1 punto o qualsiasi importo si decida di bloccare.

Per una vendita è la condizione opposta, ma si dovrebbe anche codificare per tenere conto di se SL è 0 inizialmente

OrderOpenPrice()>OrderStopLoss() || OrderStopLoss()==0
 
GumRai:

Per il break-even, sposto sempre lo SL al break-even + 1 punto almeno. Questo evita ogni possibile problema di confronto dei doppi ai controlli successivi

Si tratta semplicemente di verificare 2 condizioni (per un acquisto)

e

poi modificare l'ordine in modo che lo SL sia il prezzo aperto +1 punto o qualsiasi importo si decida di bloccare.

Per una vendita è la condizione opposta, ma si dovrebbe anche codificare per tenere conto di se SL è 0 inizialmente

Grazie mille. In effetti, quello che farò è aggiungere abbastanza punti in modo che copra solo (approssimativamente) il costo di intermediazione per il trade.

Per la seconda linea, perché dovrei usare Orderclose price-OrderOpenPrice? Non ho capito bene quel codice. Non dovrei usare Bid-OrderOpenPrice, dato che questo terrebbe traccia di quanto si è mosso il prezzo?

Sono almeno vicino a quello che sto facendo qui sotto?

 if(BuyTicket==-1)
        {
         if((iOpen(NULL,0,1)<PreviousSlow && PreviousPriceClose>=PreviousSlow && Bid>=(PreviousSlow+PipsBeforeEntry*Pips)) )
           {
            BuyTicket=OrderSend(Symbol(),OP_BUY,LotSize,Ask,Slippage,Ask-(StopLoss*Pips),0,"Main Entry EA",MagicNumber,0,clrLimeGreen);
           }
           if(OrderOpenPrice()>OrderStopLoss())
               if(Bid-OrderOpenPrice>=(BuyTicket+(Commission*LotSize)))
                  OrderModify(BuyTicket,NULL,Bid-(50*Point),NULL,NULL,clrNONE);
        }

Ho dichiarato la commissione sopra come un extern. E ho usato invece Bid.

Modifica:

Quindi immagino (in base a ciò che ho trovato qui sotto) che il codice che ho postato sopra non sia corretto? Ho trovato quanto segue nel libro/aiuto di MQL4... Sembra essere solo un trailing stop, mentre quello di cui ho bisogno è un Breakeven stop prima, seguito dal trailing stop. Come potrei modificarlo?

 int TrailingStop = 50;
               //--- modifies Stop Loss price for buy order 
            if(TrailingStop>0)
               {
               OrderSelect(BuyTicket,SELECT_BY_TICKET);
                if(Bid-OrderOpenPrice()>Point*TrailingStop)
                {
                if(OrderStopLoss()<Bid-Point*TrailingStop)
                  {
                  bool res =OrderModify(BuyTicket,OrderOpenPrice(),NormalizeDouble(Bid-Point*TrailingStop,Digits),OrderTakeProfit(),0,clrNONE);
                   if(!res)
                        Print("Error in OrderModify. Error code=",GetLastError());
                     else
                        Print("Order modified successfully.");
                    }
                 }
                 }
  
 if(BuyTicket==-1)
        {
         if((iOpen(NULL,0,1)<PreviousSlow && PreviousPriceClose>=PreviousSlow && Bid>=(PreviousSlow+PipsBeforeEntry*Pips)) )
           {
            BuyTicket=OrderSend(Symbol(),OP_BUY,LotSize,Ask,Slippage,Ask-(StopLoss*Pips),0,"Main Entry EA",MagicNumber,0,clrLimeGreen);
           }
           if(OrderOpenPrice()>OrderStopLoss())
               if(Bid-OrderOpenPrice>=(BuyTicket+(Commission*LotSize)))
                  OrderModify(BuyTicket,NULL,Bid-(50*Point),NULL,NULL,clrNONE);
        }

Tutto il tuo blocco di codice è condizionato a BuyTicket==-1

Se un ordine è aperto, allora BuyTicket non sarà = -1, quindi nessun controllo sarà fatto per passare a BE mentre la negoziazione è aperta.

if(Bid-OrderOpenPrice>=(BuyTicket+(Commission*LotSize)))

Cosa ha a che fare il numero di ticket con il prezzo?

È necessario selezionare un ordine prima di utilizzare OrderOpenPrice()

OrderClosePrice() è il Bid nel momento in cui l'ordine viene selezionato per l'acquisto, la domanda per la vendita (mentre l'ordine è ancora aperto)

 
SharkWaters:

Quindi immagino (in base a ciò che ho trovato qui sotto) che il codice che ho postato sopra non sia corretto? Ho trovato quanto segue nel libro/aiuto di MQL4... Sembra essere solo un trailing stop, mentre quello di cui ho bisogno è un Breakeven stop prima, seguito dal trailing stop. Come potrei modificarlo?

  int BreakEvenPoints=50;
  double BE_Decimal=BreakEvenPoints*Point;
//--- modifies Stop Loss price for buy order 
  if(BreakEvenPoints>0)
  {
   OrderSelect(BuyTicket,SELECT_BY_TICKET);
   if(Bid-OrderOpenPrice()>BE_Decimal)
     {
      if(OrderStopLoss()<OrderOpenPrice())
        {
         bool res=OrderModify(BuyTicket,OrderOpenPrice(),NormalizeDouble(OrderOpenPrice()+Point,Digits),
                              OrderTakeProfit(),0,clrNONE);
         if(!res)
            Print("Error in OrderModify to BE. Error code=",GetLastError());
         else
            Print("Order modified to BE successfully.");
        }
     }
  }
Prova questo
 
GumRai:
Prova questo

Grazie per i punti! Ho fatto le modifiche necessarie. Quando compilo, mostra un avviso che "il valore di ritorno di 'OrderSelect' dovrebbe essere controllato". Questo, stranamente, si traduce in un solo acquisto che viene attivato e poi per il resto è di nuovo un codice di errore 4108. Sell funziona bene (non ho apportato alcuna modifica a questo).

Ecco l'intera sezione del codice di acquisto, nel caso stia facendo qualcosa di sbagliato - ma quella parte non dovrebbe esserlo, dato che tutto ciò che ho aggiunto è questo codice nel mezzo. Il resto era come prima che funzionava perfettamente bene. Cosa sto sbagliando qui?

int start()
  {
   static datetime bar_time=0;
   if(bar_time!=Time[0])
     {
      bar_time=Time[0];
      double PreviousSlow=iMA(NULL,0,SlowMa,SlowMaShift,SlowMaMethod,SlowMaAppliedTo,1);
      double PreviousSlow2=iMA(NULL,0,SlowMa,SlowMaShift,SlowMaMethod,SlowMaAppliedTo,2);
      double PreviousPriceClose=iClose(NULL,0,1);   //You can just use Close[1]
      double PreviousPriceClose2=iClose(NULL,0,2);
      if(BuyTicket==-1)
        {
         if((iOpen(NULL,0,1)<PreviousSlow && PreviousPriceClose>=PreviousSlow && Bid>=(PreviousSlow+PipsBeforeEntry*Pips)) )
           {
            BuyTicket=OrderSend(Symbol(),OP_BUY,LotSize,Ask,Slippage,Ask-(StopLoss*Pips),0,"Main Entry EA",MagicNumber,0,clrLimeGreen);
               }
           }
   //Stop Order Modify for buy starts here
         int BreakEvenPoints=50;
         double BE_Decimal=BreakEvenPoints*Point;
         
         if(BreakEvenPoints>0)
              {
               OrderSelect(BuyTicket,SELECT_BY_TICKET);
               if(Bid-OrderOpenPrice()>BE_Decimal)
                 {
                  if(OrderStopLoss()<OrderOpenPrice())
                    {
                     bool res=OrderModify(BuyTicket,OrderOpenPrice(),NormalizeDouble(OrderOpenPrice()+Point,Digits),OrderTakeProfit(),0,clrNONE);
                     if(!res)
                        Print("Error in OrderModify to BE. Error code=",GetLastError());
                     else
                        Print("Order modified to BE successfully.");
                    }
                 }
              }
      else
      if(OrderSelect(BuyTicket,SELECT_BY_TICKET))
        {
         if(OrderCloseTime()==0)
           {
            if(Close[0]<PreviousSlow)
              {
               bool CloseTicket=OrderClose(BuyTicket,LotSize,Bid,Slippage,clrPink);
               if(CloseTicket)
                  BuyTicket=-1;
              }
           }
         else
            BuyTicket=-1; //Order has closed so reset variable
        }
        

Aggiornamento:

Googlato un po' di più, e l'ho cambiato con il seguente:

int BreakEvenPoints=50;
         double BE_Decimal=BreakEvenPoints*Point;
         
         if(BreakEvenPoints>0)
              {
               if (OrderSelect(BuyTicket,SELECT_BY_TICKET))
               {
               if(Bid-OrderOpenPrice()>BE_Decimal)
                 {
                  if(OrderStopLoss()<OrderOpenPrice())
                    {
                     bool res=OrderModify(BuyTicket,OrderOpenPrice(),NormalizeDouble(OrderOpenPrice()+10*Point,Digits),OrderTakeProfit(),0,clrNONE);
                     if(!res)
                        Print("Error in OrderModify to BE. Error code=",GetLastError());
                     else
                        Print("Order modified to BE successfully.");
                    }
                  }  
                 }
              }


Questo rimuove l'errore generato quando faccio clic su compila. Ma crea ancora l'errore OrderModify 4108 nel Journal.

 

Tutto il tuo codice è contenuto nella condizione if

 if(bar_time!=Time[0])  

quindi viene eseguito solo una volta per ogni nuova barra.

 

Quando BuyTicket == -1 state cercando di selezionare l'ordine con un numero di biglietto di -1 e naturalmente non esiste

Controlla che BuyTicket>0 prima di provare a selezionare un ordine

 
GumRai:

Tutto il tuo codice è contenuto nella condizione if

quindi viene eseguito solo una volta per ogni nuova barra.


Grazie per avermelo fatto notare.

Quindi, per questo, ho creato una parentesi extra in alto, subito dopo Start come:

int start() 
{
{

e poi ho chiuso una parentesi (che chiudeva l'intera sezioneif(bar_time!=Time[0]) e poi ho messo il codice alla fine seguito da un return (0); e una parentesi finale per chiudere la start().

Nessun errore, né nel codice, né nel backtest Journal, ma ha preso solo un'operazione di acquisto e basta - anche questa chiusa proprio all'apertura, anche se il prezzo non si è mosso più in alto dall'apertura - per non parlare del movimento di 50 pips.

Penso che questo potrebbe avere a che fare con il BuyTicket che è == -1 che hai menzionato. Ma onestamente non ho idea di come cambiarlo. Ho messo quella cosa -1 in base alle tue raccomandazioni per il codice iniziale - che ha funzionato in modo fantastico. Ma come potreicontrollare che BuyTicket>0 prima di provare a selezionare un ordine?

 
SharkWaters:

Ma come potreicontrollare che BuyTicket>0 prima di provare a selezionare un ordine?

Mi dispiace, ma se devi chiedere questo, stai cercando di scrivere un codice troppo complicato per il tuo livello di conoscenza.

Non posso scrivere il tuo codice un po' alla volta.

12345
Nuovo commento
Motivazione: