Automatisieren von Handelsstrategien mit Parabolic SAR Trend Strategy in MQL5: Erstellung eines effektiven Expertenberaters

 Einführung

Algorithmische Handelsstrategien haben den Finanzhandel stark revolutioniert, da sie es den Händlern ermöglichen, schnell fundierte Entscheidungen zu treffen. Dies hat dazu beigetragen, menschliches Versagen und emotionale Voreingenommenheit auszuschließen, da die automatisierten Systeme in dem schnelllebigen Marktumfeld vorgegebenen Parametern folgen. Daher ist beim automatisierten Handel Konsistenz gegeben, da das System jedes Mal dieselbe Logik zur Ausführung von Geschäften verwendet.

Es ist eine gängige Praxis, automatisierte Techniken mit MetaTrader 5 zu entwickeln und zu implementieren. Dieser Artikel befasst sich eingehend mit der Erstellung eines Expert Advisor (EA), der den Parabolic SAR-Indikator zur automatischen Ausführung von Trades verwendet.

Ein Überblick über die parabolische SAR-Strategie

Parabolischer SAR-Indikator. Dieser Indikator wurde 1978 von Welles Wilder erfunden. Der Indikator hebt potenzielle Umkehrpunkte im Markttrend durch eine Reihe von Punkten auf einem Chart hervor, das die Kursbewegung nach oben und unten verfolgt. Wenn die Punkte unter dem Kurs liegen, befindet sich der Markt in einem Aufwärtstrend; wenn sie darüber liegen, ist der Markt in einem Abwärtstrend. Dies macht ihn besonders nützlich, um potenzielle Umkehrpunkte zu identifizieren, an denen ein Trend zu Ende gehen könnte. 

SAR-Schritt: Dies hilft bei der Bestimmung, wie eng die SAR-Punkte den Kurs verfolgen. Die untere Stufe hinkt dem Preis um Punkte hinterher, was die Sensibilität verringert. Eine höhere Stufe bringt die Punkte näher an den Preis heran und erhöht die Sensibilität.

SAR-Punkte: Dies wirkt als Beschleunigungsfaktor als Obergrenze. In einem sich entwickelnden Markt erhöht der Parabolic SAR die Schritte, um die Preise einzuholen. Händler sind daher in der Lage, Einstiegs- und Ausstiegspunkte für potenzielle Trendumkehrungen zu identifizieren.

Diese Strategie kann mit anderen Indikatoren integriert werden, um sie umfassender zu machen, oder als eigenständige Strategie in Trendmärkten wie Devisen und Rohstoffen eingesetzt werden.

Implementation in MQL5

In der Kopfzeile werden grundlegende Metadaten wie Copyright und Versionsnummer angegeben. Die Bibliothek Trade.mqh dient der Abwicklung von Handelsoperationen, d. h. dem Öffnen und Schließen von Positionen.

#property copyright "Copyright 2024, MetaQuotes Ltd." "Duke"
#property link      "https://www.mql5.com"
#property version   "1.00"
#include <Trade\Trade.mqh>

Lassen Sie uns nun die Eingabeparameter definieren, mit denen wir den EA anpassen können.

LotSize: Es hilft dem EA, das Volumen der Handelsgeschäfte zu bestimmen. Das bedeutet, dass eine kleine LotSize die Risiken und Gewinne aufgrund des geringeren Handelsvolumens reduziert. Wenn die Losgröße groß ist, bedeutet dies auch, dass das Risiko und der Gewinn erhöht werden.

SAR_Step und SAR_Maximum: Sie steuern die Empfindlichkeit des Parabolic SAR bei der Erkennung von Kursbewegungen und der Berechnung des Parabolic SAR-Indikators.

Slippage: Dies hilft dem EA bei der Festlegung der maximal zulässigen Slippage bei der Auftragserteilung.

//--- Input parameters
input double LotSize = 0.2  ;                    // Lot size for trading
input double SAR_Step = 0.02;                    // Parabolic SAR step
input double SAR_Maximum = 0.2;                  // Parabolic SAR maximum
input int Slippage = 3;                          // Slippage for orders

