Tiki em tempo real - página 19

Novo comentário
 
Yuriy Zaytsev:

Alternativamente, para evitar preocupações de que o Symbol() coma o tempo, então deixe os dois manipuladores "alimentarem-se" igualmente.

Podemos substituir a função Symbol() por uma variável pré-definida _Symbol

 

O símbolo() não tem nada a ver com isso. O tempo no registro é correto.

O atraso está na fila de eventos ou nas funções SymbolInfo.

É disso que estou falando.


Portanto, se você precisar do copo, trabalhe com a OnBook. Se não for necessário, trabalhar no OnTick (sem filas de espera e chamadas desnecessárias).

O que resta descobrir é a maneira mais rápida de obter o histórico real do tick para ambos os métodos.

Eu acho que, se apenas o último sinal for necessário, SymbolInfo é melhor. Se precisarmos de um histórico sem lacunas, então apenas CopyTicks.

 
Andrey Khatimlianskii:

O símbolo() não tem nada a ver com isso. O tempo no registro é correto.

O atraso está na fila de eventos ou nas funções SymbolInfo.

É disso que estou falando.

Concordo que a Symbol não pode mastigar muito, mas pode dar alguma contribuição, e certamente para a pureza do teste leva tempoantes de qualquer chamada.

Quanto à fila - estou curioso sobre este ponto - até que ponto o OnBook pode ficar atrás do mesmo OnTick em condições ideais. Ou seja, quando apenas este Símbolo é subscrito, o terminal não está ocupado com mais nada, etc., e o que o causa.

Até agora não posso concordar que se trata apenas da fila, porque se os manipuladores não estão fazendo nada, então a fila de 5-6 OnBooks não deve consumir mais do que a operação de verificação do Símbolo.

Devemos remover todos os cheques e ver o que se passaentre OnTick e OnBook para o mesmo tick.

void OnBookEvent(const string &symbol)
{
ul=GetMicrosecondCount();  
  Print(__FUNCTION__, "; Time: ", ul, " mcs");
}
void OnTick()
{
ul=GetMicrosecondCount();  
  Print(__FUNCTION__, "; Time: ", ul, " mcs");
}
//+--

ap: Ficou claro que a impressão voraz não permite um controle limpo, pois a fila será longa por causa da impressão)

Tenho que colocar o tempo sem a impressão na matriz ulong, e então já uma vez a cada 5 minutos para imprimir tudo, mais tarde vou codificá-lo.

 

Queria colocar o código para testar primeiro

//---
bool is_book;
enum ENUM_BOOK_OR_TICK
{
        USE_BOOK,       // Use OnBookEvent
        USE_TICK        // Use OnTick
};
input ENUM_BOOK_OR_TICK Mode = USE_BOOK;
input int   SecForPrint =  120;
ulong TimeArrayBook[65536];
ulong TimeArrayTick[65536];
ushort curBook,curTick;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
   curBook=0;
   curTick=0; 
   ArrayInitialize(TimeArrayBook,INT_MAX);
   ArrayInitialize(TimeArrayTick,INT_MAX);
  if(Mode == USE_BOOK) is_book = MarketBookAdd(Symbol());
  if (EventSetTimer(SecForPrint)) 
  return(INIT_SUCCEEDED);
  else return (INIT_FAILED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
  if(Mode == USE_BOOK)
  {
    if(is_book == true) MarketBookRelease(Symbol());
  }  
}
//+------------------------------------------------------------------+
//| BookEvent function                                               |
//+------------------------------------------------------------------+
void OnBookEvent(const string &symbol)
{
  TimeArrayBook[curBook++]=GetMicrosecondCount();
}
void OnTick()
{
  TimeArrayTick[curTick++]=GetMicrosecondCount();
}
//+------------------------------------------------------------------+
void OnTimer()
  {  
   int total=MathMax(curBook,curTick);
   int i=0,k=0;
   while(i<total)
     {
      while(i<total && TimeArrayBook[i]<TimeArrayTick[k])
        {
          Print("Book ",TimeArrayBook[i++]);
        }    
      if(k<curTick-1)
        {
         Print("Tick ",TimeArrayTick[k++]);
        }       
        i++;
     }
     if (curTick>0)Print("Tick ",TimeArrayTick[curTick-1], " last");
     curBook=0;
     curTick=0;
  }
