Qualsiasi domanda da principiante, per non ingombrare il forum. Professionisti, non passate oltre. Da nessuna parte senza di te - 6. - pagina 155

Nuovo commento
 

Se uno degli ordini pendenti scatta, allora piazzo un altro ordine pendente nella direzione opposta e raddoppio il volume, per esempio, se piazzo buy, allora piazzo sellstop 25 pips più basso di buy, e se piazzo sell, allora piazzo buystop 25 pips più alto. Se uno degli ordini pendenti scatta, piazziamo un altro ordine pendente nella direzione opposta a quello scattato, al prezzo del primo ordine aperto, e se anche questo scatta, piazziamo di nuovo un ordine pendente nella direzione opposta a quello scattato entro 25 punti, ecc. Quindi, tutti gli ordini di acquisto dovrebbero essere ad un prezzo, e tutti gli ordini di vendita dovrebbero essere anche ad un prezzo. Se qualcuno capisce quello che ho scritto qui, per favore aiutatemi con il codice))

int A = 0;
if (OrdersTotal()==0)
   {
   A = 0;
   if ( Close[2] < Close[1])
      {
      OrderSend (Symbol(),OP_BUY,1,Ask,3,Ask-50*Point,Ask+25*Point,0,1);                 // первый вариант событий
      OrderSend (Symbol(),OP_SELLSTOP,2,Bid-25*Point,3,Bid+25*Point,Bid-50*Point,0,2);
      A=1;
      }
      
   if ( Close[2] > Close[1])
      {
      OrderSend (Symbol(),OP_SELL,1,Bid,3,Bid+50*Point,Bid-25*Point,0,1);               //второй вариант событий
      OrderSend (Symbol(),OP_BUYSTOP,2,Ask+25*Point,3,Ask-25*Point,Ask+50*Point,0,2);
      A=2;
      }
   }
//------------------------------------------------------------------------------------------------------------------+
OrderSelect(1,SELECT_BY_TICKET,MODE_TRADES);            //цена открытия первого ордера
int price = OrderOpenPrice();
//------------------------------------------------------------------------------------------------------------------+   
int sells = 0;                                                                                                                              
for (int B = 0; B < OrdersTotal(); B++)
   {
   OrderSelect (B,SELECT_BY_POS,MODE_TRADES);       //количество ордеров sell
   if (OrderType() == OP_SELL) sells++;
   }
   
int buys = 0;                                                                                                                        
for (int b = 0; b < OrdersTotal(); b++)
   {
   OrderSelect (b,SELECT_BY_POS,MODE_TRADES);       //количество ордеров buy 
   if (OrderType() == OP_BUY) buys++;
   }
int sellstops = 0;                                                                                                                              
for (int C = 0; C < OrdersTotal(); C++)
   {
   OrderSelect (C,SELECT_BY_POS,MODE_TRADES);       //количество ордеров sellstop
   if (OrderType() == OP_SELL) sellstops++;
   }

int buystops = 0;                                                                                                                        
for (int c = 0; c < OrdersTotal(); c++)
   {
   OrderSelect (c,SELECT_BY_POS,MODE_TRADES);       //количество ордеров buystop 
   if (OrderType() == OP_BUY) buystops++;
   }
//-----------------------------------------------------------------------------------------------------------------+
if (OrdersTotal()==1)
   {                                               //удаление отложенного ордера..
   OrderDelete(2);                                 //..который остался после срабатываения tp и sl
   }  
//-----------------------------------------------------------------------------------------------------------------+
if (OrdersTotal()>1 && A ==1)
   {
   if (sells == buys && buystops == 0)
      {
      OrderSend (Symbol(),OP_BUYSTOP,2,price,3,price-50*Point,price+25*Point,0,2);     //условия для первого варианта
      }
   if (buys > sells && sellstops == 0)
      {
      OrderSend (Symbol(),OP_SELLSTOP,2,price-28*Point,3,price+22*Point,price-53*Point,0,2);
      }
   }
   
if (OrdersTotal()>1 && A ==2)
   {
   if (sells == buys && sellstops == 0)
      {
      OrderSend (Symbol(),OP_SELLSTOP,1,price,3,price+50*Point,price-25*Point,0,2);     //условия для второго варианта
      }
   if (buys < sells && buystops == 0) 
      {
      OrderSend (Symbol(),OP_BUYSTOP,2,price+22*Point,3,price-28*Point,price+47*Point,0,2);
      }
   }
//-----------------------------------------------------------------------------------------------------------------+
   
   return(0);
   }
 