Wir können eine Instanz der Klasse CTrade erstellen, um Handelsvorgänge zu verwalten.

//--- Trade object
CTrade trade;

Unser nächster Schritt ist die OnInit-Funktion, die ausgeführt wird, wenn der EA geladen wird. In diesem einfachen EA wird lediglich eine Bestätigungsmeldung für die erfolgreiche Initialisierung des Expert Advisor (EA)-Protokolls gedruckt. Daher werden wir überprüfen, ob der EA problemlos geladen und initialisiert wurde. Diese Funktion ist auch bei der Fehlersuche von Nutzen, um sicherzustellen, dass der EA bereit ist, Daten zu verarbeiten. Die Funktion kann auch INIT_FAILED zurückgeben, wenn die Initialisierung aus irgendeinem Grund fehlgeschlagen ist und der EA dadurch nicht mehr funktioniert.

int OnInit()
  {
//--- Initialization code here
   Print("Parabolic SAR EA Initialized");
   return(INIT_SUCCEEDED);
  }

Wir wechseln zur Funktion OnDeint. Wenn der EA neu kompiliert wird, wird er aus dem Chart entfernt. Mit dieser Aktion wird die Funktion OnDeint aktiviert, um Aufräumarbeiten durchzuführen und sicherzustellen, dass die Ressourcen ordnungsgemäß freigegeben werden. Anhand dieses Protokolls können wir feststellen, ob der EA explizit entfernt oder neu kompiliert wurde oder ob er durch das Herunterfahren des Terminals entstanden ist; dies kann in der Entwicklungs- und Testphase aufschlussreiche Informationen liefern. Diese Funktion kann auf alle notwendigen Bereinigungsverfahren ausgedehnt werden. So müssen beispielsweise offene Ressourcen geschlossen, Datei-Handles freigeben oder der aktuellen Zustand gespeichert werden.

Dies trägt zur Verbesserung der Zuverlässigkeit und Stabilität bei, da es sicherstellt, dass Leistungsprobleme aus früheren Durchläufen die Fähigkeit des EA, neu zu laden oder neu zu starten, nicht beeinträchtigen.

void OnDeinit(const int reason)
  {
//--- Cleanup code here
   Print("Parabolic SAR EA Deinitialized");
  }

Nach der Funktion OnDeint sehen wir uns die Funktion OnTick an. Diese Funktion ist das Herzstück des EA und wird bei jedem Markttick ausgeführt. Es berechnet den Parabolic SAR-Wert und vergleicht ihn mit dem letzten Schlusskurs. Auf der Grundlage dieses Vergleichs entscheidet der EA, ob eine Kauf- oder Verkaufsorder eröffnet werden soll.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Get the Parabolic SAR value
   double sar = iSAR(_Symbol, _Period, SAR_Step, SAR_Maximum);        // Calculate the Parabolic SAR value
   double lastPrice = iClose(_Symbol, _Period, 1);                    // Get the close price of the previous candle

//--- Check if there is an existing position
   if(!IsPositionOpen(_Symbol))
     {
      //--- Determine trade direction based on SAR
      if(lastPrice > sar)
        {
         OpenBuyOrder();                                              // If the last price is above the SAR, open a buy order
        }
      else
         if(lastPrice < sar)
           {
            OpenSellOrder();                                          // If the last price is below the SAR, open a sell order
           }
     }
  }   

Zum besseren Verständnis können wir nun die Funktion OnTick aufschlüsseln.

• Die parabolische SAR-Berechnung: In der ersten Zeile des Codes wird der Parabolic-SAR-Wert berechnet:

 double sar = iSAR(_Symbol, _Period, SAR_Step, SAR_Maximum);        // Calculate the Parabolic SAR value

- iSAR(): Dies ist eine eingebaute Funktion in den MetaTrader-Plattformen, die den Wert des Parabolic SAR-Indikators für einen bestimmten Vermögenswert über einen bestimmten Zeitraum berechnet.

- _Symbol: Bezieht sich auf das Finanzinstrument oder den Handelswert wie EUR/USD, Gold oder ein anderes Handelsobjekt, das Sie gerade analysieren.