//---

Mas eu não posso abrir a conta de abertura de demonstração para algo. O tempo provavelmente não está funcionando, ou há outros problemas?



Depois codifique para dopilizar para comparar exatamente a partir de um evento.

 
Aleksey Mavrin:

Queria colocar o código para testar primeiro

Mas eu não posso abrir a conta de abertura de demonstração para algo. O tempo provavelmente não está funcionando, ou há outros problemas?



Depois codifique para dopilizar para comparar exatamente a partir de um evento.

Você tem que abri-lo no site deles. Eles então enviam um código para os correios.

 
Andrey Khatimlianskii:


Acho que se apenas o último tique for necessário, SymbolInfo é melhor. Se você precisa de um histórico sem lacunas, então apenas CopyTicks.

A questão é que o Mercado Urgente (FORTS) mesmo em instrumentos "altamente líquidos" é muito fraco,

Isso significa que ao preço certo você pode comprarum número muitolimitado de contratos, portanto, não precisamos apenas do preço,

mas o volume de contratos a este preço é muito importante.


E a SymbolInfo não dá o volume deste preço.

Devido a isso, precisamos usarMarketBookGet() que fornece tanto o preço quanto o volume do livro inteiro.

Você pode usarMarketBookGet() somente em pares com MarketBookAdd, obtendo as mudanças do market cup.

no OnBookEvent. Você pode adicionar o mercado (MarketBookAdd) e usarMarketBookGet() da OnTck(),

mas neste caso, outros deslizes de mercado(ordens pendentes não ao melhor preço) serão perdidos.

É verdade, o mercado pode brincar com isso e construir o deslize do mercado a partir de carrapatos recebidos, mas será realmente necessário?

Adicionado por

E não concordo que possamos receber carrapatos da história quando OnTck() é acionado.

Lembrando o último tick time, quando OnTck() é acionado, podemos obter ticks

em tempo real um(s) novo(s) tick(s) entrou(em) - desencadeou OnTck() lemos imediatamente, ou seja, não é história.

 
Andrey Khatimlianskii:

Resta descobrir a maneira mais rápida de obter o histórico real do tick para ambos os métodos.


Meu OnTick() é o mesmo ou um pouco mais rápido que o OnBook (mas o OnBook tem enormes atrasos).

Eu estava testando a velocidade das funções(microssegundos)

2020.02.04 13:09:13.101 Ticks_test (GOLD-3.20,M1)       SymbolInfoTick: time = 2 mcs 2020.02.04 13:09:10.720 Bid=1573.1 
2020.02.04 13:09:13.101 Ticks_test (GOLD-3.20,M1)       SymbolInfoDouble: time = 28 mcs ask = 1573.3
2020.02.04 13:09:13.101 Ticks_test (GOLD-3.20,M1)       SymbolInfoDouble: time = 33 mcs bid = 1573.1
2020.02.04 13:09:13.101 Ticks_test (GOLD-3.20,M1)       SymbolInfoDouble: time = 36 mcs last = 1573.4
2020.02.04 13:09:13.101 Ticks_test (GOLD-3.20,M1)       OnTick: time = 41 mcs 2020.02.04 13:09:10.720 Bid=1573.1 
2020.02.04 13:09:13.101 Ticks_test (GOLD-3.20,M1)       OnTick: time = 41 mcs 2020.02.04 13:09:00.328 Ask=1573.3 
OnTick - имеется ввиду CopyTicks из OnTick

O mais rápido éSymbolInfoTick, mas esta função não coloca volume no tick!

Veja para obter ajuda.

tick

[out]  Ссылка на структуру типа MqlTick, в которую будут помещены текущие цены и время последнего обновления цен.

