MetaTrader 5 herunterladen

Die Synchronisation Experts,Skripts und Indikatoren

23 Dezember 2015, 10:49
Сергей Ковалев
0
551

Einführung

Es gib drei Arten von Programmen, die in der Programmiersprache MQL4 geschrieben sind und im MetaTrader 4 Client-Terminal ausgeführt werden::
- Experte;
- Skripts;
- Indikatoren.

Jedes davon hat einen bestimmten Aufgabenbereich. Hier eine kurze Beschreibung der Programme.

1. Kurze Beschreibung der Benutzerprogramme MQL4

1.1. Experten
Experten - sind die am meisten genutzten Programme, um profitable Tradingstrategien auszuführen. Charakteristisch für einen EA sind folgende Eigenschaften:
1. Die Fähigkeit, eingebettete Funktionen zu benutzen, welche die Trades unterstützen.
2. Die Fähigkeit, externe Einstellungen manuell zu modifizieren.
3. Die Verfügbarkeit von Regeln, welche die Initiierung der Spezialfunktion start() regulieren. Diese wird tickweise gestartet. In dem Moment, wenn ein Tick hereinkommt, werden die für diese Funktion verfügbaren ganzen Environment-Parameter aktualisiert. Zum Beispiel ändern Variable wie bid und ask ihre Werte. Wenn die Funktion start() die Ausführung des Codes vollendet hat, nämlich wenn der return-Operator erreicht wurde, beendet sie ihre Aktivität und ruht, bis ein neuer Tick hereinkommt.
1.2. Skripts
Scripts sind Experten sehr ähnlich, aber ihre Eigenschaften sind etwas anders. Hier die wichtigsten Eigenschaften:
1. Scripts können die Tradefunktionen ebenfalls nutzen.
2. Parameter externer Einstellungen können in Scripts nicht verändert werden.
3. Das wichtigste Merkmal von Scripts ist die Regel, nach der die Spezialfunktion start() eines Scripts nur einmal gestartet wird, nämlich sofort nachdem sie an den Chart angeheftet und initiiert worden ist.

Experten und Scripts werden an das Hauptfenster eines Symbols angeheftet, für sie gibt es keine speziellen Unterfenster.

1.3. Indikatoren
Der Zweck der Indikatoren unterscheidet sich von dem der Experten und Scripts:
1. Die wichtigste Eigenschaft der Indikatoren ist die Möglichkeit, durchgehende/fortlaufende Kurven zu zeichnen, welche irgendeine Gesetzmäßigkeit für einen bestimmten Zweck anzeigen.
2. Trade-Funktionen können bei Indikatoren nicht angewendet werden.
3. Indikatoren werden tickweise gestartet.
4. Bezüglich seiner Parameter kann der Indikator im Haupt-Symbol-Fenster oder in einem eigenen Unterfenster ausgeführt werden.

Wir haben oben nur die wichtigsten Merkmale der Benutzer-Programme aufgelistet, nämlich jene, die wir in der Folge benötigen.

Wie wir in der obigen Beschreibung sehen können, hat keins der Benutzer-Programme Eigenschaften aller übrigen Programme: Experten und Scripts können nicht zeichnen, Indikatoren können nicht traden, und so weiter.

Wenn Ihr Trading-System die Eigenschaften aller Benutzer-Programme benötigt, ist die einzige Lösung die, einen Experten, ein Script und einen Indikator gleichzeitig zu benutzen.

2. Darstellung des Problems

In den folgenden Fällen ist die gleichzeitige Anwendung aller Benutzerprogramme notwendig.

2.1. Rechtzeitige Ausführung
Jeder Befehl des Benutzers muss sofort ausgeführt werden. Doch das ist mit einem expertengestützten Programm nicht immer möglich. Der größte Nachteil eines Experten besteht darin, dass er keine Ausgabe rechnen kann. Der Grund für diese Einschränkung ist ganz einfach: Der Basic Code des Experten wird tickweise gestartet. Was geschieht, wenn der Benutzer dem Experten befiehlt, eine Order zu schließen und der Experte auf den nächsten Tick wartet? Das hängt davon ab, wie der Experte geschrieben wurde. In einigen Fällen wird der Befehl ausgeführt, allerdings mit etwas Verzögerung.

Das Programm kann so organisiert werden, dass der Haupt-Code des Experten kontinuierlich ausgeführt wird, ohne Unterbrechungen zwischen den Ticks. Dafür ist es notwendig, die Spezialfunktion start() zu benutzen,eine unendliche Loop, in die der gesamte Haupt-Code eingefügt wird. Wenn die Environment-Information am Anfang jeder Loop zwangsläufig aktualisiert wird, kann der ganze Komplex erfolgreich arbeiten. Der Nachteil eines Experten mit unendliche Loop ist, dass das Einstellungsfenster nicht geöffnet werden kann. Wenn Sie versuchen, einen Experten mit unendliche Loop zu versehen, dann können Sie ihn nicht mehr konfigurieren.

Das Gleiche kann auch bei einem Script erfolgreich durchgeführt werden. Das heißt, eine unendliche Loop kann in einen Script eingebaut werden. Aber dann können in den Script keine Parameter konfiguriert werden.

Die Anpassbarkeit des Trading-Systems und die rechtzeitige Ausführung aller Benutzeranweisungen im kontinuierlichen Betriebsmodus ist nur möglich, wenn man gleichzeitig einen EA für die Installation und einen Script für die sofortige Ausführung verwendet.

2.2. Die Übersicht behalten
Manchmal muss man Informationen über das Trading bekommen. Zum Beispiel würde jeder Trader gerne wissen, dass, in einem bestimmten Moment (sagen wir zwei Minuten, bevor wichtige Nachrichten veröffentlicht werden, das Dealing-Center seine sonst 10 Punkte des mindestens tolerierbaren Abstands zum Setzen von Pending Orders auf 20 Punkte erhöht hat . Außerdem möchte der Trader in der Regel den Grund dafür wissen, warum der Trade-Server Anweisungen nicht ausführt. Diese und andere nützliche Informationen können als Text im Indikator-Fenster gezeigt werden. Ebenso können im Verlauf die Zeilen, welche ältere Nachrichten enthalten, nach oben verschoben werden, um Platz für neue Nachrichten vom Trading-System zu machen. In diesem Fall ist es notwendig, den handelnden Experten oder Script mit einem grafischen Indikator zu kombinieren.

2.3. Steuerelemente
Wenn Sie ein Trading-System mit einem verbesserten Interface benutzen, sollten die Steuerelemente (grafische Objekte) lieber im Indikatorfenster platziert werden. So können wir sicher sein, dass die Kurve mit den Kerzen unsere Steuerelemente nicht verdeckt und so beim Traden stört.

2.4. Systemanforderungen
Die Hauptanforderung an das Ergebnis ist in diesem Fall ein synchrones Funktionieren, so dass es bei der Entwicklung eines auf allen drei Programmtypen nötig ist, einzelne Aufgaben getrennt zu betrachten, damit diese von allen Komponenten des Programms gelöst werden können. Im Hinblick auf spezielle Merkmale von jedem Programmtype unseres Systems können wir die folgenden Merkmale dafür definieren:

Sckript - gibt den Basis-Code, der analytische und Trading-Funktionen beinhaltet;

Experte - liefert das Einstellungsfeld;

Indikator - liefert ein Bedienfeld in einem Unterfenster, um die Steuerelemente und Informationen anzuzeigen.

3. Software-Lösungen

Wir möchten gleichzeitig darauf hinweisen, dass wir hier die Struktur einer auf drei Komponenten basierenden Anwendung betrachten, die nur ein Minimum an notwendigen Elementen beinhaltet. Wenn Sie beschließen, die Anwendung in der Praxis zu benutzen, müssen Sie diese selbst erstellen, was die analytischen und Trading-Funktionen betrifft. Doch das weiter unten beschriebene Material ist zur Entwicklung einer Struktur erst einmal ausreichend.

3.1. Experte
Zunächst einmal betrachten wir im Detail, woraus ein Experte besteht und wie er arbeitet.

// Expert.mq4
//--------------------------------------------------- include ----
#include <stdlib.mqh>
#include <stderror.mqh> 
#include <WinUser32.mqh> 
//-----------------------------------------------------------------
#include <Peremen_exp.mq4>  // Die Beschreibung der Experte-Variablen.
#include <Metsenat_exp.mq4> // Die Vorbestimmung der Experte-Variablen.
#include <Del_GV_exp.mq4>   
// Löschung alle  GlobalVariable, die vom Experte erstellt wurden.
#include <Component_exp.mq4> // Überprüfung, ob es Komponenten gibt.
#include <Component_uni.mq4> 
// Die Meldung, dass es im Indikator keine Komponenten gibt.
//------------------------------------------------------------------
//
// 
//------------------------------------------------------------------
int init()  
  {
    Fishka=1;          // Wir sind in init()  
    Metsenat_exp();   // Vorbestimmung der Experte-Variablen.
    Component_exp();  // Überprüfung, ob es Komponenten gibt
    return
 } 
//------------------------------------------------------------------
int start() 
  { 
    Fishka=2;         // Wir sind in start()  
    Component_exp();  // Überprüfung, ob es Komponenten gibt
    return;                                                          
 }
//-------------------------------------------------------------------
int deinit() 
  {   
    Fishka=3;         // Wir sind in deinit()  
    Component_exp();  // Überprüfung, ob es Komponenten gibt
    Del_GV_exp();     // Löschung GlobalVariable des Experten.
    return;
 }
//-------------------------------------------------------------------

In der speziellen Funktion init() funktionieren zwei Funktionen - Metsenat_exp() und Component_exp()

Metsenat_exp() - eine Funktion zur Voreinstellung einiger Variablen.
// Metsenat_exp.mq4
//-----------------------------------------------------------------
int Metsenat_exp()
 {
//--------------------------------------------- Vorbestimmung ---
   Symb     = "_"+Symbol();
   GV       = "MyGrafic_GV_";
//--------------------------------------------- GlobalVariable ----
   GV_Ind_Yes = GV+"Ind_Yes"   +Symb;      
// 0/1 Bestätigt die Tatsache, dass der Indikator geladen ist
   GV_Scr_Yes = GV+"Scr_Yes"   +Symb;      
// 0/1 Bestätigt die Tatsache, dass das Skript geladen ist
//---------------------------------------------- Veröffentlichen ----
   GV_Exp_Yes = GV+"Exp_Yes"   +Symb;     
   GlobalVariableSet(GV_Exp_Yes, 1 ); 
   GV_Extern  = GV+"Extern"    +Symb;     
   GlobalVariableSet(GV_Extern,  1 ); 
//  AAA  wird als Beispiel verwendet:
   GV_AAA     = GV+"AAA"       +Symb;     
GlobalVariableSet(GV_AAA,   AAA ); 
//------------------------------------------------------------------
   return;
 }
//------------------------ Das Ende des Moduls --------------------------------

Eine der Aufgaben, um die ganze Anwendung am Laufen zu halten, ist es, die Verfügbarkeit aller Komponenten (Skript, Experte und Indikator) ständig zu überprüfen. Deshalb müssen die Komponenten (Skript, Experte und Indikator) einander ständig überwachen und, wenn einer von ihnen nicht verfügbar ist, ihre Arbeit abbrechen und den Benutzer darüber informieren. Zu diesem Zweck informiert jedes Programm beim Start über seine Verfügbarkeit indem es eine globale Variable anzeigt. Im vorliegenden Fall der zum Experten gehörenden Funktion Metsenat_exp() geschieht dies durch die untenstehende Zeile:
   GV_Exp_Yes = GV+"Exp_Yes"   +Symb;     
   GlobalVariableSet(GV_Exp_Yes, 1 );

Die Funktion Metsenat_exp() wird durch die zum Experten gehörende Funktion init() gesteuert, d. h., sie wird nur einmal beim Start oder bei der Änderung externer Variablen eingesetzt. Das Skript muss über veränderte Einstellungen Bescheid wissen, weshalb der Experte den Skript darüber informiert, indem er den Wert der globalen Variable GV_Extern ändert:

   GV_Extern  = GV+"Extern"    +Symb;     
   GlobalVariableSet(GV_Extern,  1 );

Component_exp()
- eine Funktion, welche die Vollständigkeit kontrollieren soll. Die weitere Entwicklung hängt von der zum Experten gehörenden Spezialfunktion ab, in der Component_exp() benutzt wird.
// Component_exp.mq4 
//----------------------------------------------------------------
int Component_exp()
 {
//----------------------------------------------------------------
   while( Fishka < 3 &&          // Wir sind in init() oder in start() und ..
      (GlobalVariableGet(GV_Ind_Yes)!=1 || 
       GlobalVariableGet(GV_Scr_Yes)!=1)) 
    {                            // ..solange, bevor jemand kommt.
      Complect=0;                // Also wenn es jemanden nicht gibt, dann ist es nicht vollständig
      GlobalVariableSet(GV_Exp_Yes, 1); 
// Informieren wir die Verfügbarkeit des Experten
//-----------------------------------------------------------------
      if(GlobalVariableGet(GV_Ind_Yes)==1 && 
         GlobalVariableGet(GV_Scr_Yes)!=1)
        {//Wenn es einen Indikator gibt, aber es ist kein Skript in vorhanden, dann..
         Graf_Text = "ist der Script nicht installiert.";  
// Der Text der Meldung
         Component_uni();                             
// Schreiben wir den Texе  der Meldung im Indikator-Fenster.
        }
//-----------------------------------------------------------------
      Sleep(300);
    }
//-----------------------------------------------------------------
     if(Complect==0)
    {
      ObjectDelete("Necomplect_1"); 
// Löschung der nicht mehr benötigen Meldungen  dass die Komponenten nicht mehr gibt   
      ObjectDelete("Necomplect_2");       
      ObjectsRedraw();   // Zur mobilen Löschung 
      Complect=1;        //  Wenn wir die Loop verlassen haben, dann sind alle da
    }
//-----------------------------------------------------------------
   if(Fishka == 3 && GlobalVariableGet(GV_Ind_Yes)==1)
// Wir sind in deinit() und es gibt den Raum, wo wir den Indikator einschreiben können
    { 
//-----------------------------------------------------------------
      if(GlobalVariableGet(GV_Scr_Yes)!=1)  // Wenn es keinen Skript gibt
       {
         Graf_Text = "wurden die Elementen Expert und Script nicht installiert";
// Meldung (da wir Entladen)
         Component_uni();     // Schreiben wir den Text der Meldung im Indikator-Fenster.
       }
//----------------------------------------------------------------
    }
//----------------------------------------------------------------
   return;Das Ende des Moduls
 }
//--------------------- Das Ende des Moduls ------------------------------

Die Verfügbarkeit von Skript und Indikator wird überwacht, indem die Werte der entsprechenden globalen Variablen - GV_Scr_Yes und GV_Ind_Yes gelesen werden. Wenn keiner der Komponenten verfügbar ist, wird die Kontrolle an die unendliche Loop übergegen, bis die Vollständigkeit erreicht ist, d. h., bis sowohl der Indikator als auch das Skript installiert wurden. Die Anwendung informiert dann den Benutzer über den aktuellen Stand mittels der Funktion Component_uni(). Dies ist eine universale Funktion, die in allen Komponenten enthalten ist.
// Component_uni.mq4
//----------------------------------------------------------------
int Component_uni()
 {
//----------------------------------------------------------------
//----------------------------------------------------------------
   Win_ind = WindowFind("Indicator");                 
// Welche Fenster-Nummer ist bei unserem Indikator?
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
   ObjectCreate ( "Necomplect_1", OBJ_LABEL, Win_ind, 0, 0  );
// Erstellen wir ein Objekt in unserem Indikator-Fenster
   ObjectSet    ( "Necomplect_1", OBJPROP_CORNER,        3  );
// mit Koordinaten. in der rechten unteren Ecke
   ObjectSet    ( "Necomplect_1", OBJPROP_XDISTANCE,   450  );
// mit Koordinaten auf Х..
   ObjectSet    ( "Necomplect_1", OBJPROP_YDISTANCE,    16  );
// mit Koordinaten auf Y..
   ObjectSetText("Necomplect_1", Graf_Text,10,"Courier New",Tomato);
// Der Text, Schrift und Farbe
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
   Graf_Text = "Die Anwendung funktioniert nicht.";
 // Der Text der Meldung
   ObjectCreate ( "Necomplect_2", OBJ_LABEL, Win_ind, 0, 0);
// Erstellen wir ein Objekt in unserem Indikator-Fenster
   ObjectSet    ( "Necomplect_2", OBJPROP_CORNER,        3);
// mit Koordinaten in der rechten unteren Ecke
   ObjectSet    ( "Necomplect_2", OBJPROP_XDISTANCE,   450);
// mit Koordinaten auf Х..
   ObjectSet    ( "Necomplect_2", OBJPROP_YDISTANCE,     2);
// mit Koordinaten auf Y..
   ObjectSetText("Necomplect_2", Graf_Text,10,"Courier New",Tomato);
// Der Text, Schrift und Farbe
// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - 
   ObjectsRedraw();      // Neuzeichnen.
   return;
//----------------------------------------------------------------
 }
//--------------------- Das Ende des Moduls  -----------------------------

Sobald die Anwendung vollständig ist, wird die Steuerung im EA von der unendlichen Loop an den folgenden Code übergeben, wo die nun nutzlos gewordene Information über die Unvollständigkeit gelöscht wird.

Wenn die EA entladen ist, wird die Spezialfunktion deinit() ebenfalls die Funktion Component_exp() aufrufen, aber zu einem anderen Zweck – um diese über die aktuelle Entladung zu informieren.

In deinit() im Experten wird auch die Funktion Del_GV_exp()aufgerufen. Sie löscht alle GlobalVariable, die vom Experten geöffnet werden. Entsprechend einem ungeschriebenen Gesetz müssen normalerweise alle vom EA geöffneten globalen Variablen gelöscht werden, alle entladenen Programme müssen “den Raum saubermachen”, d.h., zuvor geschaffene globale Variablen und grafische Objekte löschen.
// Del_GV_exp.mq4
//----------------------------------------------------------------
int Del_GV_exp()
 {
//----------------------------------------------------------------
   GlobalVariableDel(GV_Exp_Yes      ); 
   GlobalVariableDel(GV_Extern       ); 
   GlobalVariableDel(GV_AAA          ); 
//----------------------------------------------------------------
   return;
 }
//---------------------Das Ende des Moduls-----------------------------


Auf diese Weise fängt der Experte an zu arbeiten und überprüft die Verfügbarkeit der anderen zwei Komponenten in allen Phasen: einmal in init(), einmal in deinit() und, bei jedem Tick, in start(). Diese Einstellung des EA macht es möglich, das Programm für unsere Aufgabe zu nutzen – indem sie das Einstellungsfeld verfügbar macht. Die Datei, welche Variable beschreibt, enthält z.B. die Variable AAA und die ihr entsprechende globale Variable GV_AAA, deren Wert vom Skript abgelesen wird.

Um mehr darüber zu erfahren, wie all das funktioniert, betrachten wir einmal die Struktur eines Skripts.

3.2. Skript
Script code:

// Script.mq4
//-------------------------------------------------- include ----
#include <stdlib.mqh> 
#include <stderror.mqh>
#include <WinUser32.mqh>
//----------------------------------------------------------------
#include <Peremen_scr.mq4>       
// Die Beschreibungsdatei der Skripts-Variablen. 
#include <Metsenat_scr.mq4>      
// Vorbestimmung der Skripts-Variablen.   
#include <Mess_graf_scr.mq4>     
// Die Liste aus grafischen Meldungen.
#include <Novator_scr.mq4>       
// Environment scannen, von einigen Variablen neue Werten bekommen
#include <Del_GV_scr.mq4>        
// Löschen alle GlobalVariable, die vom Skript erstellt wurden.
#include <Component_scr.mq4>     
// Überprüfung, ob es Komponenten gibt.
#include <Component_uni.mq4>     
// Die Meldung, dass es im Indikator keine Komponenten gibt.
#include <Del_Obj_scr.mq4>       
// Löschung alle Objekten, die vom Programmkomplex erstellt wurden.
#include <Work_scr.mq4>          
// Die Hauptarbeitsfunktion des Skripts. 
//----------------------------------------------------------------
//
// 
//----------------------------------------------------------------
int init()  
 {
   Fishka = 1;              // Wir sind in init()  
   Metsenat_scr();          // Vorbestimmung der Skripts-Variablen.
   return;
 }
//----------------------------------------------------------------
int start()  
 {
   Fishka = 2;              // Wir sind in start()  
   while(true)
    {
      Component_scr();      // Überprüfung, ob es Komponenten gibt
      Work_scr();           // Die Hauptarbeitsfunktion des Skripts.
    }
   return;
 }
//----------------------------------------------------------------
int deinit() 
 {
   Fishka = 3;               // Wir sind in deinit()  
   Component_scr();          // Überprüfung, ob es Komponenten gibt
   Del_Obj_scr();            // Löschung der erstellten grafischen  Objekten
   Del_GV_scr();             // Löschung GlobalVariable des Experten.
   return;
 }
//-----------------------------------------------------------------

Die Basis des Codes ist die Verfügbarkeit einer unendliche Loop in der Spezialfunktion start(). In dem Skript-Code werden Funktionen mit ähnlichen Namen und Inhalten angewendet. Wir konzentrieren uns auf ihre besonderen Merkmale. Am Anfang jeder neuen Loop wird die Funktion Component_scr() aufgerufen.
// Component_scr.mq4   
//----------------------------------------------------------------
int Component_scr()
 {
//----------------------------------------------------------------
   Iter=0;                       // Setzen wir den Iterationszähler auf 0
   while (Fishka <3 &&           // Wir sind in init() oder start() 
      (GlobalVariableGet(GV_Ind_Yes)!=1 || 
       GlobalVariableGet(GV_Exp_Yes)!=1)) 
    {                            // solange, bevor jemand kommt
      GlobalVariableSet(GV_Scr_Yes, 1);               
// Informieren wir die Verfügbarkeit des Skripts
//-----------------------------------------------------------------
      Iter++;                    // Der Iterationszähler
      if(Iter==1)                // Überspringen wir die erste Iteration
       {
         Sleep(500);
         continue;
       }
//-----------------------------------------------------------------
      if(Iter==2)               // Mit der zweiten Iteration treffen wir Maßnahmen
       {
         Complect=0;            // Also wenn es jemanden nicht gibt, dann ist es nicht vollständig
         for (i=0;i<=31;i++)ObjectDelete(Name_Graf_Text[i]);
// Löschung allen Zeilen
//  Darein kann man auch die Funktion einfügen, die die Warteschlange aus Handeln-Operationen auf 0 setzt.
       }
//-----------------------------------------------------------------
      if(GlobalVariableGet(GV_Ind_Yes)==1 && 
          GlobalVariableGet(GV_Exp_Yes)!=1)
       {                    // Wenn es einen Indikator gibt, aber es ist kein Experte in vorhanden
         Graf_Text = "Der Experte Expert wurde nicht installiert."; 
// Der Text der Meldung 
         Component_uni();                             
// Schreiben wir den Text der Meldung im Indikator-Fenster
       }
//-----------------------------------------------------------------
      Sleep(300);
    }
//-----------------------------------------------------------------
   if(Complect==0)         // Das machen wir einmal nach der Vollendung
    {
      ObjectDelete("Necomplect_1"); 
// Löschung der nicht mehr benötigen Meldungen
      ObjectDelete("Necomplect_2"); 
// dass es keine Komponenten gibt        
      Mess_graf_scr(1);
// Informieren wir den Benutzer über die Vollständigung 
      if( IsExpertEnabled()) 
// Der EA-Knopf ist an
       {
         Mess_graf_scr(3000);
         Knopka_Old = 1;
       }
      if(!IsExpertEnabled()) 
// Der EA-Knopf ist aus
       {
         Mess_graf_scr(4000);
         Knopka_Old = 0;
       }
      Complect=1; 
// Die minimale Installation-Vollständigkeit ist erreicht
      Redraw = 1; 
// Zur mobilen Löschung  
    }
//-----------------------------------------------------------------
   if(Fishka == 3 && GlobalVariableGet(GV_Ind_Yes)==1)      
// Wir sind in deinit()  
    {
      for(i=0;i<=31;i++)ObjectDelete(Name_Graf_Text[i]);    
// Löschung allen Zeilen
//-----------------------------------------------------------------
      if(GlobalVariableGet(GV_Exp_Yes)!=1)                 
// Wenn es einen Indikator gibt, aber es ist kein Experte in vorhanden
         Graf_Text="wurden die Elementen Expert und Script nicht installiert.";
// Meldung (da wir Entladen)
      if(GlobalVariableGet(GV_Exp_Yes)==1)
// Wenn es einen Indikator und einen Experte gibt
         Graf_Text="ist der Script nicht installiert"; 
// Meldung (da wir Entladen)
      Component_uni();             // Schreiben wir die Meldung im Indikator-Fenster.
//----------------------------------------------------------------
      ObjectsRedraw();             // Zur mobilen Löschung 
    }
//-----------------------------------------------------------------
   return;
 }
//------------------------- Das Ende des Moduls ---------------------------

Die erste Anforderung an einen Skript ist die Kontinuität seiner Arbeit. Während die externen Variablen aktualisiert werden, geht der Experte die komplette Installation durch. Wenn man im EA-Einstellungsfenster auf OK drückt, wird dieser entladen und übergibt die Steuerung ain deinit(), dann wird er sofort wieder geladen und geht dabei erst durch init() und dann durch start(). Dadurch löscht der EA, wenn auch nur für kurze Zeit, die globale Variable von deinit(), welche seine Verfügbarkeit bestätigt.

Damit das Skript nicht “glaubt”, dass der EA überhaupt nicht geladen wurde, enthält die Funktion Component_scr() einen kleinen Block, der es unmöglich macht, eine Entscheidung schon bei der ersten Iteration zu fällen:

      Iter++;               // Der Iterationszähler
      if(Iter==1)           // Überspringen wir die erste Iteration
        {
          Sleep(500);
          continue;
        }

Fünfhundert Millisekunden werden meistens genug sein, um den Experten zu laden. Wenn man einen aufwendigeren Code im init() des EA verwenden, muss die Zeit verlängert werden. Wenn der EA bei der zweiten Iteration nicht entdeckt wurde, wird entschieden, dass er gar nicht verfügbar ist, und das Skript bricht die Arbeit ab.

      Complect = 0;         // Also wenn es jemanden nicht gibt, dann ist es nicht vollständig


Der Ausdruck “das Skript bricht die Arbeit ab” wird im vorhergehenden Absatz benutzt. In unserem Beispiel gibt es keinen Code dafür, einfach, weil dies den Rahmen unseres Themas und dieses Artikels sprengen würde. Dort, wo man die entsprechenden Funktionen aufrufen kann, gibt es einen Kommentar in dem Code.

// Darein kann man auch die Funktion einfügen, die die Warteschlange aus Handeln-Operationen auf 0 setzt.

In der Funktion Work_scr() ,eines arbeitenden Programms, außer bei den Funktionen in unserem Beispiel, übernehmen andere Funktionen die Verantwortung für eine gewisse Ordnung der Geschehnisse. Wenn Ihr Programm z.B. so eingestellt wird, dass es mehrere Reihenfolgen modifiziert, dann wird es sicherlich eine Reihenfolge enthalten, in welcher die Schlange für die Ausführung von Trades gespeichert wird, wenn mehrere solcher Trades im aktuellen Tick ausgeführt werden.

Wenn eine Unvollständigkeit (zum Beispiel wenn der Experte oder das Skript versehentlich entladen wurden) in dem Moment passiert, wenn solch eine Reihenfolge stattfindet, ist es nötig, das Traden zu deaktivieren,, was dadurch erreichen kann, dass man den oben erwähnten Array der Trading-Operationen auf Null setzt und vielleicht auch einige andere Variablen, je nach Situation.

Die unendliche Loop des Skripts enthält auch die Funktion Work_scr(). Dies ist die Hauptfunktion des Skripts in den der gesamte Haupt-Code platziert werden muss.

// Work_scr.mq4
//--------------------------------------------------------------------------------------------------------------------------------жжжжжжж
int Work_scr()  
 {
   Novator_scr();
//-----------------------------------------------------------------
   // Der Hauptcode der ganzen Anwendung.
//------------------------------------------------ Als Beispiel ----
   if(New_Tick==1)           // bei jedem neuen Tick
    {                                                              
      Alert ("Der aktuelle Wert ААА = ", AAA);
    }                                                              
//-----------------------------------------------------------------
   if(Redraw==1)
    {
      ObjectsRedraw();       // Zur momentanen Darstellung
      Redraw=0;              // Nehmen wir das Hacken Objekte neu zeichnen weg
    }
//-----------------------------------------------------------------
   Mess_graf_scr(0);
   Sleep(1);                 // Für alle Fälle vor einer Überlastung
   return;
 }
//------------------------- Das Ende des Moduls  ---------------------------


Die Funktion Work_scr() enthält die Funktion Novator_scr(), welche die im Basis-Code enthaltenen Umgebungs-Variablen aktualisiert.

// Novator_scr.mq4  
//--------------------------------------------------------------------------------------------------------------------------------жжжжжжж
int Novator_scr()  
 {
//----------------------------------------------------------------=
//---------------------------------------- Erneuerung der Einstellungen ----
   if(GlobalVariableGet(GV_Extern)==1) 
// Der Experte wurde erneuert
    {
      Metsenat_scr();         // Erneuerung der Skripts-Variablen.
      Mess_graf_scr(5000);    // Die Meldung über die neue Einstellung.
      Redraw=1;               //  neu Zeichen am Ende der Loop.
    }                                                              
//--------------------------------- Der Status des EA-Knopfs ----
   Knopka = 0;                // Voreinstellung
   if( IsExpertEnabled()) Knopka = 1; 
// Erfahren wir den echten Status des EA-Knopfs
 
   if(Knopka==1 && Knopka_Old==0) 
// Wenn der Status für An geändert wurde
    {
      Knopka_Old = 1;         // Der alte wird jetzt so sein
      Mess_graf_scr(3);       // Informieren wir den Benutzer über die Änderungen
    }
   if(Knopka==0 && Knopka_Old==1) 
// Wenn der Status für Aus geändert wurde
    {
      Knopka_Old = 0;         // Der alte wird jetzt so sein
      Mess_graf_scr(4);       // Informieren wir den Benutzer über die Änderungen
    }
//-------------------------------------------------- Der neue Tick ----
   New_Tick=0;                // Erstmal auf 0 zurücksetzen
   if (RefreshRates()==true) New_Tick=1; 
// Einen neuen Tick ist einfach, zu empfangen, wenn man weißt, wie
//-----------------------------------------------------------------
//----------------------------------------------------------------=
   return;
 }
//------------------------------ Das Ende des Modul ----------------------------


Wir werden die Notwendigkeit dieser Funktion einmal näher betrachten. Am Anfang dieses Artikels haben wir erwähnt, dass jedes Mal, wenn der EA geladen wird, ebenso wenn seine Variablen aktualisiert werden, die ihm untergeordnete Funktion Metsenat_exp() den Wert der Variablen GV_Exterm auf 1 setzt. Für den Skript bedeutet dies, dass die Einstellungen aktualisiert werden müssen. Zu diesem Zweck enthält die Funktion Novator_scr() den folgenden Block:

//---------------------------------------- Erneuerung der Einstellungen ----
   if (GlobalVariableGet(GV_Extern)==1) 
// Der Experte wurde erneuert
    {
      Metsenat_scr();              // ОErneuerung der Skripts-Variablen.
      Mess_graf_scr(5000);         // Die Meldung über die neue Einstellung.
      Redraw=1;                    // neu Zeichen am Ende der Loop.
    }

Der Wert der obigen Variablen wird hier analysiert und, falls er aktualisiert werden muss, wird die Funktion Metsenat_scr() aufgerufen, welche die Aktualisierung (das Lesen neuer Werte von globalen Variablen) durchführt.
// Metsenat_scr.mq4
//--------------------------------------------------------------------
int Metsenat_scr()
  {
//------------------------------------------------------- int -------
//------------------------------------------------------- double ----
//------------------------------------------------------- string ----
    MyGrafic    = "MyGrafic_";
    Mess_Graf   = "Mess_Graf_";
    Symb        = "_"+Symbol();
    GV          = "MyGrafic_GV_";
//----------------------------------------------- GlobalVariable ----
    GV_Ind_Yes  = GV+"Ind_Yes" +Symb;       
// 0/1 Bestätigt die Tatsache, dass der Indikator geladen ist
     GV_Exp_Yes  = GV+"Exp_Yes" +Symb;       
// 0/1 Bestätigt die Tatsache, dass der Experte geladen ist
//------------------------------------------------ Veröffentlichen ----
     GV_Scr_Yes  = GV+"Scr_Yes" +Symb;     
    GlobalVariableSet(GV_Scr_Yes,          1 ); 
    GV_Extern   = GV+"Extern"  +Symb;     
    GlobalVariableSet(GV_Extern,           0 ); 
//--------------------------------------------------- Lesen ----
    //  AAA wird als Beispiel verwendet:
    GV_AAA      = GV+"AAA"     +Symb;     
    AAA  = GlobalVariableGet(GV_AAA); 
//----------------------------------------------------------------===
     return;
 }
//------------------------  Das Ende des Moduls ----------------------------------

Die Funktion Metsenat_scr() setzt wiederum den Wert der globalen Variablen GV_Extern = 0. In der darauffolgenden Historie bleibt diese Variable auf 0, bis der Nutzer das Einstellungsfenster des EA öffnet.

Geben Sie Acht darauf, dass das Skript während oder nach der Änderung der Einstellungen durch den Nutzer nicht unterbrochen wird, trotz der Tatsache, dass der EA aufgrund seiner geänderten Einstellungen durch alle Stadien des Entladens und Ladens geht. Auf diese Weise hilft die kombinierte Anwendung des Experten mit dem Skript die notwendige Kontinuität der Anwendung zu gewährleisten und erlaubt dem Nutzer die Einstellungen zu ändern, d.h. den Prozess zu steuern.

In den nachfolgenden Blocks der Funktion Novator_scr() wird der Knopf des EA gesteuert, der das Traden aktiviert. Wenn Ihr Trading-System es übernimmt, solche und ähnliche Parameter zu nutzen, ist Novator_scr() die Funktion für solche Berechnungen.

Zum Beispiel können Sie diese Funktion zusätzlich mit den folgenden Blocken vervollständigen: erkennen einen neuen Bar, die Auftrittszeit der extremen Ereignisse, Änderung in Handelsbedingungen((z.B., Spread Size, der Mindestabstand, bei dem die Stop-Orders platziert werden können, u.s.w ), sowie mit anderen Berechnungen, die nötig sind, bevor die grundlegenden analytischen Funktionen zu arbeiten beginnen.

Funktionen, die den Hauptinhalt des Progamms ausmachen, werden in der Funktion Work_scr() nicht gezeigt. In dem Artikel mit dem Titel Die Orders-Berechnung in einem großen Programm sprachen wir über die Funktion Terminal() die Orders berechnet. Wenn Sie das gleiche Berechnungsprinzip in Ihrem Trading-System benutzen, sollte die Funktion Terminal() sofort nach der Funktion Novator_scr()in die Funktion Work_scr()eingeschlossen werden.

Das Skript hat noch eine weitere Hilfsfunktion zu seiner Verfügung Mess_graf_scr(), zur Darstellung von Meldungen im Indikator-Fenster.

// Mess_graf_scr.mq4
//----------------------------------------------------------------
int Mess_graf_scr(int Mess_Number)
 {
//----------------------------------------------------------------=
   if(Mess_Number== 0)        // Das geht in jeder Loop Work
    {
      if(Time_Mess>0 && GetTickCount()-Time_Mess>15000) 
// In den letzten 15 sek hat sich der Farbdruck
       {                      // ..veraltet, zeichnen wir die Zeile grau
         ObjectSet(Name_Graf_Text[1],OBJPROP_COLOR,Gray);
// Die letzten 2 Zeile
         ObjectSet(Name_Graf_Text[2],OBJPROP_COLOR,Gray);
// Die letzten 2 Zeile
         Time_Mess=0;         // ein zusätzliches Hacken, nicht umsonst zu zeichnen 
         Redraw=1;            // Danach Neuzeichnen
       }
      return;                 // Das war ein kleiner Schritt 
    }
//-----------------------------------------------------------------
   Time_Mess=GetTickCount(); // Merken wir uns die Veröffentlichzeit der Meldung 
   Por_Nom_Mess_Graf++;      // Zählen wir die Zeile. Das wird der Teil des Namens.
   Stroka_2=0;               // Gehen wir davon aus, dass die Meldung nur eine Seile braucht
   if(Mess_Number>1000)      
// Aber wenn da eine große Nummer ist, dann bearbeiten es, 
// klar, dass die vorherige Seile aus der gleichen Meldung ist, das heißt, sie malen wir 
// nicht auf grau 
    {
      Mess_Number=Mess_Number/1000; 
      Stroka_2=1; 
    } 
//----------------------------------------------------------------=
   switch(Mess_Number)
    {
//-----------------------------------------------------------------
      case 1:
         Graf_Text = "Die nötigen Elementen wurden installiert.";
         Color_GT = LawnGreen; 
         break;
//-----------------------------------------------------------------
      case 2:
         Graf_Text = " ";
         break;
//-----------------------------------------------------------------
      case 3:
         Graf_Text = "Der EA-Knopf ist an.";
         Color_GT = LawnGreen; 
         break;
//-----------------------------------------------------------------
      case 4:
         Graf_Text = "Der EA-Knopf ist aus.";
         Color_GT = Tomato; 
         break;
//-----------------------------------------------------------------
      case 5:
         Graf_Text = "Die Experte-Einstellungen wurden erneuert.";
         Color_GT = White; 
         break;
//---------------------------------------------------- default ----
      default:
         Graf_Text = "Строка default "+ DoubleToStr( Mess_Number, 0);
         Color_GT = Tomato;
         break;
    }
//----------------------------------------------------------------=
   ObjectDelete(Name_Graf_Text[30]); 
// Das 30-te Objekt wird verdrängt, Löschen wir ihn
   int Kol_strok=Por_Nom_Mess_Graf;
   if(Kol_strok>30) Kol_strok=30;
//-----------------------------------------------------------------
   for(int lok=Kol_strok;lok>=2;lok--)
// Schauen wir mal die Namen der grafischen Texten
    {
      Name_Graf_Text[lok]=Name_Graf_Text[lok-1];        
// Neuschreiben (aufheben)
      ObjectSet(Name_Graf_Text[lok],OBJPROP_YDISTANCE,2+14*(lok-1));
//Ändern wir Koordinaten Y(Aufheben)
      if(lok==3 || lok==4 || (lok==2 && Stroka_2==0))
         ObjectSet(Name_Graf_Text[lok],OBJPROP_COLOR,Gray);
//Die alten Zeile zeichnen wir auf grau.. .
    }
//-------------------------------------------------------------------
   Graf_Text_Number=DoubleToStr( Por_Nom_Mess_Graf, 0); 
//Der persönliche Teil des Objektnamens = Die Nummer der Meldung.
   Name_Graf_Text[1] = MyGrafic + Mess_Graf + Graf_Text_Number;
// Umformen des Meldungsnamens.
   Win_ind= WindowFind("Indicator");                    
//Welche Fenster-Nummer ist bei unserem Indikator?
 
   ObjectCreate ( Name_Graf_Text[1],OBJ_LABEL, Win_ind,0,0);
// Erstellen wir einen Objekt in unserem Indikator-Fenster
   ObjectSet    ( Name_Graf_Text[1],OBJPROP_CORNER, 3   );  
// .. mit Koordination von der rechten. unteren Ecke..
   ObjectSet    ( Name_Graf_Text[1],OBJPROP_XDISTANCE,450); 
// ..mit Koordinaten auf Х..
   ObjectSet    ( Name_Graf_Text[1],OBJPROP_YDISTANCE, 2);  
// ..mit Koordinaten auf Y..
   ObjectSetText(Name_Graf_Text[1],Graf_Text,10,"Courier New",
                 Color_GT);
//Der Text, Schrift und Farbe
   Redraw=1;    // Danach Neuzeichnen
//----------------------------------------------------------------
   return;
 }
//---------------------- Das Ende des Moduls ----------------------------
Diese Funktion braucht nicht in allen Einzelheiten beschrieben zu werden. Es reicht, nur einige seiner speziellen Merkmale zu erwähnen.

1. Alle Meldungen werden mit grafischen Mitteln angezeigt.
2. Der formale Parameter, der an diese Funktion geschickt wird entspricht der Nummer der Meldung.
3. Wenn der Wert dieses Parameters zwischen 1 und 999 liegt, wird die Textzeile davor im Indikator-Fenster weiß. Wenn dieser Wert 1000 übersteigt, wird die Nachricht angezeigt und ihre Nummer stimmt mit dem übermittelten Wert, geteilt durch 1000, überein. Im letzteren Fall wird die Textzeile davor nicht weiß.
4. Fünfzehn Sekunden nach der letzten Meldung werden alle Zeilen weiß.
5. Damit die Zeilen jederzeit weiß werden können, sollte die Funktion von Zeit zu Zeit aktiviert werden. Deshalb steht am Ende der Funktion Work_scr() der Aufruf:

   Mess_graf_scr(0);


Im Artikel Der grafische Expert Advisor:AutoGraf wird ein wirklich funktionierender Programmkomplex vorgestellt, wo wir eine ähnliche Funktion benutzen, welche über 250 verschiedene Meldungen enthält. Sie können dieses für alle oder einige Meldung bei Ihrem Trading benutzen.

3.3. Indikator

Der Vollständigkeit halber wollen wir den Indikator ebenfalls besprechen, auch wenn sein Code recht einfach ist.

// Indicator.mq4
//--------------------------------------------------- include ----
#include <stdlib.mqh>
#include <stderror.mqh>
#include <WinUser32.mqh>
//----------------------------------------------------------------=
#include <Peremen_ind.mq4>       
// Die Beschreibung der Indikators-Variablen.
#include <Metsenat_ind.mq4>      
//  Vorbestimmung der Indikators-Variablen. 
#include <Del_GV_ind.mq4>        
//  Löschen alle GlobalVariable, die vom Indikator erstellt wurden.
#include <Component_ind.mq4>     
// Überprüfung, ob es Komponenten gibt.
#include <Component_uni.mq4>     
// Die Meldung, dass es im Indikator keine Komponenten gibt.
//----------------------------------------------------------------
//
// 
//----------------------------------------------------------------
#property indicator_separate_window
//----------------------------------------------------------------
//
//
//----------------------------------------------------------------
int init()  
 {
   Metsenat_ind();
   return;
 }
//----------------------------------------------------------------=
int start() 
 {
   if(Component_ind()==0) return; // Überprüfung, ob es Komponenten gibt
   //...
   return;                                                           
 }
//----------------------------------------------------------------=
int deinit() 
 {
   Del_GV_ind();             // Löschung der GlobalVariable des Indikators.
   return;
 }
//----------------------------------------------------------------


Hier soll nur ein entscheidendes Merkmal eines Indikators betont werden: Der Indikator wird in einem anderen Fenster angezeigt:

#property indicator_separate_window

Die Inhalte der Funktionen Metsenat_ind() und Del_GV_ind() ähneln den oben beschriebenen Funktionen, welche im Experten und im Skript benutzt werden.

Der Inhalt der Funktion Component_ind()ist ebenfalls einach:

// Component_ind.mq4
//--------------------------------------------------------------- 
int Component_ind()
 {
//----------------------------------------------------------------
   if(GlobalVariableGet(GV_Exp_Yes)==1 && 
      GlobalVariableGet(GV_Scr_Yes)==1)
//Wenn alle am Platz sind
    {// Informieren wir die Verfügbarkeit des Indikators
      if(GlobalVariableGet(GV_Ind_Yes)!=1)
          GlobalVariableSet(GV_Ind_Yes,1);
      return(1);
    }
//-----------------------------------------------------------------
   if(GlobalVariableGet(GV_Scr_Yes)!=1 && 
      GlobalVariableGet(GV_Exp_Yes)!=1)
    { // Wenn es keinen Skript, auch keinen Experte gibt 
      Graf_Text = "wurden die Elementen Expert und Script nicht installiert.";            
// Der Text der Meldung
      Component_uni();    // Schreiben wir den Text. der Meldung im Indikator-Fenster
    }
//-----------------------------------------------------------------
   return(0);
 }
//---------------- Das Ende des Moduls -----------------------------------
Wie wir am Code erkennen können, sendet die Funktion Component_ind() eine Meldung sowohl an den Skript als auch an den Experten, nur dann, wenn zwei andere Komponenten nicht geladen wurden. Wenn nur eins der Programme nicht verfügbar ist, geschieht nichts. Dies bedeutet, dass diese Programme, wenn sie im Symbolfenster verfügbar sind, die Zusammensetzung des Programmkomplexes nachverfolgen und den Nutzer über die Ergebnisse informieren.

Wenn nötig, kann auch die Haupteigenschaft des Indikators, nämlich das Zeichnen, genutzt werden. Für den Programmkomplex ist diese Eigenschaft nicht notwendig, aber sie kann beim reellen Traden verwendet werden, zum Beispiel, um das Unterfenster in Zonen zu unterteilen.

4. Praktische Anwendung

Die Order zum Anheften der Anwendungskomponenten an das Symbolfenster spielt keine Rolle. Jedoch ist es empfehlenswert den Indikator als Erstes anzuheften, da uns dies erlaubt, Kommentare zu lesen, sobald sie angeheftet werden.

Um zu zeigen, wie die Anwendung funktioniert, muss Folgendes gemacht werden.

1. Heften Sie den Indikator an das Symbolfenster. Folgendes wird dann sofort im Indikator-Fenster gezeigt:

die Elementen Expert und Script wurden nicht installiert
Die Anwendung funktioniert nicht.


2. Heften Sie den Experte an das Symbolfenster. Die Funktion Component_exp() wird ausgelöst und die folgende Meldung erscheint im Indikator-Fenster::

der Script wurde nicht installiert
Die Anwendung funktioniert nicht.


3. Heften Sie den Skript an das Symbolfenster. Diese Operation wird in der Funktion Component_scr() des Skripts verarbeitet und im Indikator-Fenster angezeigt:


Die nötigen Elementen wurden installiert.
Der EA-Knopf ist an.


Wenn der EA-Knopf deaktiviert war, wird die Meldung so aussehen:

Die nötigen Elementen wurden installiert.
Der EA-Knopf ist aus.


4. Sie können mehrmals auf den EA-Knopf drücken und sicher sein, dass diese Operationssequenz sofort von der Anwendung verarbeitet und in diesen Meldungzeilen angezeigt wird:

Der EA-Knopf ist aus.
Der EA-Knopf ist an.
Der EA-Knopf ist aus.
Der EA-Knopf ist an.
Der EA-Knopf ist aus.


Geben Sie Acht darauf, dass wegen des Skripts mit dem in diesem Programmkkomplex verwendten unendlichen Loop-Code die Reaktion des Programms auf die Steueraktion des Nutzers nicht in vielfachn Ticks, sondern sofort geschieht.

Wir haben, zum Beispiel, mittels der Funktion Alert() eine tickweise Anzeige einer Variablen der EA-Einstllungen in die Funktion Work_scr() platziert.



Wir betrachten einmal diese Eigenschaft. Die Funktion Work_scr() ist der Hauptteil des Skripts. Die Hauptloop des Skripts hat Zeit, sich hunderte Male zwischen den Ticks zu drehen, während die Meldung durch die Funktion Alert() in vielfache Ticks gesendet wird.

5. Öffnen Sie die Toolbar des EA und setzen sie wieder den Wert AAA mit 3 ein. Das Skript verfolgt diese Operation nach und zeigt folgend Meldung im Indikator-Fenster an:

Der EA-Knopf ist an.
Der EA-Knopf ist aus.
Der EA-Knopf ist an.
Der EA-Knopf ist aus.
Die Experte-Einstellungen wurden erneuert.


Das Fenster der Funktion Alert() zeigt dann den neuen Wert der Variablen AAA tickweise an:




6. Nun können Sie jedweden Komponenten in jedweder Reihenfolge laden oder entladen, den EA-Knopf anklicken, wie Sie wollen, den Wert von verstellbaren Variablen ändern und sich Ihre eigene Meinung über das Programmpaket bilden.

Abschluss

Indem wir die beschriebene Technologie anwenden, erreichen wir vor allem, dass der seine Arbeit nicht unterbricht, unabhängig davon, ob in seiner Umgebung Operationen durchgeführt werden oder nicht. Das Skript unterbricht seine Arbeit, wenn ein oder beide Komponenten (Indikator, Experte) nicht verfügbar sind.

Da beschriebene Prinzip zur Schaffung eines Programm-Pakets wird, leicht verändert, in der tatsächlich laufenden Anwendung AutoGraf benutzt, die in dem Artikel mit dem Titel Der grafische Expert Advisor:AutoGraf beschrieben ist.

SK. Dnepropetrovsk. 2006.

Übersetzt aus dem Russischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/1393

Beigefügte Dateien |
Exp_Scr_Ind.zip (33.49 KB)
Informationsspeicherung und Informations-Darstellung Informationsspeicherung und Informations-Darstellung

Der Artikel ist den bequemen und praktischen Speichermethoden und der Informations-Darstellung gewidmet. Hier werden Alternativen zur Standard-Log-Datei des Terminals und der Funktion Comment() betrachtet.

Charts ohne "Gaps" (Lücken) Charts ohne "Gaps" (Lücken)

Der Artikel widmet sich der Realisierung der Charts ohne verpasste Bars.

Das Expertensystem "Kommentator". Die praktische Verwendung der eingebauten Indikatoren im MQL4-Programm Das Expertensystem "Kommentator". Die praktische Verwendung der eingebauten Indikatoren im MQL4-Programm

Der Artikel betrachtet die Verwendung der technischen Indikatoren beim Programmieren in der MQL4-Sprache.

MQL4 wie ein Traders Werkzeug oder Advanced Technical Analysis MQL4 wie ein Traders Werkzeug oder Advanced Technical Analysis

Trading ist vor allem eine Wahrscheinlichkeitsrechnung. Und das Sprichwort «Faulheit ist der Motor für den Fortschritt» zeigt uns den Grund, warum all diese Indikatoren und Handelssysteme entwickelt worden sind. Daraus folgt, dass der größte Teil von neuen Tradern schon die entwickelten Handelstheorien lernt. Aber es gibt immer noch Markt-Geheimnisse, und Werkzeuge für die Analyse der Preisbewegungen, existieren meistens in der Form von realisierten technischen Indikatoren, mathematischen und statistischen Paketen. Vielen Dank Bill Williams für seinen Beitrag in der Marktbewegungen-Theorie. Aber man soll damit nicht aufhören.