- _Period: Hier wird der Zeitrahmen des Charts angegeben (z. B. 1 Minute, 1 Stunde, 1 Tag usw.).  Dies hilft der Funktion bei der Bestimmung der Kerzen, die für die Berechnung der SAR verwendet werden sollen.

- _SAR_Step und SAR  Maximum: Diese Parameter sind spezifisch für den Parabolic SAR-Indikator und steuern seine Empfindlichkeit. Der SAR_Step ist der inkrementelle Schrittwert, der den Indikator bei fortschreitendem Trend beschleunigt, während SAR Maximum die Beschleunigung begrenzt, um zu verhindern, dass der Indikator zu schnell auf Preisänderungen reagiert.

• Abrufen des Schlusskurses der vorherigen Kerze: In der nächsten Zeile wird der Schlusskurs der letzten abgeschlossenen Kerze abgefragt:

double lastPrice = iClose(_Symbol, _Period, 1);                   // Get the close price of the previous candle

- iClose(): Diese Funktion gibt den Schlusskurs einer bestimmten Kerze im Chart zurück.

- _Symbol und _Period: Genau wie die Funktion iSAR() bezieht sich diese Funktion auf das spezifische Finanzinstrument und den zu analysierenden Zeitrahmen.

- 1: Dieser Parameter gibt an, welchen Schlusskurs der Kerze wir wollen. In diesem Fall steht die 1 für die letzte abgeschlossene Kerze (die vorherige), da die aktuelle Kerze noch in der Entstehung ist.

Dieser Wert, der in LastPrice gespeichert ist, stellt das endgültige Preisniveau dar, zu dem der Vermögenswert bei Abschluss der letzten Kerze gehandelt wurde.

Wir verwenden den Parabolic SAR-Code, um Entscheidungen über das Setzen von Stop-Losses und die Bestimmung von Handelsausstiegen oder Umkehrungen zu automatisieren. Fällt beispielsweise der Schlusskurs einer Long-Position unter den SAR-Wert, kann dies auf eine Trendumkehr hindeuten und den Händler veranlassen, die Position zu schließen oder eine Short-Position zu erwägen. Der EA nutzt diesen Vergleich, um festzustellen, ob der Markt seinen Trend fortsetzt oder sich umkehrt. Dies hilft, Emotionen auszuschalten und sich beim Handel auf klare Signale zu verlassen.

Bei der Entwicklung eines Handelsalgorithmus ist es üblich, zu prüfen, ob eine Position für einen bestimmten Vermögenswert (Symbol) bereits geöffnet ist.

//--- Check if there is an existing position
   if(!IsPositionOpen(_Symbol))

IsPositinOpen(_Symbol): Diese Funktion prüft, ob es derzeit eine offene Position für das Symbol _Symbol gibt. Das Symbol steht in der Regel für den Ticker- oder Asset-Code. 

!IsPositionOpen(_symbol): Das bedeutet, dass die Bedingung nur dann erfüllt wird, wenn für das angegebene Symbol keine offene Position besteht.

Die if-Anweisung: Wenn es für das angegebene Symbol keine offene Position gibt, wird der Code innerhalb des if-Blocks ausgeführt. Dies kann die Eröffnung einer neuen Position, die Ausführung eines Geschäfts oder die Auslösung einer anderen Handelslogik beinhalten.

Mit dieser Funktion wird also sichergestellt, dass es nicht zu einem Overtrading kommt, das durch die Eröffnung mehrerer Positionen für dasselbe Symbol verursacht wird. Dies wird dem System helfen, eine bessere Kontrolle über die Handelsaktivitäten zu behalten.

Der Parabolic SAR verfolgt Trends und zeigt Einstiegs- und Ausstiegspunkte mit einem nachlaufenden Stop-Loss an, der sich den Kursbewegungen anpasst. Ein Kreuzen signalisiert eine mögliche Trendumkehr.

 //--- Determine trade direction based on SAR
      if(lastPrice > sar)
        {
         OpenBuyOrder();                                              // If the last price is above the SAR, open a buy order
        }
      else
         if(lastPrice < sar)
           {
            OpenSellOrder();                                          // If the last price is below the SAR, open a sell order
           }
     }
  }