Isto é, apenas tempo e preço, mas sem volume :(

 

Para instrumentos negociados em bolsa (especialmente FORTS), não é apenas o preço que importa,

mas também o volume de contratos a esse preço!

 

Tentei pegar o vidro pela OnTick() - enormes atrasos claramente visíveis "a olho nu"!

//+------------------------------------------------------------------+
//|                                                   Ticks_test.mq5 |
//|                                      Copyright 2019 prostotrader |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2019 prostotrader"
#property link      "https://www.mql5.com"
#property version   "1.00"
//---
bool is_book;
MqlBookInfo BookInfo[];
int book_cnt;
struct MARKET_DATA
{
  double ask;
  long   ask_vol;
  double bid;
  long   bid_vol;
  double prev_ask;
  long   prev_ask_vol;
  double next_bid;
  long   next_bid_vol; 
};
MARKET_DATA m_data;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
{
  is_book = MarketBookAdd(Symbol());
  if(is_book == false)
  {
    Alert("No add book!");
    return(INIT_FAILED);
  }
  return(INIT_SUCCEEDED);
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
  if(is_book == true) MarketBookRelease(Symbol());
}
//+------------------------------------------------------------------+
//| Expert OnTick function                                           |
//+------------------------------------------------------------------+
bool GetBook(const string a_symb, int &cnt)
{
  cnt = 0;
  if(MarketBookGet(a_symb, BookInfo) == true)//getBook )
  {
    m_data.ask = 0;
    m_data.ask_vol = 0;
    m_data.prev_ask = 0;
    m_data.prev_ask_vol = 0;
    m_data.bid = 0;
    m_data.bid_vol = 0;
    m_data.next_bid = 0;
    m_data.next_bid_vol = 0;
    cnt = ArraySize(BookInfo);
    if(cnt > 0)
    {
      for(int i = 0; i < cnt; i++)
      {
        if(BookInfo[i].type == BOOK_TYPE_BUY) //Стакан агрегирован, т.е от наибольшего Sell к наименьшему Buy
        {
          if((i + 1) <= (cnt- 1))
          {
            m_data.ask = BookInfo[i-1].price;
            m_data.ask_vol = BookInfo[i-1].volume;
            m_data.prev_ask = BookInfo[i-2].price;
            m_data.prev_ask_vol = BookInfo[i-2].volume;
            m_data.bid = BookInfo[i].price;
            m_data.bid_vol = BookInfo[i].volume;
            m_data.next_bid = BookInfo[i+1].price;
            m_data.next_bid_vol = BookInfo[i+1].volume;
            break;
          } else break;
        }
      }
      return(true);
    }
  }
  return(false);
}  
//+------------------------------------------------------------------+
//| Expert OnTick function                                           |
//+------------------------------------------------------------------+
void OnTick()
{
  if(GetBook(Symbol(), book_cnt) == true)
  {
    if(book_cnt >= 4)
    {
      Print("Prev Sell: ask = ", m_data.prev_ask, " volume = ",m_data.prev_ask_vol); 
      Print("Sell: ask = ", m_data.ask, " volume = ",m_data.ask_vol);
      Print("Buy: bid = ", m_data.bid, " volume = ",m_data.bid_vol);
      Print("Next Buy: bid = ", m_data.next_bid, " volume = ",m_data.next_bid_vol);
    }  
  }
}
//+------------------------------------------------------------------+
 

Você tem tudo bagunçado.

Escrevi anteriormente que as negociações e o nível2 são assinaturas de dados diferentes, portanto, são manipuladores de eventos diferentes.
É por isso que as negociações devem ser chamadas da OnTick, e as gangues de volume da OnBook.
Você está tentando ligar para as negociações de eventos OnBook e gangues da OnTick. Pensando que o OnBook será mais rápido para as negociações.
Não vai ser mais rápido, acho que é uma ilusão comparar dois manipuladores de eventos, cada um dedicado a seu próprio fluxo de dados.
Entendo que é tudo experimentos, mas sem entender a lógica de que existem dois fluxos de dados (comércio e nível 2), você confundirá infinitamente esses manipuladores OnTick e OnBook.

1...121314151617181920212223242526
Novo comentário