Projekte helfen beim Entwickeln profitabler Handelsroboter! Zumindest scheint es so

Das Erstellen eines Handelsroboters beginnt immer mit einer kleinen Datei, die dann mit der Implementierung weiterer Zusatzfunktionen und benutzerdefinierter Objekte immer größer wird. Die meisten MQL5-Programmierer verwenden include-Dateien (MQH), um dieses Problem zu lösen. Es gibt jedoch eine bessere Lösung: Beginnen Sie mit der Entwicklung einer beliebigen Handelsanwendung in einem Projekt. Es gibt so viele Gründe, dies zu tun.

Vorteile des Projekts

Ein Projekt ist eine separate Datei mit der Erweiterung MQPROJ, in der Programmeinstellungen, Kompilierungsparameter und Informationen über alle im Projekt verwendeten Dateien gespeichert werden. Unter einer eigenen Registerkarte des Navigators wird diese Form von Projektarbeit angeboten. Alle Dateien, wie z.B. Include-, Ressourcen-, Header- und andere Dateien sind in Kategorien in dieser Registerkarte angeordnet.

Wie Sie sehen, besteht das Projekt nicht nur aus einer Reihe von Dateien und Ordnern, die unter einem separaten Verzeichnis angeordnet sind. Es ermöglicht die Zerlegung eines komplexen Programms in Elemente, die in einer ausgewogenen Struktur angeordnet sind. Alle erforderlichen Informationen stehen zur Verfügung:

• Set-Dateien mit Eingabeparametern zum Testen und Optimieren
• Quellcode von OpenCL programs
• Bild- und Ton-Dateien
  
• Ressource und andere Daten

Alle Verbindungen zwischen Programmteilen sind im Projekt deutlich sichtbar, so dass Sie leicht zwischen allen verwendeten Dateien navigieren können. Darüber hinaus können mehrere Programmierer über die integrierten MQL5 Storage an einem Projekt zusammenarbeiten.

Erstellen eines Projekts

Ein neues Projekt wird unter Verwendung des MQL5-Assistenten als gewöhnliches MQL5-Programm erstellt. Klicken Sie auf "Neues Projekt" und gehen Sie die erforderlichen Schritte durch: Legen Sie den Programmnamen fest, fügen Sie Eingabeparameter hinzu und geben Sie die verwendete Ereignisbehandlung an. Nach Abschluss des MQL5-Assistenten wird eine MQPROJ-Datei geöffnet. Diese Datei ermöglicht die Verwaltung der Projekteigenschaften.

>

Hier können Sie die Version angeben, eine Programmbeschreibung festlegen, ein Symbol hinzufügen und zusätzliche Optionen verwalten:

1. Maximale Optimierung — Optimierung der ausführbaren EX5-Datei für maximale Leistung. Wenn die Option deaktiviert ist, kann die Kompilierung des Quellcodes schneller abgeschlossen werden, aber die resultierende EX5-Datei kann viel langsamer laufen.
   
2. Gleitkomma-Divisioren prüfen — Prüfung, ob die reellen Zahlen vom Typ double oder float bei Divisionsoperationen ungleich Null sind. Die Operationsgeschwindigkeit kann höher sein, wenn die Option deaktiviert ist. Sie sollten jedoch vollkommenes Vertrauen in Ihren Code haben.
3. Den Cache für die Testoptimierung verwenden — der Tester ist standardmäßig aktiviert, und somit speichert der Tester alle Ergebnisse abgeschlossener Durchläufe im Optimierungs-Cache. Die Daten können weiterhin in Neuberechnungen verwendet werden. Der Cache kann über die Eigenschaft tester_no_cache deaktiviert werden. Optional können Sie die entsprechende Option im Projekt deaktivieren.

Wenn die Projektdatei geschlossen wird, kann sie mit dem entsprechenden Befehl des Kontextmenüs Eigenschaften wieder geöffnet werden. Um den Inhalt der MQPROJ-Datei besser zu verstehen, können Sie sie mit dem Befehl Öffnen im Textformat öffnen. Auf diese Weise können Sie die interne Struktur von Projekten einsehen.

{
  "platform"    :"mt5",
  "program_type":"expert",
  "copyright"   :"Copyright 2019, MetaQuotes Software Corp.",
  "link"        :"https:\/\/www.mql5.com",
  "version"     :"1.00",
  "description" :"Die Strategie Rückkehr zum Mittelwert: Der Preis durchbricht eine Kanalgrenze nach außen und kehrt zum Durchschnitt zurück. Der Kanal wird durch Bollinger-Bänder repräsentiert. Der Expert Advisor steigt mit Limit-Orders in den Markt ein, die nur in der Trendrichtung geöffnet werden können.",
  "icon"        :"Mean Reversion.ico",
  "optimize"    :"1",
  "fpzerocheck" :"1",
  "tester_no_cache":"0",
  "tester_everytick_calculate":"0",

  "files":
  [
    {
      "path":".\\Mean Reversion.mq5",
      "compile":"true",
      "relative_to_project":"true"
    },
    {
      "path":"MQL5\\Include\\Trade\\Trade.mqh",
      "compile":"false",
      "relative_to_project":"false"
    },
....

Handelsregeln

Wenden wir die klassische Regel an: Positionseröffnung, wenn der Preis eines der Bollinger Bänder berührt. Dies ist eine der Handelsstrategien, bei der erwartet wird, dass der Preis zu seinem Mittelwert zurückkehrt.

Für Aufträge zum Markteintritt werden nur Limit-Orders verwendet. Die zusätzliche Regel wird wie folgt lauten: Handeln Sie nur in der Trendrichtung. Somit wird in einem Aufwärtstrend ein Buy-Limit an der unteren Kanalgrenze platziert. In einem Abwärtstrend wird hingegen ein Verkaufslimit an der oberen Grenze platziert.

Es gibt viele Möglichkeiten, die Trendrichtung zu bestimmen. Nehmen wir die einfachste: die relative Position von zwei gleitenden Durchschnitten. Wenn der schnelle EMA über dem langsamen EMA liegt, definiert das einen Aufwärtstrend. Der Abwärtstrend wird angenommen, wenn die Linien in anders herum angeordnet sind.

Diese einfache Regel hat einen Nachteil: Immer wird es entweder einen Aufwärtstrend oder einen Abwärtstrend geben. Daher kann in der Phase einer Seitwärtsbewegung eine Menge falscher Eröffnungen produzieren. Um dies zu vermeiden, fügen Sie eine weitere Regel hinzu, die das Platzieren von Pending Orders erlaubt, wenn der Abstand zwischen den Bollinger-Bändern gross genug ist. Der optimale Weg ist es, die Kanalbreite in relativen Werten statt in Punkten zu messen. Die Breite kann auf der Grundlage des ATR-Indikators bestimmt werden, der die Volatilität in Punkten misst.

• Eine Kanalbreite unter k*ATR weist auf eine Seitwärtsbewegung hin, so dass das Platzieren von Aufträgen nicht erlaubt ist.
• Wenn die Kanalbreite größer als k*ATR ist, platzieren Sie eine Pending-Limit-Order an der Kanalgrenze in Trendrichtung.
  

Hier ist k ein Koeffizient, der bestimmt werden muss.

Daher müssen wir bei der Projekterstellung 8 Eingabeparameter für die Bestimmung der Handelssignale festlegen. Der Expert Advisor wird mit einer festen Losgröße handeln, die im Parameter InpLot angegeben werden sollte. Ein weiterer nicht optimierbarer Parameter ist InpMagicNumber. Indem wir ihn verwenden, können wir den EA anweisen, nur seine eigenen Aufträge und Positionen zu bearbeiten.

//--- Kanal-Parameter
input int             InpBBPeriod   =20;           // Periodenlänge der Bollingerbänder
input double          InpBBDeviation=2.0;          // Spannbreite der Bollinger Bänder vom MA
//-- EMA Periodenlänge zur Trendberechnung 
input int             InpFastEMA    =12;           // Periodenlänge des schnellen EMA
input int             InpSlowEMA    =26;           // Periodenlänge des langsamen EMA
//-- Parameter des ATR
input int             InpATRPeriod  =14;           // Periodenlänge des ATR
input double          InpATRCoeff   =1.0;          // Koeffizient des ATR zur Bestimmung der Seitwärtsbewegung
//--- Kapital-Managements
input double          InpLot        =0.1;          // Handelsvolumen in lots
//--- Zeitrahmen-Parameter
input ENUM_TIMEFRAMES InpBBTF       =PERIOD_M15;   // Der Zeitrahmen für die Bollinger-Bänder
input ENUM_TIMEFRAMES InpMATF       =PERIOD_M15;   // Der Zeitrahmen zur Trendbestimmung
//--- Identifikator des Expert Advisors für die Handelstätigkeiten
input long            InpMagicNumber=245600;       // Magicnummer

Die Parameter InpBBTF und InpMATF wurden hinzugefügt, um die manuelle Auswahl von Zeitrahmen für die Bestimmung des Trends und der Kanalbreite zu vermeiden. In diesem Fall können durch die Optimierung optimale Werte für die Zeitrahmen gefunden werden. Der EA kann mit dem Zeitrahmen M1 laufen, während er die Bollinger Bänder von M15 und die gleitende Durchschnitte von M30 verwendet. Für den ATR werden keine Eingabeparameter verwendet, da es sonst zu viele Parameter für dieses Beispiel geben würde.

Schreibfunktionen

Nachdem wir ein Projekt erstellt haben, können wir mit der Entwicklung des Expert Advisors fortfahren. Der folgende Code zeigt die drei Hauptfunktionen, die die Regeln beschreiben.

Die Berechnung der Kanalbreite der Bollinger-Bänder ist einfach: Wir kopieren die Werte aus den Indikatorpuffern.

//+------------------------------------------------------------------+
//| Abrufen der Werte der Kanalgrenzen                               |
//+------------------------------------------------------------------+
bool ChannelBoundsCalculate(double &up, double &low)
  {
//--- Abrufen der Indikatorwerte der Bollinger Bänder 
   double bbup_buffer[];
   double bblow_buffer[];
   if(CopyBuffer(ExtBBHandle, 1, 1, 1, bbup_buffer)==-1)
     {
      PrintFormat("%s: Failed CopyBuffer(ExtBBHandle,0,1,2,bbup_buffer), code=%d", __FILE__, GetLastError());
      return(false);
     }

   if((CopyBuffer(ExtBBHandle, 2, 1, 1, bblow_buffer)==-1))
     {
      PrintFormat("%s: Failed CopyBuffer(ExtBBHandle,0,1,2,bblow_buffer), code=%d", __FILE__, GetLastError());
      return(false);
     }
   low=bblow_buffer[0];
   up =bbup_buffer[0];
//--- erfolgreich
   return(true);
  }

Die Bestimmungsmethode der Seitwärtsbewegung ist ebenfalls recht einfach. Zuerst werden die Werte der Kanalgrenzen ermittelt, dann die Breite berechnet und mit dem ATR-Wert multipliziert mit dem InpATRCoeffizienten verglichen.

//+------------------------------------------------------------------+
//|  Gibt true zurück, wenn der Kanal zu schmal ist (kein Trend)     |

//+------------------------------------------------------------------+
int IsRange()
  {
//--- Abfrage des ATR-Werts des letzten geschlossenen Balkens
   double atr_buffer[];
   if(CopyBuffer(ExtATRHandle, 0, 1, 1, atr_buffer)==-1)
     {
      PrintFormat("%s: Failed CopyBuffer(ExtATRHandle,0,1,2,atr_buffer), code=%d", __FILE__, GetLastError());
      return(NO_VALUE);
     }
   double atr=atr_buffer[0];
//--- Abfrage der Kanalgrenzen
   if(!ChannelBoundsCalculate(ExtUpChannel, ExtLowChannel))
      return(NO_VALUE);
   ExtChannelRange=ExtUpChannel-ExtLowChannel;
//--- Ist die Kanalgrenze kleiner als ATR*Koeffizient, ist es eine Seitwärtsbewegung
   if(ExtChannelRange<InpATRCoeff*atr)
      return(true);
//--- Eine Seitwärtsbewegung wurde nicht erkannt
   return(false);
  }

Wie aus dem Code ersichtlich ist, wird manchmal der Makrocode NO_VALUE zurückgegeben, was bedeutet, dass die Berechnung eines bestimmten Parameters fehlgeschlagen ist.

#define NO_VALUE      INT_MAX                      // ungültiger Wert bei der Berechnung von Signal oder Trend

Die Funktion zur Trendbestimmung ist am längsten.

//+------------------------------------------------------------------+
//| Gibt 1 für Aufwärts-, -1 für Abwärtstrend zurück (0 = kein Trend)|
//+------------------------------------------------------------------+
int TrendCalculate()
  {
//--- Zuerst prüfen wir auf eine Seitwärtsbewegung 
   int is_range=IsRange();
//--- Ergebnisprüfung
   if(is_range==NO_VALUE)
     {
      //--- Schlägt die Prüfung fehl, erfolgt ein vorzeitiges Ende mit der Antwort "NO_VALUE"
      return(NO_VALUE);
     }
//--- Keine Richtungsbestimmung in einer Seitwärtsbewegung
   if(is_range==true) // kleine Spannweite, Rückgabe vorn "Seitwärtsbewegung"
      return(0);
//--- Abfrage des ATR-Werts des letzten geschlossenen Balkens
   double atr_buffer[];
   if(CopyBuffer(ExtBBHandle, 0, 1, 1, atr_buffer)==-1)
     {
      PrintFormat("%s: Failed CopyBuffer(ExtATRHandle,0,1,2,atr_buffer), code=%d", __FILE__, GetLastError());
      return(NO_VALUE);
     }
//--- Abrufen des Werts der letzten geschlossenen Bar des schnellen EAs
   double fastma_buffer[];
   if(CopyBuffer(ExtFastMAHandle, 0, 1, 1, fastma_buffer)==-1)
     {
      PrintFormat("%s: Failed CopyBuffer(ExtFastMAHandle,0,1,2,fastma_buffer), code=%d", __FILE__, GetLastError());
      return(NO_VALUE);
     }
//--- Abrufen des Werts der letzten geschlossenen Bar des langsamen EAs
   double slowma_buffer[];
   if(CopyBuffer(ExtSlowMAHandle, 0, 1, 1, slowma_buffer)==-1)
     {
      PrintFormat("%s: Failed CopyBuffer(ExtSlowMAHandle,0,1,2,slowma_buffer), code=%d", __FILE__, GetLastError());
      return(NO_VALUE);
     }
//--- Standardmäßig wird kein Trend angenommen
   int trend=0;
//--- wenn der schnelle EMA über dem langsamen liegt
   if(fastma_buffer[0]>slowma_buffer[0])
      trend=1;   // Aufwärtstrend
//--- wenn der schnelle EMA unter dem langsamen liegt
   if(fastma_buffer[0]<slowma_buffer[0])
      trend=-1;  // Abwärtstrend
//--- Rückgabe der Trendrichtung
   return(trend);
  }

Die letzte Funktion des Handelsalgorithmus ist die Bestimmung eines neuen Balkens. Gemäß der Logik wird der Trend bestimmt, wenn ein neuer Balken erscheint.

//+------------------------------------------------------------------+
//| Prüfung der Entstehung einer neuen Bar im aktuellen Zeitrahmen,  |
//| berechnet auch den Trend und das Signal                          |
//+------------------------------------------------------------------+
bool IsNewBar(int &trend)
  {
//--- permanentes Speichern der aktuellen Eröffnungszeit der Bar zwischen Funktionsaufrufen
   static datetime timeopen=0;
//--- Abrufen der aktuellen Eröffnungszeit der Bar 
   datetime time=iTime(NULL, InpMATF, 0);
//--- Ist die Zeit unverändert, gibt es keine neue Bar, und wir kehren mit 'false' zurück
   if(time==timeopen)
      return(false);
//--- Gibt es eine neue Bar, sollte die Trendrichtung berechnet werden
   trend=TrendCalculate();
//--- Gibt es keine Trendrichtung, kehren wir zurück und versuchen es beim nächsten Aufruf
   if(trend==NO_VALUE)
      return(false);
//--- Alle Prüfungen erfolgreich durchgeführt: Die Bar ist neu und eine Trendrichtung wurde erkannt
   timeopen=time; // Speichern der aktuellen Zeit für spätere Abfragen.
//---
   return(true);
  }

Die obige Logik erlaubt es, die EA-Operation so zu organisieren, dass alle Handelsoperationen nur einmal während der gesamten Bar durchgeführt werden. Daher sind die Testergebnisse nicht vom Modus der Tickerzeugung abhängig.

Der gesamte Handelsalgorithmus befindet sich in OnTick():

• Zuerst werden das Auftauchen einer neuen Bar und die Trendrichtung bestimmt.
• Wenn es keinen Trend gibt oder eine Position offen ist, wird versucht, die Pending Orders zu löschen und die Funktion zu verlassen.
  
• Wenn es eine Trendrichtung und keine Pending-Order gibt, wird versucht, eine Limit-Order an der Kanalgrenze zu platzieren.
  
• Wenn bereits eine Pending-Order existiert und diese nicht auf dem neuen Balken geändert wurde, wird versucht, sie an die aktuelle Kanalgrenze zu verschieben.
  

//+------------------------------------------------------------------+
//| Experten Funktion OnTick                                         |
//+------------------------------------------------------------------+
void OnTick()
  {
   static bool order_sent    =false;    // Platzieren einer Limit-Order während der aktuellen Bar ist fehlgeschlagen
   static bool order_deleted =false;    // Löschen einer Limit-Order während der aktuellen Bar ist fehlgeschlagen
   static bool order_modified=false;    // Ändern einer Limit-Order während der aktuellen Bar ist fehlgeschlagen
//--- Wenn die Eingabeparameter ungültig sind, wird der Test bei der ersten Bar gestoppt
   if(!ExtInputsValidated)
      TesterStop();
//--- Prüfen auf neue Bar und der Trendrichtung
   if(IsNewBar(ExtTrend))
     {
      //--- Rücksetzen der statischen Variablenwerte auf ihre Originalwerte
      order_sent    =false;
      order_deleted =false;
      order_modified=false;
     }
//--- Erstellen von Hilfsvariablen für einen einzigen Prüfungsaufruf während der aktuellen Bar
   bool order_exist   =OrderExist();
   bool trend_detected=TrendDetected(ExtTrend);
//--- Gibt es keinen Trend oder eine offene Position, werden die Pending-Orders gelöscht
   if(!trend_detected || PositionExist())
      if(!order_deleted)
        {
         order_deleted=DeleteLimitOrders();
         //--- Wenn die Orders erfolgreich gelöscht wurden, gibt es während dieser Bar nichts mehr zu tun
         if(order_deleted)
           {
            //--- Vermeidung des Platzierens oder Änderns von Orders
            order_sent    =true;
            order_modified=true;
            return;
           }
        }

//--- Es gibt einen Trend
   if(trend_detected)
     {
      //--- Platzieren einer Order auf der Kanalgrenze, wenn keine Order gefunden wurde
      if(!order_exist && !order_sent)
        {
         order_sent=SendLimitOrder(ExtTrend);
         if(order_sent)
            order_modified=true;
        }
      //--- Versuch, die Order auf die Kanalgrenze zu schieben, wenn sie noch nicht dort ist
      if(order_exist && !order_modified)
         order_modified=ModifyLimitOrder(ExtTrend);
     }
//---
  }

Die anderen Handelsfunktionen des Expert Advisors sind Standard. Die Quellcodes sind im Standardpaket des MetaTrader 5 Terminals verfügbar. Sie sind unter MQL5\Experts\Beispiele zu finden.

Optimieren von Parametern und Hinzufügen der Set-Dateien

Nun, da der EA fertig ist, wollen wir im Strategietester die optimalen Parameter finden. Wussten Sie, dass der Tester Optionen zum einfachen Kopieren von Werten aus den Registerkarten "Einstellungen" und "Eingaben" in die Zwischenablage mit der Kombination Ctr+C bietet? So können Sie Ihre Einstellungen einer anderen Person, z.B. einem Kunden über den Freelance-Chat, zur Verfügung stellen, ohne sie in einer Set-Datei speichern zu müssen. Der Kunde kann die Daten in die Zwischenablage kopieren und mit Ctr+V in die Registerkarte Einstellungen des Testers einfügen.

Das Speichern in eine Set-Datei ist ebenfalls eine bequeme Lösung. Viele Verkäufer auf dem Markt stellen solche Dateien zur Verfügung, so dass die Produktkäufer sofort die entsprechenden Parametersätze laden und die EA auf einem gewünschten Instrument testen oder optimieren können. Für jedes der gehandelten Instrumente müssen separate Set-Dateien erstellt werden. Die Anzahl solcher Dateien auf dem Computer kann recht groß sein, wenn viele Expert Advisors in der Plattform existieren. Bei Projekten können Ihre Kunden sofort auf die erforderlichen Dateien zugreifen, ohne dass sie bei jeder Änderung des Symbols auf der Festplatte danach suchen müssen.

Hier ist ein Beispiel dafür, wie Projekte helfen können, geeignete Parametersätze direkt in der EX5-Datei des EA hinzuzufügen. Wählen Sie das Symbol aus, für das die Optimierung durchgeführt werden soll. Zum Beispiel EURUSD. Stellen Sie Start, Step und Stop für die Parameter ein, die Sie optimieren möchten, und starten Sie den Optimierungsprozess. Sobald er beendet ist, machen Sie einen Doppelklick auf den besten Durchgang in der Registerkarte Optimierungen, und die Werte der Eingabeparameter aus diesem Durchgang werden in die Registerkarte Parameter eingefügt, und es wird ein einzelner Test durchgeführt. Die gefundenen Parameter können in eine Set-Datei gespeichert werden. Es besteht jedoch keine Notwendigkeit, sie separat bereitzustellen. Speichern Sie den Parametersatz unter einem eindeutigen Namen, wie z.B. EURUSD.set. Das bedeutet, dass die Parameter für dieses Paar angewendet werden sollten und nicht GBPJPY.

Wiederholen Sie diesen Vorgang für jedes Symbol, mit dem Ihr EA handeln kann. Auf diese Weise haben Sie eine Reihe von fertigen Set-Dateien, sagen wir 9. Fügen Sie diese Dateien zu Ihrem Projekt hinzu. Erstellen Sie den entsprechenden Ordner "Settings and files\Set", um sie von den Quelldateien zu trennen. Mit Projekte können Sie Ordnung und die richtige Dateistruktur aufrechterhalten.

Kompilieren Sie nun das Projekt und öffnen Sie den Strategietester mit dem EA MeanReversion. Ein neuer Punkt "Laden" wird im Kontextmenü auf der Registerkarte Eingaben erscheinen. Von diesem Menü aus kann auf alle verfügbaren Set-Dateien zugegriffen werden.

Somit ist die kompilierte EX5-Datei des Expert Advisors ein vollständig abgeschlossenes Produkt mit fertigen Parametersätzen. Die Strategie kann sofort getestet werden, ohne dass Grenzen und Schritte für jedes der gewünschten Symbole festgelegt werden müssen. Nutzer und Käufer Ihrer Handelsroboter werden diesen Komfort sicherlich zu schätzen wissen.

Strategie läuft auf realen Daten

Im September 2019 wurde MeanReversion auf einem Demokonto eingeführt. Ziel war es, Programmier- und Handelsfehler in Echtzeit herauszufinden. Der EA wurde in einem Portfoliomodus auf mehreren Symbolen eingeführt (dies war die ursprüngliche Idee während der Optimierung). Für den EA wurde ein integrierter VPS gemietet, auf dessen Grundlage ein privates Signal Many MeanReversion Optimized zu Überwachungszwecken erstellt wurde. 

Im ersten Monat nach der Einführung zeigte die EA positive Ergebnisse. Es folgten 5 aufeinander folgende Verlustmonate. Das virtuelle Hosting wurde mit der automatischen Abo-Verlängerung gemietet, und so lief die EA in einem völlig autonomen Modus. Er handelte weiter in Richtung eines vollständigen Einlagenverlusts. Dann, im März, änderte sich etwas auf dem Devisenmarkt, und der EA erzielte plötzlich einen Rekordgewinn. Während der nächsten 2 Monate waren die Ergebnisse widersprüchlich. Das gleiche Wachstum lässt sich wahrscheinlich nie mehr wiederholen.

Die Analyse der Geschäfte und Ergebnisse nach Symbolen zeigt, dass drei Yen-Paare und AUDUSD einen Verlust erlitten haben. Der Expert Advisor zeigte keine beeindruckenden Ergebnisse. Nichtsdestotrotz läuft er selbst bei einer so einfachen Handelslogik seit 9 Monaten in einem Portfoliomodus, bei dem Verluste bei einigen Symbolen durch Gewinne bei anderen Paaren gedeckt werden.

Die Parameter des Expert Advisors wurden seit ihrer Einführung nie geändert, in dieser Zeit wurde auch keine Weiterentwicklung durchgeführt. Der EA wurde vor 9 Monaten zusammengestellt und auf acht Charts auf einem eingebauten VPS gestartet. Er läuft nach wie vor ohne jeglichen menschlichen Eingriff. Wir können uns nicht einmal daran erinnern, warum nur acht von neun Set-Dateien gestartet wurden. Außerdem können wir uns nicht an die verwendeten Parameter erinnern. Nichtsdestotrotz läuft das Projekt MeanReversion, das für Ausbildungszwecke geschaffen wurde, noch immer und weist zum 10. Juni 2020 einen Gewinn aus.

Wechseln Sie zu Projekte und genießen Sie die Vorteile

Projekte ermöglichen es Entwicklern, Programme jeder Komplexitätsstufe zu erstellen und während der Entwicklung zusammenzuarbeiten. Wenn Sie mit Gleichgesinnten zusammenarbeiten, können Sie Anwendungen schneller entwickeln, nützliche Ideen und Fähigkeiten austauschen sowie die Qualität des Codes verbessern.

Die in diesem Expert Advisor verwendeten Handelsregeln sind sehr einfach, aber er kann als Vorlage für die Erstellung vieler anderer Handelsroboter verwendet werden. Ersetzen Sie Funktionen, die die Trendrichtung, die Seitwärtsbewegung oder die Einstiegsebenen und -methoden bestimmen (z.B. können Sie Marktaufträge anstelle von Limitaufträgen verwenden). Vielleicht können bessere Ergebnisse erzielt werden, wenn nur während flacher Perioden gehandelt wird. Außerdem fehlen im EA die Einstellungen für ein Trailing Stop, Stop-Loss und Take-Profit. Es gibt noch viel mehr, was Sie tun können, um den EA zu verbessern.

Mit MeanReversion aus dem MetaTrader 5 Standardpaket können Sie die Vorteile von Projekten untersuchen und ausprobieren. Erstellen Sie Ihr eigenes Projekt oder kopieren Sie dieses in einen neuen Ordner und beginnen Sie mit eigenen Experimenten. Beginnen Sie mit Projekten und evaluieren Sie die Vorteile für sich selbst!