MQL4-Echtzeituhr (Sekunde für Sekunde) - Seite 3

Neuer Kommentar
 
brewmanz:

A) Machen Sie sich nicht die Mühe, MT4 als Echtzeituhr zu verwenden. Es ist ein bisschen so, als würde man einen Hund dazu bringen, auf den Hinterbeinen zu laufen - es ist zwar interessant zu sehen, bringt aber nicht wirklich viel.

B) Warum ist es so wichtig, jede Sekunde zu verarbeiten? Wenn bei den Ticks nicht viel passiert, dann passiert auch bei den Preisen nicht viel.

(jeder Kommentar ist 1 Cent wert)


A) Warum sollten wir nicht! Ist nur entweder PC- oder Serverzeit; ich schätze, wir können Infos genau bekommen.

B) Warum ist es kritisch ... mal sehen - Hochfrequenzhandel - nicht auf asynchrone Informationen, wo Tick-by-Tick ist! das sollte ein triftiger Grund sein, denke ich.

Ich warte immer noch auf meine 2 Cents.

 
Ais:

MQL4 Reference : https://docs.mql4.com/runtime/start: "Skripte und Experten arbeiten in ihrem eigenen Thread. Benutzerdefinierte Indikatoren arbeiten im Thread der Hauptschnittstelle."


Ihr Indikator zeigt also die Zeit auf der Oberfläche des Benutzers in der GUI an - in Echtzeit / Sekunde für Sekunde.
 

Um "Sekunde für Sekunde" zu arbeiten, verwenden wir die Funktion "Sleep()".

Zu diesem Zweck messen wir die Laufzeit der Hauptroutine.

Zum Beispiel wird die Laufzeit in der Variablen "int Runtime;" gespeichert, und "RunTime < 1000".

Dann rufen wir "Sleep (1000 - RunTime) ;" auf, um sicherzustellen, dass der nächste Durchlauf in 1000 ms stattfindet, natürlich mit einer bestimmten Genauigkeit.

Aber.

MQL4 Reference : https://docs.mql4.com/common/Sleep: "Die Funktion Sleep() kann nicht von benutzerdefinierten Indikatoren aufgerufen werden, da diese im Schnittstellen-Thread rechnen und ihn nicht verlangsamen dürfen."

 

Einfache Lösung:

Binden Sie die Berechnungen in Ihren EA ein, und Sie sind fein raus.

Vorteile:

Keine Notwendigkeit, icustom aufzurufen

Kein Indikator

Nachteile:

Kein Indikator. Aber für High-Freq-Trading Sie *müssen* einen EA verwenden, weil Menschen zu langsam sind.

 

"Hochfrequenz" und "niedrige Latenz" sind leicht unterschiedlich.

Außerdem werden Visualisierungen oft für Analysen oder zur Überwachung verwendet, nicht nur für den Handel.

 
Ais:

"Hochfrequenz" und "niedrige Latenz" sind leicht unterschiedlich.

Außerdem werden Visualisierungen oft zur Analyse oder zur Überwachung verwendet, nicht nur für den Handel.

Wenn Sie wirklich eine Überwachung benötigen, können Sie das Verhalten des Indikators mit Linien nachbilden. Sicherlich ist Hochleistung etwas anderes.

 

Was ist, wenn wir Ereignisse in bestimmten Zeitabständen analysieren und überwachen wollen?
Zum Beispiel alle 1 Sekunde.

 
Ais:

Was ist, wenn wir Ereignisse in bestimmten Zeitabständen analysieren und überwachen wollen?
Zum Beispiel alle 1 Sekunde.

Sobald man von Tick-by-Tick spricht, meint man Ultrahochfrequenz ....

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

Abtastung in vordefinierten Intervallen kann als Hochfrequenzabtastung definiert werden, wenn 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);
  }
leicht in einen EA umcodierbar, um die richtige Schlaffunktion zu verwenden. Ich habe dies bereits getan.
 
zzuegg:
leicht in einen EA umcodierbar, um die richtige Sleep-Funktion zu verwenden. Habe das schon gemacht.


Nettes Programm. TimeCurrent() ist der Tick-by-Tick-Preis, den wir brauchen, um den Computerpreis zu erhalten!

Vielleicht können wir eine synthetische Uhr aus dem Beispiel bauen:

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

Gib uns einen Tipp! zzuegg :)

123456
Neuer Kommentar
Grund der Beschwerde: