Automatisierte Auswahl des Broker Unternehmen für einen Eiffizienten Betrieb von Expert Advisors

Einführung

Wir begegnen sehr oft Situationen, in denen ein Expert Advisor erfolgreich bei einem Broker Unternehmen arbeitet und nicht profitabel, oder gar mit Verlusten bei einem anderen. Die Gründe können unterschiedlich sein. Verschiedene Broker haben unterschiedliche Einstellungen:

• Kurse. Diese unterscheiden sich geringfügig wegen zwei Faktoren - verschiedene Daten-Feeds und unterschiedliche Filtration, die Kurse glättet. Für einige Expert Advisors kann dies von Bedeutung sein. Es können Situationen auftreten, in denen ein EA häufig mit einem Broker handelt, und nur selten bei einem anderen.
• Slippage. Er kann sich bei verschiedenen Brokern stark unterscheiden. Dies kann auch zu schlechteren Eigenschaften eines EA führen, aufgrund des niedriger erwarteten Gewinns.
  
• Requotes. Bei einigen Brokern treten sie öfter auf als bei anderen. In diesem Fall wird der EA erfolgreiche Einstiegspunkte verpassen, wegen einer großen Anzahl an Requotes.

Also, der Betrieb einiger EAs hängt stark von dem Broker-Unternehmen ab, bei dem er arbeitet. Wenn es keine Auswahl gäbe, könnten wir nach Kursen, Slippage und Requotes einstellen. Aber wir haben Auswahl, und sie wird breiter und breiter. Also, wir können verschiedene Broker vergleichen, ihre technischen Eigenschaften erkennen, Und mit diesen Informationen wählen wir die besten Broker Unternehmen für unseren EA.

Statistik

Natürlich können wir mehrere Terminals von verschiedenen Brokern starten, diese ein Monat oder zwei verwenden und dann einen auswählen, bei dem der Profit maximal ist. Aber eine solche Prüfung ist wenig informativ. Es wäre besser mehr Informationen zu erhalten: mittlere Slippage pro Trade, Anzahl der Requotes, die beim Öffnen von jedem sicheren Trade auftreten, Öffnungszeit, und so weiter. Um keine Protokolle analysieren zu müssen, wurde ein Projekt Statistic entwickelt. Es basiert auf der folgenden Zusammenstellung an Regeln:

1. Ein EA analysiert den Markt, führt Transaktionen aus, erhält alle notwendigen Informationen über einen Trade und übergibt ihn an ein gemeinsames Modul.
2. Dieses Modul enthält alle Informationen über die aktuellen und geschlossenen Geschäfte. Es erfasst außerdem die die Statistik über alle technischen Eigenschaften des Broker Unternehmens.
3. Es sollte möglichst komfortabel für den Betrieb mit großen Datenmengen sein, damit wir nur die notwendigen Informationen sehen, und nicht alle die gesammelt und erfasst werden können.

Durch Analyse der Statistik (Anzahl der Requotes, Dauer der Orderausführung, Slippage) und betrachte aller Trades können wir feststellen, mit welchem Broker Unternehmen besser zu arbeiten ist. Wenn die Statistik bei allen Unternehmen schlecht ist, sollten wir einige EA Parameter ändern, zum Beispiel die Zeit im Markt, Häufigkeit der Trades. Und ändern Sie diese, bis der EA anfängt mit Gewinnen zu arbeiten. Wenn ein EA auf einer bestimmten Stufe aufhört bei einem Broker Gewinne zu erzielen und profitabel bei anderen ist, beenden wir den Test bei diesem Unternehmen.

Theorie

Wir können die Eingabe von Daten in eine Anwendung entweder durch Dateien organsieren, oder durch dll. Die Variante mit Dateien ist einfacher in Bezug auf die technische Umsetzung, weil sie keine ernsthafte Systemprogrammierung erfordert. Allerdings ist das Arbeiten mit Dateien nicht sehr komfortabel, weil wir nicht im Voraus wissen, wo MetaTrader 4 Terminals für verschiedene Broker sein werden, auf welchen Währungen sie getestet werden, was machen, wenn die Dateien verloren gehen, und so weiter. Wenn wir alles dynamisch gemacht haben müssen, mit maximaler Sicherheit, ist es besser die Datenübergabe durch dll zu organisieren.

