Um minuto e meio de diferença entre a hora local e a hora do novo tick. O que fazer. - página 2

Novo comentário
 
prostotrader:

Existe um código fonte com comentários.

Sente-se preguiçoso para dar uma olhada? Ou há algo que eu não entendo?

Eu fiz. Eu tive a idéia sem o código. Não entendo porque você me aconselha:

prostotrader:

Você precisa adicionar os instrumentos mais líquidos ao Market Watch.

Em seguida, acrescente camadas desses instrumentos.

E, quando OnBookEvent() aciona, copie 1 tick (último), haverá um tempo e imediatamente pegue o tempo local e compare.

Como seu método é melhor ?

 
pivomoe:

Eu já dei uma olhada. Eu tive a idéia sem o código. Não entendo porque você me aconselha:

Por que seu método é melhor?

Porque é o certo!

Eu cometi um erro, não a hora local, mas a hora do servidor.

1. os bilhetes chegam ao terminal em pacotes.

2. Cada pacote subsequente pode conter carrapatos que não foram "empilhados" no pacote anterior, mas têm o mesmo tempo que o pacote anterior.

3. OnBookEvent() é acionado na chegada de qualquer tick (mudança de preço, volume), ou seja, cada tick. (você aciona um temporizador - já ruim).

4. Você usa o tempo do computador local, o que não é necessário!

 

Aqui está tudo o que você precisa para negociar (verifique os horários das sessões de negociação)

//+------------------------------------------------------------------+
//|                                                         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);
}

Adicionado por

Se você precisa de precisão de milissegundos, então este

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;

Adicionado

Mas tudo isso não dará o resultado desejado (os limites do tempo de negociação) porque

pode não haver carrapatos em uma sessão de negociação, e o tempo não pára.

Suponhamos que alguém tenha retirado sua ordem pendente, o registro mudou,

há um sinal, mas há uma correlação "antiga" (o tempo não é o tempo atual).

O terminal não transmite o tempo exato do servidor.

 

Você não me entendeu. Vamos começar pelo início.

1) Em seu programa, você liga para TimeCurrent() e recebe a hora de chegada da última cotação para um dos símbolos selecionados no Market Watch.

Que sejam 18:00:00.

2) Com o próximo comando, você recebe a hora do último tique da SBER.

Que sejam 17:58:00

3) Um pouco de tempo passa e você solicita novamente a hora do último tick da SBER.

Que sejam 17:59:00


Note a pergunta: Você acha que está tudo bem às 18:00:00 da TimeCurrent() não saber sobre o tick com o tempo 17:59:00 ?

 
pivomoe:

Você não me entendeu. Vamos começar pelo início.

1) Em seu programa, você liga para TimeCurrent() e recebe a hora de chegada da última cotação para um dos símbolos selecionados no Market Watch.

Que sejam 18:00:00.

2) Com o próximo comando, você recebe a hora do último tique da SBER.

Que sejam 17:58:00

3) Um pouco de tempo passa e você solicita novamente a hora do último tick da SBER.

Que sejam 17:59:00


Pergunta de atenção: Você acha que não há problema em não estar ciente às 18:00:00 horas pelo TimeCurrent() de um tick com a hora 17:59:00 ?

No código que citei você pode contabilizar todas as carrapatas (sem problemas)

O último código não usa TineCurrent() masTimeTradeServer() - desta vez só é necessário

para verificar o tick com uma precisão de um dia e pronto!

Vamos começar do início.

Em geral, o que você quer fazer, para descobrir?

Por que você começou a comparar a hora do carrapato com a hora local?

Qual é o propósito original?

 

Agora vou lhes mostrar como este problema se apresenta na prática. Eu redesenhei completamente o Expert Advisor. Tornei possível apanhar novos carrapatos no OnTimer, bem como no OnBookEvent.

Há 45 símbolos no Market Watch. A maioria deles não é líquida.

Aqui está o resultado da captura de novos carrapatos no 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

Ou seja, um novo tique foi pego às 18:50 no TimeCurrent para o símboloSNGR-3.19 com o horário de 18:41.


Em seguida, há medidas do horário local do computador no momento:


1) receber um novo tick, ou seja, no momento da última chamada do CopyTick (ou SymbolInfo, dependendo das configurações).

2) O momento da última chamada.

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


Então, neste caso o problema ocorreu porque a função get new só foi chamada em 10 minutos.... Isso porque o evento OnBookEvent para oSNGR-3.19 não foi gerado durante 10 minutos.

Talvez o terminal o tenha colocado na fila de eventos e de alguma forma tenha desaparecido desta fila. Não existem tais erros com o OnTimer. Sim, pode haver um carrapato com 20 segundos de atraso.


Arquivos anexados:
ProverkaAktyalnostiTikov.mq5  39 kb
ProverkaAktyalnostiTikov.ex5  43 kb
 
pivomoe:


Qual é o seu propósito original?

Por que você precisa comparar os horários dos tee com a hora local?

 
prostotrader:

Qual é o seu propósito original?

Por que você precisa comparar os horários dos carrapatos com a hora local?

Quero saber a demora máxima entre quando o tick ocorre no servidor e quando ele chega no terminal. E eu quero saber como minimizar este tempo.

Este conhecimento pode ser usado para escrever meu próprio testador. Você pode até mesmo pedir aos desenvolvedores que aumentem o atraso.

TimeCurrent() - o tempo do último tick por um símbolo será menor do que o tempo de atraso, por isso pode ser usado. Usar a hora local na primeira versão não foi uma boa idéia.

 
pivomoe:

Quero saber a demora máxima entre quando um tick ocorre no servidor e quando ele chega ao terminal. E como minimizar este tempo.

Este conhecimento pode ser usado ao escrever meu próprio testador. E talvez eu possa até mesmo confundir os desenvolvedores com atrasos maiores.

Estou vendo. Continuar... Sem mim.

E para o resto do fórum

//+------------------------------------------------------------------+
//|                                                         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:

Pergunta de atenção: Você acha que é normal não ter conhecimento de um tick às 18:00:00 pela TimeCurrent() com um horário de 17:59:00 ?

Acho que a questão é discutível. Queremos que a seqüência de tick atenda pelo menos os seguintes critérios:

1. deve ser sequencial, ou seja, o tempo de cada tick subseqüente >= o tempo do tick anterior;

2. atualidade. Isto é, a hora do último tique de chegada é a mais próxima possível do momento atual;

Parece que o problema está no segundo ponto.

A argumentação do ponto 2 é a seguinte: eu quero que o tempo desde a geração do tick no servidor até o recebimento (lag) seja mínimo, para que eu possa processá-lo mais rapidamente do que outros e tomar uma decisão comercial. Mas se o atraso for o mesmo para todos os proponentes - então não há problema (tanto quanto eu entendo). Ou seja, o servidor do corretor tem o problema, mas todos estão em pé de igualdade. Se alguém recebeu a informação sobre o tique às 17:59:01, e eu não a recebi nem mesmo às 18:00 - este é o grande problema.

E aqui está a questão. Qual é o problema (e existe um)? No servidor do corretor, que não dá o tique (para todos) por muito tempo, ou no MT5, que não o recebe por muito tempo.

123456789
Novo comentário