Reloj de tiempo real MQL4 (segundo a segundo) - página 3

Nuevo comentario
 
brewmanz:

A) No te molestes en usar MT4 como un reloj de tiempo real. Es un poco como hacer que un perro camine sobre sus patas traseras - interesante para ver cómo se hace, pero en realidad no logra mucho.

B) ¿Por qué es tan crítico procesar cada segundo? Si no pasa mucho con los ticks, entonces no pasa mucho con los precios.

(cada comentario vale 1 céntimo)


A) ¿Por qué no? Es sólo el tiempo del PC o del servidor; supongo que podemos obtener información con precisión.

B) ¿Por qué es crítico ... déjame ver- comercio de alta frecuencia - no se basa en la información asíncrona donde tick-by-tick es ! eso debería ser una razón válida supongo.

Todavía estoy esperando mis 2 centavos.

 
Ais:

MQL4 Reference : https://docs.mql4.com/runtime/start: "Los scripts y los expertos trabajan en su propio hilo. Los indicadores personalizados trabajan en el hilo de la interfaz principal".


Así que su indicador muestra el tiempo en la interfaz del usuario en la GUI ? tiempo real / segundo a segundo.
 

Para trabajar "segundo a segundo" utilizamos la función "Sleep()".

Para ello, medimos el tiempo de ejecución de la rutina principal.

Por ejemplo, dejamos que el tiempo de ejecución se almacene en la variable "int Runtime;", y que "RunTime < 1000".

Entonces invocamos "Sleep (1000 - RunTime) ;" para asegurarnos de que la siguiente ejecución tendrá lugar en 1000 ms, con una precisión dada por supuesto.

Pero.

Referencia MQL4 : https://docs.mql4.com/common/Sleep: "La función Sleep() no puede ser invocada desde los indicadores personalizados ya que calculan en el hilo de la interfaz y no pueden desacelerarlo."

 

La solución es sencilla:

Incluya los cálculos en su EA y estará bien.

Ventajas:

No hay necesidad de llamar a icustom

No hay indicador

Contras:

No hay indicador. Pero para el comercio de alta frecuencia usted *debe* usar un EA porque los humanos son demasiado lentos.

 

"Alta frecuencia" y "baja latencia" son ligeramente diferentes.

Además, las visualizaciones se utilizan a menudo para el análisis o la supervisión, no solo para el comercio.

 
Ais:

"Alta frecuencia" y "baja latencia" son ligeramente diferentes.

Y, las visualizaciones a menudo se utilizan para el análisis o para la supervisión, no sólo para el comercio.

Si realmente necesitas monitorización puedes reconstruir el comportamiento del indicador con líneas. Seguro que el alto rendimiento es algo diferente.

 

¿Y si queremos analizar y controlar los eventos en intervalos de tiempo?
Por ejemplo, cada 1 segundo.

 
Ais:

¿Qué ocurre si queremos analizar y supervisar los eventos a intervalos de tiempo?
Por ejemplo, cada 1 segundo.

En cuanto se habla de tick-by-tick se habla de de ultra alta frecuencia ....

Analysis of ultra-high-frequency financial data using advanced Fourier transforms' (2009) Finance Research Letters Vol 6, pp 47-53 (con I.Giampaoli y W.L.Ng)

El muestreo en intervalos predefinidos puede definirse como muestreo de alta frecuencia cuando T<t

  
#property indicator_chart_window
#property indicator_buffers 8
#property indicator_color1 Black
#property indicator_color2 Black
#property indicator_color3 Red
#property indicator_color4 Blue
#property indicator_color5 Red
#property indicator_color6 Red
#property indicator_color7 Red
#property indicator_color8 Red
//---- buffers
double open[];
double close[];
double high[];
double low[];
double ExtMapBuffer5[];
double ExtMapBuffer6[];
double ExtMapBuffer7[];
double ExtMapBuffer8[];
 