Um verschiedene Terminals mit einer dll zu betreiben, sollte sie sich im Systemverzeichnis Windows\System32 befinden. Es ist wichtig, dass EAs von einem Terminal ein und dieselbe dll-Kopie herunterladen, weil sie alle in einem Vorgang arbeiten, was das Terminal (terminal.exe) ist, was bedeutet, sie haben ein und denselben Adressraum, d.h. sie arbeiten mit den gleichen Variablen. Ein Terminal mit EAs hat seine eigene dll-Kopie und die gleichen Variablen, angegeben innerhalb der dll, ein anderes Terminal hat eine andere Kopie mit anderen Variablen. Daher erhält ein Terminal keinen Zugang zu Variablen von einem anderen Terminal.

Wir möchten eine einzelne erstellen, in der Daten von verschiedenen Terminals gesammelt werden. Es gibt verschiedene Arten einen synchronen Betrieb verschiedener Vorgänge in einem Datenfeld zu organisieren. Dies kann über Dateien realisiert werden, aber wir begegnen wieder dem Problem der Pfadangaben, sowie dem Problem mit der Verarbeitungsgeschwindigkeit, wen wir viele Terminals und EAs haben. Die beste Lösung ist ein teilbarer Kernspeicher. Mit ihm zu arbeiten erfordert höhere Aufmerksamkeit und Kenntnis über die Eigenschaften des verwendeten Betriebssystems (in unserem Fall ist es Windows), die zur Verfügung stehenden Möglichkeiten sind jedoch unendlich. Für die Organisation eines sukzessiven Zugriffs auf einen Block in dem gemeinsamen Speicher, wird ein spezieller Mechanismus der Programm Semaphoren verwendet.

Theorie Fazit: Über dll schreiben EAs Daten in gemeinsamen Speicher und dann in die Anwendung, nennen wir sie Monitor, diese liest die Daten aus dem Speicher, zeigt sie an und führt die notwendigen statistischen Berechnungen aus. Wenn MetaTrader 4 DLL zum ersten Mal aufruft, erstellt das Betriebssystem eine Kopie dieser DLL für jedes Terminal, weil jedes Terminal ein eigenständiger Prozess ist. Das Betriebsschema befindet sich unten im Bild.

Praxis

Expert Advisor

Sicher, Daten über den aktuellen Trade sollten von einem Expert Advsior gebildet werden. Für die Datenweitergabe müssen wir die Schnittstelle der dll bilden. Für die Umsetzung der Aufgabe benötigen wie drei Funktionen:

 bool NewExpert(string  isBrokerName, string isInstrument, int Digit);

Erstellen Sie einen neuen Experts Advisor, benennen ihn nach dem Namen von Broker und Aktie. Für die Berechnung einiger statistischer Eigenschaften, übergeben wir die Anzahl der Ziffern hinter dem Komma des Aktienkurses.

bool NewDeal(string isInstrument, int Action, int magik, 
double PriceOpen, int Slippage, int TimeForOpen, int Requotes);

Die Registrierung eines neuen Trades wird auf die folgende Weise durchgeführt. Während der Terminal-Prozess bereits durch einen Brokernamen ermittelt wird, ist für einen neuen Trade der Name einer Katie, auf die der Trade ausgeführt wird, ausreichend. Andere Parameter sind die Handelseigenschaften.

Tabelle 1. Trade Eröffnung

Parameter	Wert
Action	0 – buy, 1 - sell
magik	Magic number
PriceOpen	Eröffnungskurs
Slippage	Slippage
TimeForOpen	Ausführungsdauer
Requotes	Anzahl der erhaltenen Requotes

bool CloseDeal(string isInstrument, int magik, double PriceClose, 
               int Slippage, int TimeForClose, int Requotes);

Das Schließen eines Trades wird erkannt an einer Aktie und der Magic Number. Übergebene Parameter:

Tabelle 2. Trade schließen

Parameter	Wert
PriceClose	Schlusskurs
Slippage	Slippage
TimeForClose	Ausführungsdauer
Requotes	Anzahl der erhaltenen Requotes

Durch diese Schnittstelle werden die Initialisierungs-, Öffnen- und Schließen-Funktionen wie folgt aussehen:

