Horloge temps réel MQL4 (seconde par seconde) - page 3

Nouveau commentaire
 
brewmanz:

A) Ne vous embêtez pas à utiliser MT4 comme horloge en temps réel. C'est un peu comme faire marcher un chien sur ses pattes arrière - c'est intéressant de le voir faire, mais cela ne donne pas grand-chose.

B) Pourquoi est-il si important de traiter chaque seconde ? S'il ne se passe pas grand-chose avec les tics, alors il ne se passe pas grand-chose avec les prix.

(chaque commentaire vaut 1 cent)


A) Pourquoi ne le ferions-nous pas ? C'est juste le temps du PC ou du serveur; je suppose que nous pouvons obtenir des informations précises.

B) Pourquoi est-ce essentiel ... voyons voir - trading à haute fréquence - pas basé sur des informations asynchrones où le tick-by-tick est ! cela devrait être une raison valable je suppose.

J'attends toujours mes deux cents.

 
Ais:

Référence MQL4 : https://docs.mql4.com/runtime/start: "Les scripts et les experts travaillent dans leur propre fil. Les indicateurs personnalisés travaillent dans le fil de l'interface principale."


Donc votre indicateur affiche le temps sur l'interface de l'utilisateur dans le GUI ? temps réel / seconde par seconde.
 

Pour travailler "seconde par seconde", nous utilisons la fonction "Sleep()".

Pour ce faire, nous mesurons le temps d'exécution de la routine principale.

Par exemple, laissons le temps d'exécution être stocké dans la variable "int Runtime ;", et laissons "RunTime < 1000".

Ensuite, nous invoquons "Sleep (1000 - RunTime) ;" pour nous assurer que la prochaine exécution aura lieu dans 1000 ms, avec une précision donnée bien sûr.

Mais.

Référence MQL4 : https://docs.mql4.com/common/Sleep: "La fonction Sleep() ne peut pas être appelée depuis des indicateurs personnalisés car ils calculent dans le thread de l'interface et ne peuvent pas le ralentir."

 

Une solution simple :

Incluez les calculs dans votre EA et tout ira bien.

Pour :

Pas besoin d'appeler icustom

Pas d'indicateur

Contre :

Pas d'indicateur. Mais pour le trading à haute fréquence, vous *doit* utiliser un EA parce que les humains sont trop lents.

 

Les termes "haute fréquence" et "faible latence" sont légèrement différents.

En outre, les visualisations sont souvent utilisées pour l'analyse ou le suivi, et pas seulement pour le trading.

 
Ais:

Les termes "haute fréquence" et "faible latence" sont légèrement différents.

Et les visualisations sont souvent utilisées pour l'analyse ou le suivi, pas seulement pour le trading.

Si vous avez vraiment besoin d'un suivi, vous pouvez reconstruire le comportement de l'indicateur avec des lignes. Bien sûr, la haute performance est quelque chose de différent.

 

Que se passe-t-il si nous voulons analyser et surveiller des événements sur la base d'intervalles de temps ?
Par exemple, toutes les secondes.

 
Ais:

Que faire si nous voulons analyser et surveiller des événements sur la base d'intervalles de temps ?
Par exemple, toutes les secondes.

Dès que vous parlez de tic-tac, signifie ultra haute fréquence .....

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

L'échantillonnage dans des intervalles prédéfinis peut être défini comme un échantillonnage à haute fréquence où 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);
  }
facilement recodable par un EA pour utiliser la bonne fonction de sommeil. C'est déjà fait.
 
zzuegg:
facilement recodable dans un EA pour utiliser la fonction de sommeil appropriée. Je l'ai déjà fait.


Beau programme. TimeCurrent() est le prix tick-by-tick dont nous avons besoin pour obtenir le prix de l'ordinateur !

Peut-être pouvons-nous construire une horloge synthétique à partir de cet exemple :

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

donnez-nous un indice ! zzuegg :)

123456
Nouveau commentaire