Orologio in tempo reale MQL4 (secondo per secondo) - pagina 3

Nuovo commento
 
brewmanz:

A) Non preoccupatevi di usare MT4 come un orologio in tempo reale. È un po' come far camminare un cane sulle zampe posteriori - interessante vederlo fare, ma in realtà non si ottiene molto.

B) Perché è così critico elaborare ogni secondo? Se non succede molto con i tick, allora non succede molto con i prezzi.

(ogni commento vale 1 centesimo)


A) Perché non dovremmo! È solo il tempo del pc o del server; immagino che possiamo ottenere informazioni con precisione.

B) Perché è critico ... fammi vedere- trading ad alta frequenza - non basato su informazioni asincrone dove tick-by-tick è ! che dovrebbe essere una ragione valida credo.

Sto ancora aspettando i miei 2 centesimi.

 
Ais:

MQL4 Reference : https://docs.mql4.com/runtime/start: "Gli script e gli esperti lavorano nel loro proprio thread. Gli indicatori personalizzati lavorano nel thread dell'interfaccia principale".


Quindi il tuo indicatore visualizza il tempo sull'interfaccia dell'utente nella GUI ? tempo reale / secondo per secondo.
 

Per lavorare "secondo per secondo" usiamo la funzione "Sleep()".

Per fare questo, misuriamo il tempo di esecuzione della routine principale.

Per esempio, lasciamo che il tempo di esecuzione sia memorizzato nella variabile "int Runtime;", e lasciamo che "RunTime < 1000".

Poi invochiamo "Sleep (1000 - RunTime) ;" per assicurarci che la prossima esecuzione avrà luogo in 1000 ms, con la precisione data, naturalmente.

Ma.

MQL4 Reference : https://docs.mql4.com/common/Sleep: "La funzione Sleep() non può essere chiamata dagli indicatori personalizzati poiché essi calcolano nel thread dell'interfaccia e non possono decelerarlo."

 

Soluzione semplice:

Includete i calcoli nel vostro EA e siete a posto.

Pro:

Non c'è bisogno di chiamare icustom

Nessun indicatore

Contro:

Nessun indicatore. Ma per il trading ad alta frequenza si *deve* usare un EA perché gli umani sono troppo lenti.

 

"Alta frequenza" e "bassa latenza" sono leggermente diversi.

E le visualizzazioni sono spesso usate per l'analisi o il monitoraggio, non solo per il trading.

 
Ais:

"Alta frequenza" e "bassa latenza" sono leggermente diversi.

E le visualizzazioni sono spesso usate per l'analisi o il monitoraggio, non solo per il trading.

Se hai davvero bisogno di monitoraggio puoi ricostruire il comportamento dell'indicatore con delle linee. Certo l'alta performance è qualcosa di diverso.

 

E se volessimo analizzare e monitorare gli eventi su intervalli di tempo?
Per esempio, ogni 1 secondo.

 
Ais:

Cosa succede se vogliamo analizzare e monitorare gli eventi su intervalli di tempo?
Per esempio, ogni 1 secondo.

Non appena si parla di tick-by-tick si intende ultra alta frequenza ....

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

Il campionamento in intervalli predefiniti può essere definito come campionamento ad alta frequenza dove 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);
  }
facilmente ricodificabile in un EA per utilizzare la funzione di sonno appropriata. L'ho già fatto.
 
zzuegg:
facilmente ricodificabile in un EA per utilizzare la funzione di sonno appropriata. Già fatto questo.


Bel programma. TimeCurrent() è il prezzo tick-by-tick che ci serve per ottenere il prezzo del computer!

Forse possiamo costruire un orologio sintetico da esempio:

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

dacci un suggerimento! zzuegg :)

123456
Nuovo commento