Initialisierung:

int init()
  {
   int Digit;
   if(IsDllsAllowed() == false)
     {
       Print("Calling from libraries (DLL) is impossible." + 
             " EA cannot be executed.");
       return(0);
     }
   if(!IsTradeAllowed())
     {
       Print("Trade is not permitted!");
       return(0);     
     }
   Digit = MarketInfo(Symbol(), MODE_DIGITS);
   if((Digit > 0) && (Bid > 0))
     {  
       if(!NewExpert(AccountServer(), Symbol(), Digit))
         {
           Print("Creation of a new broker failed");
           return (0);
         }                      
       Print("A broker is successfully created ");                    
       return(0);      
     }   
   Print("No symbol in MarketInfo!");       
   return(0);  
  }

Während der Initialisierung, nach dem Überprüfen der Terminal-Parameter (Handelsfreigabe und Bestätigung des DLL Aufrufs), erhalten wir die Informationen über die Kommastellen einer Aktie und ihren aktuellen Kurs. Wenn beide Parameter größer als Null sind, wird die Aktie hinreichend im Chart dargestellt und wir können mit ihr arbeiten. Jeder Broker unterscheidet sich in seinem Namen, der über die Funktion AccountServer() erhalten werden kann, und durch diesen Namen unterscheiden sich die Terminals von anderen in dem gemeinsamen Speicher. EAs unterscheiden sich in den Namen der Aktien, mit denen Sie handeln. Das ist der Grund, weshalb verschiedene EAs, die an ein und dasselbe Währungspaar angehangen werden, ein und dieselbe DLL Kopie herunterladen werden, was zu einer Kollision führen kann.

Funktion zum Öffnen einer neuen Order:

int Deal(int act, double Lot)
  {
   int N = 0;
   int ticket;
   int err;
   double Price_open;
   double Real_price;
   datetime begin_deal;
   double Lots;
   int cmd;
   int magik;
   magik = GenericMagik() + 1;   
   Lots = NormalizeDouble(Lot, 1);
// checking margin for a position opening
   AccountFreeMarginCheck(Symbol(), cmd, Lots);
   err = GetLastError();
   if(err > 0)
     {
       Print("No money for new position");
       return(0);
     }      
   begin_deal=TimeCurrent(); 
   while(N < count)
     {
       if(act == 1)
         {
           Price_open = NormalizeDouble(Ask, Digits);
           cmd = OP_BUY;
         }
       if(act == 2)
         {
           Price_open = NormalizeDouble(Bid, Digits);
           cmd = OP_SELL;
         }
       ticket = OrderSend(Symbol(), cmd, Lots, Price_open,
                          slippage, 0, 0, 0, magik);
       if(ticket > 0)
         {
           if(OrderSelect(ticket, SELECT_BY_TICKET) == true)
             {
               Real_price = OrderOpenPrice();
               NewDeal(Symbol(), cmd,magik, Real_price ,
                       MathAbs(Real_price - Price_open),
                       (TimeCurrent() - begin_deal), N);
             }                   
           return(ticket);
         }
       N++;
       Sleep(5000);
       RefreshRates();
     } 
   return(0);
  }

Eine Order wird durch die Funktion Deal mit zwei Parametern geöffnet: action (1 - buy, 2 - sell ) und Lot. Jede Order unterscheidet sich von der vorherigen in der magic number - sie wird erhöht. Eine Position versucht in gezählten Versuchen zu öffnen. Die Informationen über die Anzahl der gesamten Versuche, den Kurs und Slippage werden an einen gemeinsamen Speicher übergeben, von wo es durch den Momitor gelesen wird.

Order Schließen Funktion:

bool CloseOrder(int magik)
  {
   int ticket, i;
   double Price_close;
   int count = 0;
   datetime begin_time;
   double Real_close; 
   begin_time = TimeCurrent();    
   for(i = OrdersTotal() - 1; i >= 0; i--) 
     {
       if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
           if(OrderSymbol() == Symbol()) 
               if(OrderMagicNumber() == magik)
                 {                  
                   while(count < 10)
                     {                       
                       if(OrderType() == OP_BUY)        
                           Price_close = NormalizeDouble(Bid, Digits);
                       if(OrderType() == OP_SELL)        
                           Price_close = NormalizeDouble(Ask, Digits);
                       if(OrderClose(OrderTicket(), OrderLots(),
                                     Price_close, slippage))
                         { 
                           Real_close = OrderClosePrice();
                           CloseDeal(Symbol(), magik, Real_close,
                                     MathAbs(Real_close - Price_close),
                                     (TimeCurrent() - begin_time), count); 
                           return(true);
                         }
                       count++;
                       Sleep(5000);
                       RefreshRates();
                     }
                 }
     }
   return(false); 
  }