LastPrice: Dies ist der aktuelle Marktpreis des gehandelten Vermögenswerts.

sar: Dies ist der Wert des Parabolic SAR zum aktuellen Zeitpunkt.

Durch den Vergleich der beiden Werte bestimmt der Algorithmus, ob es sich um einen Aufwärts- oder Abwärtstrend handelt und handelt entsprechend.

Die Kauf- und Verkaufslogik

Kaufaufträge: Kaufaufträge werden ausgelöst, wenn der letzte Kurs den sar-Wert übersteigt, was auf einen Aufwärtstrend hindeutet. Der Algorithmus löst dann die Funktion OpenBuyOrder() aus, um den Handel auszuführen, wobei er von der Annahme ausgeht, dass der Markt weiter steigen wird, wenn der Preis über dem SAR liegt.

Verkaufsaufträge: Umgekehrt wird ein letzter Preis, der unter dem SAR liegt, als Signal dafür interpretiert, dass sich der Markt in einem Abwärtstrend befindet. Der Algorithmus reagiert, indem er die Funktion OpenSellOrder() aufruft und einen Verkaufshandel einleitet. In diesem Fall geht die Strategie davon aus, dass der Markt, nachdem der Kurs unter den SAR gefallen ist, weiter fallen könnte.

Der Code priorisiert zunächst die Auswertung eines Kaufauftrags. Wenn die Bedingung für einen Kaufauftrag (lastprice > sar) erfüllt ist, führt das System sofort ein Kauf aus. Wenn diese Bedingung nicht erfüllt ist, prüft der Code, ob eine Verkaufsbedingung vorliegt (lastPrice<sar). Wenn die Bedingung erfüllt ist, wird ein Verkauf ausgeführt.

Unser nächster Schritt ist die Nutzenfunktion

Hier beginnen wir mit der Suche nach der Funktion OpenPositions. Die Funktion IsPositionOpen prüft, ob für das aktuelle Handelssymbol bereits eine offene Position besteht. Dadurch wird verhindert, dass der EA mehrere Positionen in dieselbe Richtung gleichzeitig eröffnet.

//+------------------------------------------------------------------+
//|Check if there is an open position for the given symbol           |
//+------------------------------------------------------------------+
bool IsPositionOpen(string symbol)
  {
   uint total=PositionsTotal();                                     //Get the total number of open positions
   for(uint i=0; i<total; i++)
     {
      string POSITION_SYMBOL=PositionGetSymbol(i);                 //Get the symbol of the position
      if(POSITION_SYMBOL == _Symbol)                               //Check if the symbol matches the current symbol
        { 
         return true;
        }
     }
   return false;
  }

 Wir gehen nun im Detail darauf ein, indem wir den Funktionscode wie folgt aufschlüsseln;

• Eingabe Parameter: Die Funktion erhält das Symbol als String-Argument, das ein gewünschtes Symbol darstellt, z. B. ein Währungspaar oder einen Börsenticker.
• Ermitteln der Anzahl aller Positionen: Die Funktion ermittelt die Gesamtzahl der derzeit offenen Positionen mit PositionsTotal(). Diese Funktion gibt die Anzahl der offenen Positionen im Terminal zum Zeitpunkt der Ausführung zurück.
• Iterieren durch alle Positionen: Mit Hilfe einer for-Schleife durchläuft der Code alle offenen Positionen. Die Variable total enthält die Anzahl der offenen Positionen, die Schleife läuft von 0 bis total - 1.
• Symbole vergleichen: Das ermittelte Symbol, POSITION_SYMBOL, wird dann mit dem aktuellen Symbol unter der Bedingung if (POSITION_SYMBOL==_SYMBOL) verglichen. Die Variable _Symbol ist ein vordefinierter Bezeichner, der das Symbol des Charts zugewiesen ist, von dem aus die Funktion aufgerufen wird. Wenn die Symbole übereinstimmen, bedeutet dies, dass bereits eine offene Position für das angegebene Symbol besteht.
• Rückgabewert: Wenn die Funktion eine Übereinstimmung findet (d.h. eine Position für das angegebene Symbol ist bereits offen), gibt sie true zurück. Wenn keine passende Position gefunden wird, nachdem die Schleife alle offenen Positionen überprüft hat, gibt die Funktion false zurück und zeigt damit an, dass es keine offenen Positionen für das angegebene Symbol gibt.

Diese Funktion ist besonders nützlich, um zu verhindern, dass der Algorithmus eine neue Position auf derselben öffnet, wenn bereits eine aktiv ist. Wenn Sie beispielsweise mit „EURUSD“ handeln und die Funktion „true“ zurückgibt, könnte die Strategie die Eröffnung einer neuen Position vermeiden und sich stattdessen auf die Verwaltung der bestehenden Position konzentrieren.  

Unsere nächste Hilfsfunktion ist OpenBuyOrder(); diese Funktion ist für die Ausführung eines Kaufgeschäfts verantwortlich. Es wird versucht, einen Kaufauftrag mit einer bestimmten Losgröße zu eröffnen, wobei auch eine Fehlerbehandlung vorgesehen ist, um sicherzustellen, dass der Vorgang korrekt abgeschlossen wird, oder um den Händler zu benachrichtigen, wenn etwas schief läuft.

//+------------------------------------------------------------------+
//| Open a Buy order                                                 |
//+------------------------------------------------------------------+
void OpenBuyOrder()
  {
   if(trade.Buy(LotSize, NULL, 0, 0, 0, "Buy Order"))
     {
      Print("Buy order placed successfully");
     }
   else
     {
      Print("Error placing buy order: ", GetLastError());
     }
  }

Die Funktion wird als void OpenBuyOrder () deklariert, d. h. sie gibt keinen Wert zurück, sondern führt eine bestimmte Aufgabe aus, in diesem Fall die Platzierung einer Kauforder.

Die Funktion verwendet die Methode trade.Buy(), um einen Kaufauftrag auszuführen. Die Methode erfordert die folgenden Parameter:

• LotSize: Hier wird das Volumen des Auftrags angegeben, in unserem Fall ist es 0,2.
• Null: Verweist auf das aktuelle Symbol des Charts, von dem aus die Funktion aufgerufen wird. In diesem Fall wird NULL auf das Symbol des aktuellen Charts gesetzt.
• 0: Er legt den Preis fest, zu dem der Auftrag erteilt wird. Die Verwendung von 0 bedeutet, dass der Auftrag zum aktuellen Marktpreis ausgeführt wird.
• 0: Dieser Parameter stellt die Stop-Loss-Ebene dar. 0 bedeutet, dass bei der Eröffnung des Auftrags kein Stop-Loss festgelegt wird.
• 0: Dieser Parameter ist das Take-Profit-Niveau. Wenn Sie den Wert auf Null setzen, wird zunächst kein Take Profit festgelegt.
• "Buy Order": Dies ist der mit dem Auftrag verbundene Kommentar, der zur Identifizierung dient.

