Come implementare la chiusura delle posizioni una alla volta dopo N minuti?

 

mql4
Per esempio, sono passati 5 minuti dall'apertura dell'ordine e questo ordine dovrebbe chiudersi.
Il codice è troppo ingombrante per memorizzare il biglietto da chiudere e il tempo di apertura da utilizzare per calcolare i minuti per ogni ordine separatamente.
Ci possono essere 1,2,3-10 posizioni, comprare e vendere allo stesso tempo.

Puoi suggerire una funzione per memorizzare questi dati in un array per confrontare ulteriormente e chiudere sul biglietto richiesto?


 
Dopo tutto, tutti i biglietti e gli orari di apertura sono già presenti negli array standard.
Passare attraverso tutte le posizioni per timer e confrontare TimeCurrent()-OrderOpenTime()>=300
 
Taras Slobodyanik:
Dopo tutto, tutti i biglietti e gli orari di apertura sono già presenti negli array standard.
Enumeriamo tutte le posizioni per timer e confrontiamo TimeCurrent()-OrderOpenTime()>=300

Cosa sono questi array standard?
Può spiegarsi meglio?

 
funzioni MQL standard, non array
Торговые функции - Справочник MQL4
Торговые функции - Справочник MQL4
  • docs.mql4.com
Торговые функции могут использоваться в экспертах и скриптах. Торговые функции OrderSend(), OrderClose(), OrderCloseBy(), OrderModify(), OrderDelete(), изменяющие состояние...
 

Come posso usare queste funzioni per chiudere le posizioni individualmente e non tutte insieme dopo 5 minuti?

C'è la prima posizione aperta, abbiamo registrato il tempo e il biglietto
nella variabile, poi la seconda posizione aperta, la vediamo nel ciclo come l'ultima e la registriamo nella variabile tempo e biglietto
, ma tutte queste azioni sono sovrascritte e risulta che i dati sono memorizzati solo dall'ultima posizione

 
Natalya Dzerzhinskaya:

Come posso usare queste funzioni per chiudere le posizioni individualmente e non tutte insieme dopo 5 minuti?

C'è la prima posizione aperta, l'abbiamo registrata nella variabile tempo e biglietto
poi la seconda posizione aperta, la vediamo nel ciclo come l'ultima e la registriamo nella variabile tempo e biglietto
ma tutte queste azioni sono sovrascritte e risulta che i dati sono memorizzati solo dall'ultima posizione

La condizione di selezionare un solo ordine tra quelli che dobbiamo chiudere non prima di 5 minuti dalla sua apertura non è molto chiara.

Pertanto, non so cosa rispondere.

Se c'è una condizione, dovremmo iniziare con quella.

Al momento, tutti sono stati virtualmente selezionati e saranno chiusi in un mucchio, uno dopo l'altro.

Il primissimo ordine aperto ha questo: TimeCurrent()-OrderOpenTime() sarà il più grande per esempio, il suo OrderTicket().

Potete passare attraverso tutti i vostri ordini di mercato nel seguente ciclo

int i;      
     for (i=OrdersTotal()-1; i>=0; i--)
         {
            if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
               {
                  ............
               }
         }
 
Natalya Dzerzhinskaya:

mql4
Per esempio, sono passati 5 minuti dall'apertura dell'ordine e questo ordine deve essere chiuso.

Date un'occhiata alle funzioni di Kim Igor.

Qui, a colpo d'occhio, la funzione restituisce il numero di secondi dopo che l'ultima posizione è stata aperta.

//+----------------------------------------------------------------------------+
//|  Автор    : Ким Игорь В. aka KimIV,  http://www.kimiv.ru                   |
//+----------------------------------------------------------------------------+
//|  Версия   : 19.02.2008                                                     |
//|  Описание : Возвращает количество секунд после открытия последней позиций. |
//+----------------------------------------------------------------------------+
//|  Параметры:                                                                |
//|    sy - наименование инструмента   (""   - любой символ,                   |
//|                                     NULL - текущий символ)                 |
//|    op - операция                   (-1   - любая позиция)                  |
//|    mn - MagicNumber                (-1   - любой магик)                    |
//+----------------------------------------------------------------------------+
datetime SecondsAfterOpenLastPos(string sy="", int op=-1, int mn=-1) {
  datetime t=0;
  int      i, k=OrdersTotal();

  if (sy=="0") sy=Symbol();
  for (i=0; i<k; i++) {
    if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) {
      if (OrderSymbol()==sy || sy=="") {
        if (OrderType()==OP_BUY || OrderType()==OP_SELL) {
          if (op<0 || OrderType()==op) {
            if (mn<0 || OrderMagicNumber()==mn) {
              if (t<OrderOpenTime()) t=OrderOpenTime();
            }
          }
        }
      }
    }
  }
  return(TimeCurrent()-t);
}

Rivedilo per adattarlo al tuo compito. Aggiungete la funzione che chiude una posizione.

 
Renat Akhtyamov:

Non è chiaro se si tratta di un ordine che deve essere chiuso almeno 5 minuti dopo l'apertura.

Lasciatemi spiegare in modo più semplice:

C'è il 1° ordine nel mercato, poi il 2°, il 3° e così via.
Il tempo del primo ordine è scaduto e dovremmo chiuderlo, poi il 2° ordine è il primo della serie, il tempo è scaduto e dovremmo chiuderlo, ecc.
Infatti, dovremmo scegliere l'ordine più vecchio da chiudere se è >=5*60
Ma per selezionarlo da una serie da chiudere con il biglietto, dovremmo in qualche modo definire il valore più piccolo del biglietto negli ordini aperti e determinare il tempo di esistenza.

Aleksandr Volotko:

Date un'occhiata alle funzioni di Kim Igor.

Qui, a colpo d'occhio, la funzione restituisce il numero di secondi dopo che l'ultima posizione è stata aperta.

Non si adatta. Interessato alla prima posizione sul mercato.

 
Natalya Dzerzhinskaya:

La farò semplice:

C'è il 1° ordine sul mercato, poi il 2° ordine, il 3° e così via.
Il tempo del primo ordine è scaduto, quindi il 2° ordine è il primo della serie, il tempo è scaduto, dovrebbe essere chiuso, ecc.
Infatti, dovremmo scegliere l'ordine più vecchio da chiudere se è >=5*60
Ma per selezionarlo da una serie da chiudere con il biglietto, dovremmo in qualche modo definire il valore più piccolo del biglietto negli ordini aperti e determinare il tempo di esistenza.

Non si adatta. Interessato alla prima posizione sul mercato.


Qual è il problema?

  1. Trova l'ordine più vecchio aperto dall'Expert Advisor. Ha il più piccolo OrderOpenTime().
  2. Confronta quanto tempo è passato dal momento dell'apertura di questo ordine all'ora corrente. Se è uguale o superiore al tempo specificato, lo chiude.
int nOlderTicket = -1;
datetime dtOlderOrderTime = D'3000.12.30';
for (int i = OrdersTotal() - 1; i >= 0; --i)
{
   if (!OrderSelect(i, SELECT_BY_POS))
      continue;

   if (OrderSymbol() != Symbol())
      continue;

   if (OrderMagicNumber() != i_nMagicNumber)
      continue;

   if (nOlderTicket < 0 || OrderOpenTime() < dtOlderOrderTime)
   {
      nOlderTicket = OrderTicket();
      dtOlderOrderTime = OrderOpenTime();
   }
}

if (TimeCurrent() - dtOlderOrderTime >= время в секундах)
{
   // Закрыть ордер nOlderTicket
}


 
Natalya Dzerzhinskaya:

La farò semplice:

Il 1° ordine è sul mercato, poi il 2°, il 3° e così via.
Il tempo del primo ordine è scaduto e dovremmo chiuderlo, poi il 2° ordine è il primo della serie, il tempo è scaduto e dovremmo chiuderlo, ecc.
Infatti, dovremmo scegliere l'ordine più vecchio da chiudere se è >=5*60
Ma per selezionarlo da una serie da chiudere con il biglietto, dovremmo in qualche modo definire il valore più piccolo del biglietto negli ordini aperti e determinare il tempo di esistenza.

Non si adatta. Siete interessati alla prima posizione sul mercato.

In termini di tempo di esistenza, è possibile selezionare sia il primo ordine aperto che quello più recente. In questo caso ricordiamo il biglietto e il numero di secondi di esistenza. Per esempio

int i, DeltaTimeOpen, prevDeltaMax, prevDeltaMin, TicketFirst, TicketLast, DeltaTimeClose;  
//---------------
prevDeltaMax=0; prevDeltaMin=9999999999999; TicketFirst=0; TicketLast=0; DeltaTimeClose = 5*60;     
     for (i=OrdersTotal()-1; i>=0; i--)
         {            
            if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES))
               { 
                  DeltaTimeOpen = TimeCurrent()-OrderOpenTime();//возраст ордера в секундах
                  if(DeltaTimeOpen>=DeltaTimeClose)
                  {
                     if(DeltaTimeOpen>prevDeltaMax)
                     {                         
                         TicketLast=OrderTicket();//последний  
                         prevDeltaMax=DeltaTimeOpen;//возраст                    
                     }
                     if(DeltaTimeOpen<prevDeltaMin)
                     {
                         TicketFirst=OrderTicket(); //первый
                         prevDeltaMin=DeltaTimeOpen;//возраст                                              
                     }
                  }
               }
         }
if(TicketFirst>0)
{
//ну и пошло-поехало...
}

 

Il modo più semplice è quello di inserire nel campo dei commenti l'ora in cui l'ordine dovrebbe essere chiuso.

Allora devi solo ricordare l'ora più vicina alla chiusura (e anche in quel caso, è l'ottimizzazione).

Quando è il momento della "revisione", con un timer o quello che volete, fate un ciclo degli ordini aperti e chiudete quelli la cui durata supera il tempo specificato nel commento