artmedia70:
Questo viene da un indicatore o da un EA? C'è una differenza. In generale, per evitare di disegnare la freccia, è necessario controllare la barra adiacente precedente nell'indicatore e se ha un valore non zero o non vuoto, significa che la freccia sulla barra adiacente esiste già e non c'è bisogno di inserire il valore nel buffer della barra corrente. Per un EA, se la precedente barra adiacente contiene già un fatto di incrocio nella stessa direzione di quella attuale e la freccia segna già questo fatto, il fatto di incrocio sulla barra attuale può non essere registrato (se esiste) e la freccia non deve nemmeno essere visualizzata.
Non posso dirvi altro sul vostro codice. Se ci sono telepati in giro, probabilmente saranno in grado di capire il tuo codice in misura maggiore ;)

Questo è dall'indicatore. Intersezione di 2 slittamenti, dà la direzione. Non capisco bene, la direzione è data solo quando si attraversa non su ogni barra. Da qui, giudicare dalla barra precedente è impossibile.... Mi dica, stiamo costruendo una serie, vero? Come controllare la cella precedente? Due buffer uno CrossUp[i]=Low[i] - Range*0.75;, un altro diciamo Cr[i]=Low[i] + Range*0.75; (non voglio entrare di nuovo nelle cartelle e nel codice)
 
zaqwsx123:

Se uno degli ordini pendenti scatta, allora piazzo un altro ordine pendente nella direzione opposta e raddoppio il volume, per esempio, se piazzo buy, allora piazzo sellstop 25 pips più basso di buy, e se piazzo sell, allora piazzo buystop 25 pips più alto. Se uno degli ordini pendenti scatta, piazziamo un altro ordine pendente nella direzione opposta a quello scattato, al prezzo del primo ordine aperto, e se anche questo scatta, piazziamo di nuovo un ordine pendente nella direzione opposta a quello scattato entro 25 punti, ecc. Quindi, tutti gli ordini di acquisto dovrebbero essere ad un prezzo, e tutti gli ordini di vendita dovrebbero anche essere ad un prezzo. Se qualcuno capisce quello che ho scritto qui, per favore mi aiuti con il codice))

Hai scritto un sacco di sciocchezze... Almeno questo:

OrderSelect(1,SELECT_BY_TICKET,MODE_TRADES);            //цена открытия первого ордера

sei sicuro che l'ordine sia stato scelto? Sei sicuro che il prezzo sia questo? Sei sicuro che l'ordine ha un biglietto == 1? Quando si seleziona per biglietto, il pool è irrilevante, quindi MODE_TRADES è superfluo. Dopo aver effettuato con successo la selezione per ticket, dovremmo anche controllare il tempo di chiusura dell'ordine selezionato. Se == 0, l'ordine è a mercato ed è stato selezionato dalla lista degli ordini a mercato. Se il tempo di chiusura > 0, l'ordine è stato chiuso o è un ordine pendente cancellato ed è stato selezionato dalla lista degli ordini chiusi.

Non voglio approfondire il codice. Forse, dovreste prima familiarizzare con le basi. Leggete il tutorial e la documentazione - sono in un posto ben visibile qui.

 
artmedia70:


Non voglio approfondire il codice...


che ha catturato la mia attenzione)) Perché 4 pulcini identici? e il campione non è quello che c'è nel commento

if (OrderType() == OP_BUY) buystops++   //количество ордеров buystop

Lo stesso vale per selstop. avete bisogno di OP_BUYSTOP e OP_SELLSTOP

 
ALXIMIKS:


che ha catturato la mia attenzione)) Perché 4 pulcini identici? e il campione non è quello che c'è nel commento

simile con selestop. avete bisogno di OP_BUYSTOP e OP_SELLSTOP

Non sono arrivato a quel punto. Quando guardi il codice e vedi che non devi spiegare gli errori, ma solo iniziare a insegnare a una persona dalle basi, che potrebbe leggere da sola, allora... ...non voglio. Si può insegnare a pagamento, ma non dove si aiuta solo a trovare gli errori nel codice e non il codice tra gli errori.
 
Zolotai:

Questo è dall'indicatore. Intersezione di 2 diapositive, dà la direzione. Non ho capito bene, dà solo la direzione quando si attraversa, non su ogni barra. Da qui, è impossibile giudicare dal precedente bar.... Mi dica, stiamo costruendo una serie, vero? Come controllare la cella precedente? Ci sono due buffer: uno CrossUp[i]=Low[i] - Range*0.75; e un altro, diciamo, Cr[i]=Low[i] + Range*0.75; (non voglio cercare ancora nelle cartelle e nel codice).
Non ci sono dati di origine. Prova a cercare qui.
 