Die Funktion zum Schließen CloseOrder() hat nur einen Eingabeparameter - die magic number. Eine Order versucht mehrere Male zu schließen, und diese Anzahl an Versuchen wird, zusammen mit der Ausführungsdauer der Order, Schlusskurs und Slippage, an den Speicher übergeben und dann durch den Monitor gelesen.

Der verbleibende Code ist der getestete EA. Also, für die Verwendung von Statistic in Ihren eigenen EA, müssen Sie die erforderlichen dll-Funktionen importieren. Für die Initialisierung und Öffnen/Schließen von Positionen verwenden Sie die Funktionen Deal und CloseOrder. Wenn Sie möchten, können Sie diese Funktionen neu schreiben, aber Daten über Transaktionen sollten in Übereinstimmung mit der in der dll enthaltenen Schnittstelle übergeben werden.

Unten ist ein Beispiel der Umsetzung eines solchen EA mit Verwendung von DLL (Code der oben aufgeführten Funktionen ist nicht inbegriffen).

// Enable dll for operation with monitor
#import "statistik.dll"
  bool NewExpert(string  isBrokerName, string isInstrument, 
                 int Digit);   // Create a broker
  bool NewDeal(string isInstrument, int Action, int magik, 
               double PriceOpen, int Slippage, int TimeForOpen,
               int Requotes);
  bool CloseDeal(string isInstrument, int magik, double PriceClose, 
                 int Slippage, int TimeForClose,
                 int Requotes);
#import
//---- 
extern int Num_Deals = 3;
extern int TimeInMarket = 4;
// maximally acceptable slippage
int  slippage = 10;
// time for rest after a trade
int TimeForSleep = 10;
// period of request
int time_for_action = 1;
// number of attempts for opening a position
int count = 5;
// Function of a new bar
bool isNewBar()
  {
    static datetime BarTime;
    bool res = false; 
    if(BarTime != Time[0]) 
      {
        BarTime = Time[0];  
        res = true;
      } 
   return(res);
  }
//+------------------------------------------------------------------+
//| Generation of magic                                                  |
//+------------------------------------------------------------------+ 
int GenericMagic()
  {
   int deals;
//----  
   for(int i = OrdersTotal() - 1; i >= 0; i--) 
     {
       if(OrderSelect(i, SELECT_BY_POS, MODE_TRADES))
           if(OrderSymbol() == Symbol())
               if(OrderMagicNumber() != 0)
                   deals++;
     }       
   return (deals);
  }
//+------------------------------------------------------------------+
//| forming signals to open/close a position                         |
//+------------------------------------------------------------------+
int GetAction(int &action, double &lot, int &magic)
   {
    int cnt, total;  
    if(OrdersTotal() <= Num_Deals)
      {
        if(Close[1] > Close[2])
          {
            action = 1;
            lot = 1;
            return(0);
          }
        if(Close[2] < Close[1])
          {
            action = 2;
            lot = 1;         
            return(0);               
          }
      }
    total = OrdersTotal();
    for(cnt = total - 1; cnt >= 0; cnt--)
      {
        if(OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES))
            if(OrderSymbol() == Symbol())  
                if((TimeCurrent() - OrderOpenTime()) > TimeInMarket*60)
                  {
                    action = 3;
                    magic = OrderMagicNumber();
                    return(0); 
                  }
      }
   }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
  {
   int action = 0;
   double lot = 1;
   int magic = 0;     
   while(!IsStopped())
     {
       Sleep(time_for_action*1000);      
       RefreshRates();
       if(isNewBar())
         {
           GetAction(action, lot, magic);
           if(((action == 1) || (action == 2)))
             {                                        
               if(IsTradeAllowed())
                   Deal(action, lot);
               Sleep(TimeForSleep*1000);
             }
           if(action == 3)
             {
               if(IsTradeAllowed())
                   if(!CloseOrder(magik))
                     {
                       Print("MANUAL CLOSING OF A POSITION IS NEEDED");
                       Sleep(TimeForSleep*1000);   
                     } 
             }
           action = 0;
           lot = 0;
           magik = 0;
         }
     }
   Print("A serious error occurred, the EA stopped operating");  
   return(0);
  }
