Librerías: OnTickMulti - página 5

[fxsaber]

Stanislav Korotky #:

Para que el caso de prueba sea completo, me gustaría entender el problema práctico: ¿operamos únicamente con ticks cuya hora coincida con una precisión de milisegundos?

No. El objetivo es disponer siempre de un entorno actualizado para todos los símbolos. En mi ejemplo, en OnTimer siempre se cumple la condición de actualidad. La apertura de la posición es solo una demostración.

[Stanislav Korotky]

fxsaber #:
No. El objetivo es tener siempre un entorno actualizado en todos los símbolos. En mi ejemplo, en OnTimer siempre se cumple la condición de actualidad. La apertura de la posición es solo una demostración.

De acuerdo.

Por ahora no está claro dónde la implementación en el evento OnTickMulti «pierde» el tick o, dicho de otro modo, cómo es posible que SymbolInfoTick devuelva precios distintos a los esperados (antes supuse que probablemente hubiera un retraso debido a la gestión de eventos personalizados del indicador) ; yo lo probaría sin el indicador espía para que el experimento fuera más limpio: simplemente SymbolInfoTick/CopyTicks para todos los símbolos desde el OnTick habitual, al menos para la misma marca de tiempo.

En cuanto a OnTimer, me plantea algunas dudas (corrígeme si me equivoco):

void OnTimer()
{
  if (TimeMsc++ == 1759280400081) // 01/10/2025 01:00:00.081
    PositionOpen();
}

No tenemos garantía de que el controlador se ejecute en menos de un milisegundo, por lo que un simple incremento del contador no garantiza que se mantenga la sincronización inicial; es decir, la sincronización con la hora del servidor debe realizarse correctamente sobre la marcha cada vez (tras abrir una posición o realizar otros cálculos más complejos que un simple incremento, si los hubiera). En otras palabras, este enfoque refinado no servirá cuando haya que abrir muchas posiciones.

Además, la sincronización inicial (inicialización del contador) tampoco es 100 % perfecta, en mi humilde opinión.

ulong TimeMsc = TimeTradeServer() * 1000 + (inTimer && EventSetMillisecondTimer(1));

Supongamos que, en el simulador, la hora del servidor realmente comienza sin milisegundos, pero ¿cómo funcionará ese código en producción? ¿Y por qué sumamos 1 milisegundo? Yo, en cualquier caso, obtendría la hora del servidor a partir de los ticks.

No se trata de buscarle tres pies al gato, sino simplemente de dudas sobre el «cumplimiento constante de la condición de actualidad».

[fxsaber]

Stanislav Korotky #:

Un simple incremento del contador no garantiza que se mantenga la sincronización inicial

En el probador está garantizado.

Pero, ¿cómo funcionará este código en modo online?

En el entorno en línea no existe ese problema, ya que todos los datos que llegan al terminal son indicativos: no están actualizados debido a los retrasos.

¿Y por qué sumamos 1 milisegundo?

Porque la primera llamada a OnTimer se activará tras un intervalo predeterminado, y no de inmediato.

[fxsaber]

Stanislav Korotky #:

Por el momento no está claro dónde la implementación del evento OnTickMulti «pierde» un tick o, dicho de otro modo, cómo es posible que SymbolInfoTick devuelva unos precios distintos a los esperados

OnTickMulti no tiene nada que ver, ya que el propio SymbolInfoTick predeterminado de uno de los símbolos devuelve el tick correcto, mientras que para otros símbolos no lo hace.

La causa radica únicamente en la secuencia de envío de los ticks.

Foro sobre trading, sistemas de trading automáticos y pruebas de estrategias de trading

Bibliotecas: OnTickMulti

fxsaber, 30/09/2025 09:24

Los ticks con la misma hora no llegan al mismo tiempo. Todos llegan de forma secuencial. Y si el tick del EUR/USD con la hora más alta llega primero, en ese momento no se sabe nada del tick con la misma hora del GBP/USD, que llegará en segundo lugar. Por lo tanto, en el momento en que llega el primer tick del EURUSD, el segundo tick del GBPUSD simplemente no existe, sino que se dispone de los datos del tick anterior del GBPUSD.

[fxsaber]

fxsaber #:

Porque la primera llamada a OnTimer se activará tras un intervalo determinado, y no de inmediato.

Se me ha ocurrido una forma rápida de actualizar todos los datos.

#include <fxsaber\OnTickMulti\OnTickMulti.mqh> // https://www.mql5.com/es/code/47647

#include <MT4Orders.mqh> // https://www.mql5.com/es/code/16006

void PositionOpen()
{
  for (uint i = ArraySize(OnTickMultiObject.Symbols); (bool)i--;)
  {
    const string SymbName = OnTickMultiObject.Symbols[i];
    
    OrderSend(SymbName, OP_BUY, 1, SymbolInfoDouble(SymbName, SYMBOL_ASK), 0, 0, 0);
  }
}

long CurrentTime = 0;

// OnTick multicarácter.
void OnTickMulti( const string &Symb, const uint &Index )
{  
  MqlTick Tick;
  
  if (SymbolInfoTick(Symb, Tick) && (Tick.time_msc > CurrentTime))
  {
    CurrentTime = Tick.time_msc;
    
    EventSetMillisecondTimer(1);
  }  
}

void OnTimer()
{
  if (CurrentTime == 1759280400081) // 01/10/2025 01:00:00.081
    PositionOpen();
    
  EventKillTimer();
}

Este mecanismo permite, incluso en modo normal (modo de moneda única sin OnTickMulti), trabajar únicamente con datos actualizados. Por ejemplo, en el EURUSD hay varios ticks con la misma hora. La actualización permite trabajar con el tick más reciente: el último de esa secuencia.

P. D.: Esta es otra razón para crear símbolos personalizados: incluir en el historial solo el último tick de las secuencias con la misma hora. En ese caso, en el modo monovaluta siempre se respetará la actualización.

[Stanislav Korotky]

Rorschach #:

Pero los precios de apertura son los mismos, aunque la hora de apertura sea la misma para todos los valores.

Y debido a este comportamiento, es imposible probar correctamente una serie de sistemas.

He refrescado la memoria sobre el modo del simulador con precios de apertura. La clave está en que, a pesar del nombre, el simulador genera en este modo 4 ticks OHLC, y no 1 como cabría esperar intuitivamente por el nombre. De estos 4 puntos de control, para los expertos solo se toma el primer O y se invoca OnTick, mientras que para los indicadores, además, para HLC o LHC (dependiendo de la dirección de la barra), se invoca 3 veces OnCalculate con ticks para los precios correspondientes. Los tiempos para estos tres puntos adicionales se fijan artificialmente en los tres últimos segundos de la barra. El resultado es que el indicador espía envía varios eventos para los símbolos en lugar de uno solo. Probablemente, quienes utilicen el modo basado en los precios de apertura deben tener esto en cuenta.

Además, he observado un artefacto (al añadir depuración a mi indicador espía análogo del libro) por el que el evento del tick del símbolo adicional de la barra anterior se repite, por alguna razón, en la nueva barra, solo que después se activa OnCalculate del indicador espía y llega el evento del nuevo tick del símbolo adicional con el precio actualizado. Como resultado, para disponer del precio actualizado de los símbolos adicionales, es necesario incluir una marca de tiempo en los propios eventos y no procesar de nuevo los eventos que ya se han procesado. Yo lo hago así al enviarlos:

int OnCalculate(const int rates_total, const int prev_calculated, const int, const double &price[])
{
   MqlTick tick;
   SymbolInfoTick(_Symbol, tick);
   EventChartCustom(Chart, Message, Index, (double)tick.time_msc, NULL);
  
   return rates_total;
}

Y al recibir (se muestra el caso de un símbolo adicional; para muchos se necesita un array timestamp[]!):

void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
{
   if(id == CHARTEVENT_CUSTOM + Message)
   {
      static long timestamp;
      long event = (long)dparam;
      if(event > timestamp)
      {
         OnSymbolTick((int)lparam);
         timestamp = event;
      }
   }
}

Cabe señalar que, si hay ticks con milisegundos idénticos, se ejecuta el primero de ellos, y no el último.

[Rorschach]

Rorschach #:
La forma más sencilla de sincronización

Pensaba que la sincronización de series temporales era un problema bien estudiado y que ya existían algoritmos preparados, así que me metí en Internet y no encontré nada.