Wenn die Order erfolgreich platziert wurde (if(trade.Buy(....) ergibt true), ruft die Funktion die Funktion Print() auf, um die Meldung zu protokollieren: „Buy order placed successfully“. Dadurch erhält der Händler die Rückmeldung, dass der Auftrag erfolgreich ausgeführt wurde.

Wenn der Auftrag fehlgeschlagen ist (else), gibt die Funktion eine Fehlermeldung aus: „Error placing buy order“, gefolgt von dem spezifischen Fehlercode, der von GetLastError() zurückgegeben wird. Die Funktion GetLastError () ruft den letzten im System aufgetretenen Fehler ab und liefert dem Händler oder Entwickler wertvolle Informationen für die Fehlerbehebung.

Unsere letzte Nutzenfunktion ist die Eröffnung eines Verkaufsauftrags: Diese Funktion wurde entwickelt, um den Prozess der Eröffnung eines Verkaufsauftrags in einem algorithmischen Handelssystem zu automatisieren. Diese Funktion spiegelt die Logik der Funktion OpenBuyOrder() wider, ist aber auf kurze Handelsgeschäfte oder Verkaufsaufträge am Markt zugeschnitten.

//+------------------------------------------------------------------+
//| Open a Sell order                                                |
//+------------------------------------------------------------------+
void OpenSellOrder()
  {
   if(trade.Sell(LotSize, NULL, 0, 0, 0, "Sell Order"))
     {
      Print("Sell order placed successfully");
     }
   else
     {
      Print("Error placing sell order: ", GetLastError());
     }
  }

Die Funktion void OpenSellOrder() gibt keinen Wert zurück, sondern konzentriert sich auf die Ausführung einer bestimmten Aufgabe: die Erteilung eines Verkaufsauftrags.

Die Methode trade.Sell() wird verwendet, um einen Verkaufsauftrag auszulösen. Die dieser Methode übergebenen Parameter sind wie folgt:

• Grundstücksgröße: Damit wird die Anzahl der Losgrößen für den Verkaufsauftrag festgelegt, in unserem Fall ist es 0,2.
• NULL: Stellt das Symbol des aktuellen Charts dar, von dem aus die Funktion aufgerufen wird. Durch die Übergabe von null wird die Funktion standardmäßig mit dem Symbol im aktuellen Chart handeln.
• 0: Legt den Preis für den Auftrag fest. Wenn Sie 0 verwenden, wird der Auftrag zum aktuellen Marktpreis ausgeführt. 
• 0: Stellt das Stop-Loss-Niveau dar. Ein Wert von 0 bedeutet, dass bei der Eröffnung des Auftrags kein Stop-Loss-Level festgelegt wird. 
• 0: Legt das Take-Profit-Niveau fest. Ein Wert von Null bedeutet, dass zunächst keine Take-Profit festgelegt wird.
• Verkaufsauftrag: Dies ist ein an den Auftrag angehängter Kommentar, der die Identifizierung und Verfolgung des Auftrags erleichtert.

Wenn der Verkaufsauftrag erfolgreich platziert wurde, wird mit der Funktion Print() eine Erfolgsmeldung protokolliert. Im Protokoll des Terminals erscheint die Meldung „Sell order placed successfully“, um zu bestätigen, dass der Handel ausgeführt wurde.

Falls der Verkaufsauftrag aus irgendeinem Grund fehlschlägt, gibt die Funktion eine Fehlermeldung aus: „Error placing sell order:“, gefolgt von dem spezifischen Fehlercode, der von GetLastError() zurückgegeben wird. So lässt sich feststellen, warum der Verkaufsauftrag nicht erteilt wurde.

Nachstehend finden Sie den vollständigen Code unseres Artikels:

//+------------------------------------------------------------------+
//|                                              ParabolicSAR_EA.mq5 |
//|                            Copyright 2024, MetaQuotes Ltd."Duke" |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd." "Duke"
#property link      "https://www.mql5.com"
#property version   "1.00"
#include <Trade\Trade.mqh>

//--- Input parameters
input double LotSize = 0.2  ;                    // Lot size for trading
input double SAR_Step = 0.02;                    // Parabolic SAR step
input double SAR_Maximum = 0.2;                 // Parabolic SAR maximum
input int Slippage = 3;                        // Slippage for orders

//--- Trade object
CTrade trade;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Initialization code here
   Print("Parabolic SAR EA Initialized");
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- Cleanup code here
   Print("Parabolic SAR EA Deinitialized");
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- Get the Parabolic SAR value
   double sar = iSAR(_Symbol, _Period, SAR_Step, SAR_Maximum);        // Calculate the Parabolic SAR value
   double lastPrice = iClose(_Symbol, _Period, 1);                    // Get the close price of the previous candle

//--- Check if there is an existing position
   if(!IsPositionOpen(_Symbol))                                       
     {
      //--- Determine trade direction based on SAR
      if(lastPrice > sar)
        {
         OpenBuyOrder();                                              // If the last price is above the SAR, open a buy order
        }
      else
         if(lastPrice < sar)
           {
            OpenSellOrder();                                          // If the last price is below the SAR, open a sell order
           }
     }
  }