extern int MaxHistory=200;
extern int TimeInSeconds=5;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
double a.open[];
double a.close[];
double a.high[];
double a.low[];
 
int init()
  {
//---- indicators
   SetIndexStyle(0,DRAW_HISTOGRAM);
   SetIndexBuffer(0,high);
   SetIndexStyle(1,DRAW_HISTOGRAM);
   SetIndexBuffer(1,low);
   SetIndexStyle(2,DRAW_HISTOGRAM,STYLE_SOLID,5);
   SetIndexBuffer(2,open);
   SetIndexStyle(3,DRAW_HISTOGRAM,STYLE_SOLID,5);
   SetIndexBuffer(3,close);
   SetIndexStyle(4,DRAW_LINE);
   SetIndexBuffer(4,ExtMapBuffer5);
   SetIndexStyle(5,DRAW_LINE);
   SetIndexBuffer(5,ExtMapBuffer6);
   SetIndexStyle(6,DRAW_LINE);
   SetIndexBuffer(6,ExtMapBuffer7);
   SetIndexStyle(7,DRAW_LINE);
   SetIndexBuffer(7,ExtMapBuffer8);
   ArrayResize(a.high,MaxHistory);
   ArrayResize(a.low,MaxHistory);
   ArrayResize(a.open,MaxHistory);
   ArrayResize(a.close,MaxHistory);      
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
void redraw(){
   for(int i=200;i>=0;i--){
      if(i==200){
      open[i]=0;
      close[i]=0;
      high[i]=0;
      low[i]=0;
      }else{
      open[i]=a.open[i];
      close[i]=a.close[i];
      high[i]=a.high[i];
      low[i]=a.low[i];      
      }
   }
}
 
void shift(){
   for(int i=200;i>0;i--){
      a.open[i]=a.open[i-1];
      a.close[i]=a.close[i-1];
      a.high[i]=a.high[i-1];
      a.low[i]=a.low[i-1];
   }
}
 
extern int sleep=100;
int start()
  {
   int    counted_bars=IndicatorCounted();
//----
   bool running=true;
   static double price=0;
   static int t=0;
   static datetime t.r=0; 
   static bool updates=false;
   //t=TimeCurrent();
   //while(running){
      updates=false;
      if(TimeCurrent()>(t+TimeInSeconds)){
 
         shift();
         if(a.open[1]==EMPTY || a.open[1]==EMPTY_VALUE || a.open[1]==0){
            a.open[0]=Bid;
            a.close[0]=Bid;
            a.high[0]=Bid;
            a.low[0]=Bid;
         }else{
         a.open[0]=a.close[1];
         a.high[0]=a.close[1];
         a.low[0]=a.close[1];
         a.close[0]=a.close[1];
         }
         Print("shift "+a.open[0]+" - "+a.open[1]);
         updates=true;
         t=TimeCurrent();
      }
      if(price!=Bid){
            price=Bid;
            a.close[0]=price;
            a.high[0]=MathMax(price,a.high[0]);
            a.low[0]=MathMin(price,a.low[0]);
            updates=true;
      }       
      if(Time[0]!=t.r){
         t.r=Time[0];
         redraw();
      }else{
         if(updates){
            redraw();
         }
      }
      if(IsStopped()) running=false;
   //   Sleep(sleep);
   //}
//----
   return(0);
  }
fácilmente recodificable a un EA para utilizar la función de sueño adecuada. Ya lo he hecho.
 
zzuegg:
fácilmente re-codificable a un EA para utilizar la función de sueño adecuado. Ya he hecho esto.


Buen programa . ¡TimeCurrent() es el precio tick-by-tick que necesitamos para obtener el precio de la computadora!

Tal vez podamos construir un reloj sintético a partir del ejemplo:

if(Time[0]!=t.r){
t.r=Time[ 0];
redraw();

danos una pista! zzuegg :)

123456
Nuevo comentario