//+------------------------------------------------------------------+

Der ausführende Block des EA ist ein unendlicher Zyklus auf der Start-Funktion. Bei einer voreingestellten Frequenz time_for_action ruft der EA die analytische Funktion GetAction() auf, die durch Bezug eine Aktion zurückgibt, die von dem EA ausgeführt werden sollte. Lot-Größe mit der die Position geöffnet werden soll, und magic für den Fall, dass sie die Position schließen müssen.

Der analytische Block ist hier elementar - Kaufen, wenn der vorherige Balken mehr was als der vor ihm, und verkaufen wenn es umgekehrt ist. Positionen werden nach Zeit geschlossen. Zum Testen Ihres eigenen EAs, schreiben Sie diesen Block einfach in Übereinstimmung mit Ihrem Algorithmus um. Sie können keine Änderungen in dem ausführenden Teil vornehmen.

DLL

DLL kann in verschiedenen Umgebungen und verschiedenen Sprachen umgesetzt werden. Die für unsere Arbeit notwendige DLL wurde in Visual C++ erstellt. Die Trades werden die folgende Struktur haben:

struct DealRec
  {
    int Index;
    int Magic;
    int Cur;
    int Broker;
    double PriceOpen;
    double PriceClose;
    int SlipOpen;
    int SlipClose;
    int Action;  // 0 = BUY 1 = SELL
    int TimeForOpen;
    int TimeForClose;
    int ReqOpen;
    int ReqClose;
    int Profit;
    bool Checked; // indication that the position is closed
  };

Sie werden in zwei Stufen verwirklicht werden - beim Öffnen und beim Schließen. D.h. Ein Teil der Daten (Eröffnungskurs, Slippage beim Öffnen usw.) wird beim Öffnen übergeben, ein anderer Teil (Schlusskurs, Schließzeit, usw.) wird beim Schlie0ßen übergeben. Prototypen des Aufrufens einer Funktion in einer dll

__declspec(dllexport) bool __stdcall NewExpert (char *isBrokerName, 
                                                char *isInstrument, 
                                                int Digit);
__declspec(dllexport) bool __stdcall NewDeal (char *isInstrument, 
                                              int Action, 
                                              int magic, 
                                              double PriceOpen, 
                                              int Slippage, 
                                              int TimeForOpen, 
                                              int Requotes);
__declspec(dllexport) bool __stdcall CloseDeal (char *isInstrument, 
                                                int magic, 
                                                double PriceClose, 
                                                int Slippage, 
                                                int TimeForClose, 
                                                int Requotes);

unterscheiden sich von Prototypen in MQL4 nur in beiläufigen Zeilen. Sie können die Quell-dll ansehen, die beim Erstellen anderer Projekte helfen kann. Für das Neu-Kompilieren des Projekts, öffnen sie die Datei statistic.dsw mit dem Programm Visual C++. Der gesamte Code der dll ist in den Dateien statistic.cpp und statistic.h, die übrigen sind nebensächlich. Alle aufgeführten Dateien befinden sich in Statistic.zip.

Monitor

Ein optimales Tool für das schnelle Schreiben von Anwendungen mit Tabellen und grafischer Schnittstelle - Lösung von Borland. Das ist Delphi und C++Builder.

Monitor Funktionen: Erstellen eines gemeinsamen Speichers, Daten von ihm auslesen und in einer Tabelle anzeigen, bewahren der Statistik des Slippage. Es gibt einige Optionen mehr, die das Arbeiten komfortabler machen. Dies ist die Funktionalität von Monitor:

1. Bewahren des Journals geöffneter Positionen,
2. Bewahren des Journals geschlossener Positionen,
3. Statistiken über Slippage und Requotes,
4. Einstellbare Tabellen,
5. Speichern von Trades in html-Dateien.