C'è un ordine BUY_STOP che è stato cancellato prima dell'esecuzione:




Controllare il codice:
            for(int cnt_1=OrdersHistoryTotal()-1; cnt_1>=0; cnt_1--) {
               if(OrderSelect(cnt_1, SELECT_BY_POS, MODE_HISTORY)==true ) {
                  if(OrderSymbol()==Symbol()   &&   OrderCloseTime()!=0   &&   OrderMagicNumber()==My_Magic_Number ) {
                     Print("OrderProfit()=",OrderProfit(), "   OrderCloseTime()=",TimeToStr(OrderCloseTime(),TIME_DATE|TIME_SECONDS), "   OrderType()=",OrderType(), "   OrderTicket()=",OrderTicket(), "   OrderClosePrice()=",OrderClosePrice(), "   OrderOpenPrice()=",OrderOpenPrice() );
                  } // if(OrderSymbol()==Symbol()   &&   OrderCloseTime()!=0   &&   OrderMagicNumber()==My_Magic_Number ) {
               }
            } // for(int cnt_1=0; cnt_1<OrdersHistoryTotal(); cnt_1++) {

Stringa con risultato:
OrderProfit()=0   OrderCloseTime()=2001.01.26 06:15:00   OrderType()=4   OrderTicket()=24   OrderClosePrice()=0.9237   OrderOpenPrice()=0.9419

1, OrderType=4 - "4" è OP_SELLLIMIT, giusto?
2. OrderClosePrice()=0.9237 OrderOpenPrice()=0.9419 - Da dove viene il valore di OrderClosePrice() non uguale a OrderOpenPrice()?

 
chief2000:

C'è un ordine BUY_STOP che è stato cancellato prima dell'esecuzione:




Controllare il codice:

Stringa con risultato:

1, OrderType=4 - "4" è OP_SELLLIMIT, giusto?
2. OrderClosePrice()=0.9237 OrderOpenPrice()=0.9419 - da dove viene il valore OrderClosePrice() non uguale a OrderOpenPrice()?

e nella modalità di visualizzazione del tester, su tutti i tick, in modalità passo-passo (F12 in pausa) trovare il momento della sua rimozione e guardare il prezzo corrente, forse lì il cane è nascosto?
 
artmedia70:
e tu nel tester in modalità visualizzazione, sì su tutti i tick, in modalità step (F12 in pausa) trovi il momento della sua rimozione e vedi il prezzo attuale, forse è lì che il cane è sepolto?


BINGO! Non lo sapevo, ma tutto come hai scritto, cioè il prezzo di chiusura in questo caso è il valore del prezzo al momento in cui l'ordine è stato cancellato. Grazie!
 

Spesso dichiaravo una variabile come questa all'interno delle funzioni:

int err = GetLastError();

Più all'interno, a qualche condizione lo chiamo già per vedere se c'è un errore. Beh, non sono solo io, ma molti altri posti nel codice che ho incontrato. Quindi, per dire, è una situazione tipica. Oggi ho pensato che non è logico dichiarare ogni volta la stessa variabile in ogni funzione in cui si vogliono controllare gli errori. Ci ho pensato e sono arrivato alla conclusione che è più facile dichiarare globalmente una volta e inizializzarlo nell'init. Funziona così:

// Объявили на глобальном уровне
int err;

// Инициируем данную переменную:
int init()
{
    err = GetLastError();
}

E inoltre, quando avete bisogno di chiamare la variabile err nelle funzioni utente, sapendo che ha già un valore. In effetti, GetLastError() emette il codice dell'ultimo errore, quindi se questa variabile err viene chiamata in ogni funzione alla fine di tutti i calcoli, che è responsabile di emettere il codice di errore, e chiama GetLastError(), allora tutto sarà corretto, giusto?

Ma se non chiamate questa variabile alla fine di qualche funzione (seguendo la catena di esecuzione del codice), non si resetterà, e potrebbe essere un'esecuzione sbagliata, nel caso in cui ci fosse un errore nella catena di esecuzione precedente, ma non in quella attuale, ma il codice di errore viene restituito per ultimo... E per resettarlo, dovete chiamare questa funzione GetLastError(). Cioè qui tutto dipende dal fatto che sia stato chiamato o meno. Se non si è sicuri che sarà ovunque, è più facile riassicurarsi e azzerare ogni volta, giusto?

1...148149150151152153154155156157158159160161162...1178
Nuovo commento