//+------------------------------------------------------------------+
//|Check if there is an open position for the given symbol           |
//+------------------------------------------------------------------+
bool IsPositionOpen(string symbol)
  {
   uint total=PositionsTotal();                                     //Get the total number of open positions
   for(uint i=0; i<total; i++)
     {
      string POSITION_SYMBOL=PositionGetSymbol(i);                 //Get the symbol of the position
      if(POSITION_SYMBOL == _Symbol)                               //Check if the symbol matches the current symbol
        {
         return true;
        }
     }
   return false;
  }
//+------------------------------------------------------------------+
//| Open a Buy order                                                 |
//+------------------------------------------------------------------+
void OpenBuyOrder()
  {
   if(trade.Buy(LotSize, NULL, 0, 0, 0, "Buy Order"))
     {
      Print("Buy order placed successfully");
     }
   else
     {
      Print("Error placing buy order: ", GetLastError());
     }
  }

//+------------------------------------------------------------------+
//| Open a Sell order                                                |
//+------------------------------------------------------------------+
void OpenSellOrder()
  {
   if(trade.Sell(LotSize, NULL, 0, 0, 0, "Sell Order"))
     {
      Print("Sell order placed successfully");
     }
   else
     {
      Print("Error placing sell order: ", GetLastError());
     }
  }

Bis zu diesem Punkt haben wir nun unseren EA implementiert.

Nachstehend finden Sie die Backtest-Ergebnisse:

 

Getestet wurde der USDJPY auf einem M1-Chart. Der Testzeitraum war vom 01.01.2024 bis zum 05.08.2024. Art der Modellierung, jeder Tick. 

Nachfolgend sind die Eingangsparameter aufgeführt, die bei der Prüfung verwendet wurden:

       

Nach mehreren Tests auf einem M1-Chart konnte ich dies feststellen:

• Diese Strategie ist für USDJPY und EURUSD geeignet.
• Diese Strategie funktioniert nicht gut bei GBPUSD.

Schlussfolgerung

Aus den Ergebnissen können wir schließen, dass dieser einfache Expert Advisor (EA) einem Trader gute Ergebnisse sichern kann, wenn er weiter verfeinert und angepasst wird, um seine Verwaltung zu verbessern und auch die Exposition der Vermögenswerte gegenüber hohen Risiken zu reduzieren. Dies beinhaltet die Implementierung von Risikomanagement-Funktionen wie das Hinzufügen eines Trailing-Stopps, der dazu beiträgt, die Leistung des EAs zu verbessern, indem er Gewinne sichert, wenn sich der Markt günstig entwickelt. Parameteroptimierung, verschiedene Tests und Feinabstimmung von Einstellungen wie SAR Step und Maximum für optimale Leistung unter verschiedenen Marktbedingungen.

Haftungsausschluss : Dieser Code soll Händlern nur helfen, die Grundlagen der Implementierung der Parabolic SAR-Strategie zu erlernen: Bei der Entwicklung eines effektiven Expert Advisors sind die Ergebnisse der Demoversion, die wir in unserem Backtest erhalten haben, keine Garantie für die zukünftige Leistung des EA im Handel.

Gründliche Backtesting- und Forwardtesting-Verfahren sind vor dem Live-Einsatz von entscheidender Bedeutung, wobei eine kontinuierliche Überwachung unerlässlich ist, um unerwartete Verluste zu vermeiden und schnelle Anpassungen vorzunehmen. Die Automatisierung des Handels mit dieser Strategie kann dazu beitragen, menschliche Fehler und Ermüdungserscheinungen zu minimieren, und ermöglicht es, durch Anpassung, Optimierung und Tests ein ausgeklügeltes und profitables Handelssystem zu erstellen. Daher kann die Einführung dieser Art von Automatisierung zu einer effizienteren Nutzung von Chancen und einer besseren Handelsleistung führen. Bis zu diesem Punkt hat der Artikel die erforderlichen Kenntnisse und Fähigkeiten für die Umsetzung der Parabolic-SAR-Strategie aufgezeigt und vermittelt. Alle anderen Ressourcen, die für die Implementierung erforderlich sind, können über unsere MQL5-Plattform abgerufen werden.