Die Umsetzung befindet sich in der angehängten zip-Datei Statistic Monitor.zip. Für das Neu-Kompilieren des Projekts verwenden Sie das Programm C++Builder. Die Erweiterung der Projektdatei ist *.bpr. Der wichtigste Code ist in в main.cpp.

Testen

Zum Testen wurde ein spezieller EA erstellt - er hat die einfachsten Bedingungen zum Einsteigen und Schließen von Positionen nach Zeit (die Umsetzung wurde vorher gezeigt). Der EA mit dll und monitor.exe befindet sich in der zip-Datei monitor+dll+expert.zip. Zum Starten klicken Sie START, wodurch ein gemeinsamer Speicher erstellt wird. Die DLL muss sich in dem Ordner System32 befinden. Danach starten Sie mehrere Terminals und hängen den EA an Charts von Währungen an, mit denen er Traden soll. Nach einer Anzahl von Trades sind Statistiken gesammelt. Die Daten werden in monitor/Journal gesammelt. Von Zeit zu Zeit sollte sie in eine Datei übertragen und in Form einer html-Seite gespeichert werden.

Der reale Betrieb der Anwendung wird der gleiche sein. Er ermöglicht Tradern den Betrieb bei verschiedenen Broker Unternehmen hinsichtlich ihrer technischen Eigenschaften zu vergleichen, und die Besten für automatisiertes Trading auszuwählen.

Fazit

Aktivieren von dll in MQL4 ermöglicht es verschiedene Anwendungsprogramme zu entwickeln, die nicht nur bei Handelsentscheidungen helfen, sondern auch Statistiken sammeln. Letzteres kann sehr nützlich sein beim Trading und bei der Auswahl eines Broker Unternehmens. Die erstellte Anwendung sollte Entwicklern bei dieser schwierigen Suche helfen. Um Broker zu analysieren, hängen Sie die statistic.dll an einen Expert Advisor, wie beschrieben in dem untersuchten Beispiel in diesem Artikel. Die notwendigen Dateien für die Arbeit befinden sich in monitor+dll+expert.zip. Für den Betrieb kopieren Sie die statistic.dll in den Ordner System32, starten Statistic.exe von jedem Ort öffnen Terminals mit Expert Advisors, welche die dll herunterladen, beginnen zu traden und ihre Daten an den gemeinsamen Speicher übergeben. Statistics.exe erstellt Hilfsdateien, weshalb es besser ist die Anwendung aus einem leeren Ordner zu starten. Wenn das Programm für Entwickler von Handelsrobotern interessant ist, kann es modifiziert und verbessert werden.

Es sollte beachtet werden, dass nicht alle Broker Unternehmen ähnliche Bedingungen für automatisiertes Trading anbieten:

1. Ein Broker kann automatisiertes Trading verbieten.
2. Ein Broker kann verbieten bei der Orderplatzierung SL oder TP anzugeben https://www.mql5.com/ru/forum/103341.
3. Unsymmetrische Niveaus für SL und TP.
4. Kann keine Option zum gemeinsamen Öffnen von Ordern haben.
5. Beschränkung bei der Anzahl gleichzeitig geöffneter Positionen in einem Konto. Wenn die Anzahl der Ordern (offene Positionen + Pending Orders) die Beschränkung überschreitet, gibt die Funktion OrderSend den Fehlercode ERR_TRADE_TOO_MANY_ORDERS zurück.
6. Andere Einschränkungen.

Deshalb ist es dringend empfohlen, die Bestimmungen des Broker Unternehmens zu lesen, mit dem Sie arbeiten möchten.

Das Projekt Statistics zeigt, wlche Komplexe erstellt werden können, wenn Sie die Möglichkeiten anderer Sprachen und Programmierumgebungen zu MQL4 hinzufügen. Das erstellte Programm wird hilfreich die Arbeit mit Expert Advisors bei verschiedenen Broker Unternehmen sein, weil es hilft deren technischen Eigenschaften auf eine komfortable weise zu analysieren. Wenn ein Broker Slippage hat, Trades nach Zeit ausgeführt werden und Requotes ziemlich häufig sind, wofür brauchen wir dann ein solches Unternehmen? Es gibt so viele Alternativen!