Un minuto e mezzo di differenza tra l'ora locale e l'ora fresca di zecca. Cosa fare. - pagina 2

Nuovo commento
 
prostotrader:

C'è il codice sorgente con i commenti.

Troppo pigro per guardarlo? O c'è qualcosa che non capisce?

L'ho fatto. Ho avuto l'idea senza il codice. Non capisco perché mi consigli:

prostotrader:

Devi aggiungere gli strumenti più liquidi a Market Watch.

Poi, aggiungere strati di questi strumenti.

E, quando OnBookEvent() si innesca, copia 1 tick (ultimo) ci sarà un tempo e immediatamente prendere il tempo locale e confrontare.

In che modo il tuo metodo è migliore?

 
pivomoe:

Ho dato un'occhiata. Ho avuto l'idea senza il codice. Non capisco perché mi consigli:

Perché il tuo metodo è migliore?

Perché è quello giusto!

Ho fatto un errore, non l'ora locale, ma l'ora del server.

1. Le zecche arrivano al terminale in pacchetti.

2. Ogni pacchetto successivo può contenere tick che non sono stati "impilati" nel pacchetto precedente, ma hanno lo stesso tempo del precedente.

3. OnBookEvent() si attiva all'arrivo di qualsiasi tick (cambiamento di prezzo, volume) cioè ogni tick. (si attiva un timer - già male).

4. Si usa il tempo del computer locale, che non è affatto necessario!

 

Qui c'è effettivamente tutto ciò di cui hai bisogno per fare trading (controlla gli orari delle sessioni di trading)

//+------------------------------------------------------------------+
//|                                                         Time.mq5 |
//|                                                   Copyright 2019 |
//|                                                                  |
//+------------------------------------------------------------------+
int is_book;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
  is_book = MarketBookAdd(Symbol());
  if(is_book == false) return(INIT_FAILED);
  return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
  if(is_book == true) MarketBookRelease(Symbol()); 
}
//+------------------------------------------------------------------+
// Expert Book event function                                        |
//+------------------------------------------------------------------+  
void OnBookEvent(const string &symbol)
{
  if(symbol == Symbol())
  {
    if(CheckMarketTime() == true)
    {
     //Торговое время
     //Наш код
    }
  }
}
//+------------------------------------------------------------------+
//| Expert Check Market Time function                                |
//+------------------------------------------------------------------+
bool CheckMarketTime()
{
  MqlDateTime cur_time, sv_time;
  MqlTick ticks[];
  cur_time.year = 0;
  TimeTradeServer(cur_time); //Возвращает расчетное текущее время торгового сервера.
  if(cur_time.year > 0)
  {
    int result = CopyTicks(Symbol(), ticks, COPY_TICKS_ALL, 0, 1);
    if(result > 0)
    {
      if(TimeToStruct(ticks[0].time, sv_time) == true)
      {
        if(sv_time.day_of_year == cur_time.day_of_year)      //Проверка, что это сегодняшний тик
        {
          ulong tr_time = sv_time.hour * 3600 + sv_time.min * 60 + sv_time.sec;
          if(((tr_time >= 3600) && (tr_time < 50370)) ||   //10:00:00 - 13:59:30
             ((tr_time >= 50700) && (tr_time < 67470)) ||  //14:05:00 - 19:44:30 
             ((tr_time >= 68700) && (tr_time < 85770)))    //19:05:00 - 23:49:30
          {
            return(true);
          }
        }
      }
    }
  }   
  return(false);
}

Aggiunto da

Se avete bisogno di una precisione al millisecondo, allora questo

double t_msc = double(ticks[0].time_msc - ulong(ticks[0].time) * 1000)/1000; //Получаем в секундах
double tr_time = sv_time.hour * 3600 + sv_time.min * 60 + sv_time.sec + t_msc;

Aggiunto

Ma tutto questo non darà il risultato desiderato (i limiti del tempo di trading) perché

non ci possono essere tick in una sessione di trading, e il tempo non si ferma.

Supponiamo che qualcuno abbia rimosso il suo ordine pendente, il ticker è cambiato,

c'è un segnale ma c'è una correlazione "vecchia" (il tempo non è quello attuale).

Il terminale non trasmette l'ora esatta del server.

 

Tu non mi capisci. Cominciamo dall'inizio.

1) Nel vostro programma, chiamate TimeCurrent() e ottenete il tempo di arrivo dell'ultima quotazione per uno dei simboli selezionati in Market Watch.

Che siano le 18:00:00.

2) Con il prossimo comando, si ottiene il tempo dell'ultimo tick SBER.

Che sia 17:58:00

3) Passa un po' di tempo e richiedete di nuovo l'ora dell'ultimo tick di SBER.

Che siano le 17:59:00


Notate la domanda: pensate che vada bene alle 18:00:00 da TimeCurrent() non sapere del tick con tempo 17:59:00 ?

 
pivomoe:

Tu non mi capisci. Cominciamo dall'inizio.

1) Nel vostro programma, chiamate TimeCurrent() e ottenete il tempo di arrivo dell'ultima quotazione per uno dei simboli selezionati in Market Watch.

Che siano le 18:00:00.

2) Con il prossimo comando, si ottiene il tempo dell'ultimo tick SBER.

Che sia 17:58:00

3) Passa un po' di tempo e richiedete di nuovo l'ora dell'ultimo tick di SBER.

Che siano le 17:59:00


Domanda di attenzione: pensate che sia normale non sapere di un tick con tempo 17:59:00 da TimeCurrent() alle 18:00:00 ?

Nel codice che ho citato si può tenere conto di tutti i tic (nessun problema)

L'ultimo codice non usa TineCurrent() maTimeTradeServer() - questa volta è necessario solo

per controllare la zecca con una precisione di un giorno e basta!

Cominciamo dall'inizio.

In generale, cosa vuoi fare per scoprirlo?

Perché hai iniziato a confrontare l'ora della zecca con l'ora locale?

Qual è lo scopo originale?

 

Ora vi mostrerò come si presenta questo problema nella pratica. Ho completamente ridisegnato l'Expert Advisor. Ho reso possibile la cattura di nuovi tick in OnTimer così come in OnBookEvent.

Ci sono 45 simboli in Market Watch. La maggior parte di loro non sono liquidi.

Ecco il risultato della cattura di nuovi tick in OnBookEvent:

РЕКОРДная  Разница между временем последенго тика по ВСЕМ символам Минус только, что полученный новый тик по символу 494013 милесекундa.

CR      0       18:51:47.334    ProverkaAktyalnostiTikov (ALRS,H1)       Получен НОВЫЙ тик по символу                     SNGR-3.19 time_msc= 2019.03.18 18:41:47.988

HN      0       18:51:47.335    ProverkaAktyalnostiTikov (ALRS,H1)       ХОТЯ до этого был получeн тик                        ARMD time_msc 2019.03.18 18:50:02.001

Cioè un nuovo tick è stato catturato alle 18:50 su TimeCurrent per il simboloSNGR-3.19 con un tempo di 18:41.


Poi ci sono le misurazioni del tempo del computer locale al momento:


1) ottenere un nuovo tick, cioè al momento dell'ultima chiamata di CopyTick (o SymbolInfo a seconda delle impostazioni).

2) Il momento dell'ultima chiamata.

18:51:47.335    ProverkaAktyalnostiTikov (ALRS,H1)       Локальное время получения нового тика по символу.                      2019.03.18 18:51:47.334

18:51:47.335    ProverkaAktyalnostiTikov (ALRS,H1)       Предпоследние Локальное время попытки получить новый тик по символу    2019.03.18 18:41:47.204


Quindi in questo caso il problema si è verificato perché la funzione get new non è stata chiamata per 10 minuti.... Questo perché l'evento OnBookEvent perSNGR-3.19 non è stato generato per 10 minuti.

Forse il terminale l'ha messo nella coda degli eventi e in qualche modo è scomparso da questa coda. Non ci sono errori del genere con OnTimer. Sì, ci può essere un tick con 20 secondi di ritardo.


 
pivomoe:


Qual è il suo scopo originale?

Perché avete bisogno di confrontare gli orari dei tee con l'ora locale?

 
prostotrader:

Qual è il suo scopo originale?

Perché avete bisogno di confrontare i tempi di tick con l'ora locale?

Voglio sapere il ritardo massimo tra quando il tick avviene sul server e quando arriva nel terminale. E voglio sapere come minimizzare questo tempo.

Questa conoscenza può essere usata per scrivere il mio tester personale. Si può anche chiedere agli sviluppatori di allungare il ritardo.

TimeCurrent() - il tempo dell'ultimo tick di un simbolo sarà inferiore al tempo di ritardo, quindi può essere utilizzato. Usare l'ora locale nella prima versione non è stata una buona idea.

 
pivomoe:

Voglio sapere il ritardo massimo tra quando un tick si verifica sul server e quando raggiunge il terminale. E come minimizzare questo tempo.

Questa conoscenza può essere usata quando scrivo il mio tester. E forse riuscirò anche a confondere gli sviluppatori con ritardi più lunghi.

Capisco. Vai avanti... Senza di me.

E per il resto del forum

//+------------------------------------------------------------------+
//|                                                         Time.mq5 |
//|                                                   Copyright 2019 |
//|                                                                  |
//+------------------------------------------------------------------+
enum FRESH_TICK
{
  UNKNOWN_TICK,
  NEW_TICK,
  CUR_TICK
};
//
int is_book;
ulong last_tick_time; //Время последнего тика
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
  last_tick_time = 0;
  is_book = MarketBookAdd(Symbol());
  if(is_book == false) return(INIT_FAILED);
  return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
  if(is_book == true) MarketBookRelease(Symbol()); 
}
//+------------------------------------------------------------------+
// Expert Book event function                                        |
//+------------------------------------------------------------------+  
void OnBookEvent(const string &symbol)
{
  if(symbol == Symbol())
  {
    MqlTick a_ticks[];
    int result = CopyTicks(symbol, a_ticks, COPY_TICKS_ALL, 0, 1);
    if(result > 0)
    {
      FRESH_TICK tick_state = CheckTickTime(a_ticks[0]);
      switch(tick_state)
      {
       case UNKNOWN_TICK:; //Тик не определен
       break;
       case NEW_TICK:;     //Торговое время, можно отсылать ордера;
       break;
       case CUR_TICK:;     //По усмотрению разработчика;
       break;
      }
    }  
  }
}
//+------------------------------------------------------------------+
//| Expert Check Market Time function                                |
//+------------------------------------------------------------------+
FRESH_TICK CheckTickTime(MqlTick &a_tick)
{
  MqlDateTime cur_time, tick_time;
  cur_time.year = 0;
  TimeTradeServer(cur_time); //Возвращает расчетное текущее время торгового сервера.
  if(cur_time.year > 0)
  {
    if(TimeToStruct(a_tick.time, tick_time) == true)
    {
      if(tick_time.day_of_year == cur_time.day_of_year)      //Проверка, что это сегодняшний тик
      {
        double t_msc = double(a_tick.time_msc - ulong(a_tick.time) * 1000)/1000;
        double tr_time = double(tick_time.hour * 3600 + tick_time.min * 60 + tick_time.sec) + t_msc;
        if(((tr_time >= 36000) && (tr_time < 50370)) ||   //10:00:00 - 13:59:30
           ((tr_time >= 50700) && (tr_time < 67470)) ||   //14:05:00 - 19:44:30 
           ((tr_time >= 68700) && (tr_time < 85770)))     //19:05:00 - 23:49:30
        {
          if(ulong(a_tick.time_msc) > last_tick_time)
          {
            last_tick_time = ulong(a_tick.time_msc);
            return(NEW_TICK);
          } else return(CUR_TICK);  
        }
      }
    }
  }   
  return(UNKNOWN_TICK);
} 
      
 
pivomoe:

Domanda di attenzione: pensate che sia normale non essere a conoscenza di un tick alle 18:00:00 da TimeCurrent() con un tempo di 17:59:00 ?

Credo che la questione sia irrilevante. Vogliamo che la sequenza di tick soddisfi almeno i seguenti criteri:

1. deve essere sequenziale, cioè il tempo di ogni tick successivo >= il tempo del tick precedente;

2. attualità. Cioè il tempo dell'ultimo tick in arrivo è il più vicino possibile al momento attuale;

Sembra che il problema sia il secondo punto.

L'argomentazione del punto 2 è la seguente: voglio che il tempo dalla generazione del tick sul server fino alla sua ricezione (lag) sia minimo, in modo da poterlo elaborare più velocemente degli altri e prendere una decisione di trading. Ma se il ritardo è lo stesso per tutti gli offerenti - allora non c'è problema (per quanto ne so). Cioè il server del broker ha il problema, ma tutti sono su un piano di parità. Se qualcuno ha ricevuto l'informazione sul tick alle 17:59:01, e io non l'ho ricevuta nemmeno alle 18:00 - questo è il grande problema.

Ed ecco la domanda. Qual è il problema (e ce n'è uno)? Nel server del broker, che non dà il tick (a tutti) per molto tempo, o in MT5, che non lo riceve per molto tempo.

123456789
Nuovo commento