Implementierung einer Handelsstrategie der Bollinger Bänder mit MQL5: Ein schrittweiser Leitfaden

Einführung

In der dynamischen Welt des Finanzhandels kann die Verwendung von technischen Indikatoren von großer Bedeutung sein. Bollinger Bänder sind eine solche effektive Technik, die Händler verwenden können, um mögliche Einstiegs- und Ausstiegspunkte auf der Grundlage der Preisvolatilität und Trendstärke zu bestimmen. Dieser Artikel befasst sich mit der Automatisierung von Handelsentscheidungen mit einer Bollinger Bänder Handelsstrategie unter Verwendung der MQL5 Programmiersprache in MetaTrader 5.

Händler können einen Expert Advisor (EA) erstellen, der Bollinger Bänder verwendet, um Kauf- und Verkaufsaufträge basierend auf bestimmten Marktbedingungen auszuführen, indem sie dieser Schritt-für-Schritt-Anleitung folgen. Wichtige Themen wie die Konfiguration des Bollinger-Band-Indikators, die Kontrolle von Handelspositionen, die Auftragsausführung und das Fehlermanagement werden behandelt. Unabhängig von Ihrer Erfahrung mit der Entwicklung oder Ihrer Vertrautheit mit dem algorithmischen Handel bietet dieses Tutorial Händlern eine solide Grundlage, auf der sie ihre Handelsmethoden entwickeln und verbessern können.

Diese Reise wird die folgenden Themen behandeln:

1. Definition der Bollinger Band Strategie
2. Beschreibung der Bollinger Band Strategie
3. Schritt-für-Schritt-Implementierung mit MQL5
4. Schlussfolgerung

Definition der Strategie der Bollinger Bänder

Die Bollinger-Band-Strategie ist eine technische Analysemethode, die eine Reihe von Bändern um einen gleitenden Durchschnitt herum verwendet, um den Nutzen und mögliche Handelsmöglichkeiten zu bestimmen. Die Strategie besteht aus drei Bändern: einem unteren Band (mittleres Band minus ein Vielfaches der Standardabweichung), einem oberen Band (mittleres Band plus ein Vielfaches der Standardabweichung) und einem mittleren Band (einfacher gleitender Durchschnitt). Basierend auf der Interaktion des Kurses mit den Bändern können Händler dieses Setup nutzen, um überkaufte oder überverkaufte Situationen zu erkennen, mögliche Kauf- oder Verkaufssignale zu identifizieren und Kursausbrüche oder -umkehrungen vorherzusagen.

Beschreibung der Bollinger Band Strategie 

Ein beliebtes technisches Analyseinstrument, das Händler verwenden, um die Marktvolatilität zu bewerten und mögliche Handelsmöglichkeiten zu erkennen, ist die Bollinger-Bänder-Strategie. John Bollinger hat diese Taktik entwickelt, die aus drei Hauptbestandteilen besteht:

1. Mittleres Band (SMA): Dies ist der einfache gleitende Durchschnitt (SMA) der Schlusskurse des Vermögenswerts eines bestimmten Zeitraums. Er stellt den Durchschnittspreis während des angegebenen Zeitraums dar und dient als zentraler Bezugspunkt für das Band.
2. Oberes Band: Dieses Band wird durch Multiplikation der Standardabweichung mit dem SMA berechnet und oberhalb des mittleren Bandes angezeigt. Er bezeichnet die obere Grenze der Preisspanne und ist ein Indikator für überkaufte oder volatilere Bedingungen. Sie ergibt sich aus: [{Oberes Band} = {Mittleres Band} + 2* {Standardabweichung}]
3. Unteres Band: Diese Bandbreite wird durch Abzug des Doppelten der Standardabweichung vom SMA berechnet und unterhalb der mittleren Bandbreite angezeigt. Infolge einer verringerten Volatilität oder einer überverkauften Situation stellt er die untere Grenze der Preisspanne dar. Sie wird bereitgestellt durch: [{Unteres Band} = {Mittleres Band} - 2* {Standardabweichung}]

Schlüsselaspekte der Strategie:

Preisbewegung und Bandinteraktion: Die Kurse gelten oft als überverkauft, wenn sie sich dem unteren Band nähern oder dieses berühren, und als überkauft, wenn sie sich dem oberen Band nähern oder dieses berühren. Die Identifizierung möglicher Kauf- oder Verkaufssignale durch den Händler kann durch diese Interaktion unterstützt werden.

• Verengung der Bänder: Die Verengung der Bänder (Band Squeeze) entsteht, wenn sich die Bänder einander nähern, es ist eine Schlüsselidee der Bollinger-Bänder. Dies deutet auf eine Zeit geringer Volatilität hin und kann auch das bevorstehende Auftreten einer großen Kursbewegung oder eines Ausbruchs bedeuten. Händler achten auf mögliche Handelschancen während dieser Engpässe

• Trendbestätigung: Bollinger Bänder sind nützlich für die Trendbestätigung, wenn sie mit anderen Indikatoren kombiniert werden. So kann beispielsweise ein starker Aufwärtstrend bestätigt werden, wenn der Kurs das obere Band mit erheblichem Volumen überschreitet, während ein Abwärtstrend bestätigt werden kann, wenn der Kurs unter das untere Band fällt.                                       

Anwendung der Strategie:

Durch die Verwendung von Kursniveaus über den Bändern können Händler mit Hilfe der Bollinger-Bänder-Strategie gut informierte Entscheidungen treffen. Eine typische Strategie besteht darin, zu kaufen, wenn der Kurs das untere Band berührt oder durchquert, in der Annahme, dass es zu einer Erholung kommt, und zu verkaufen, wenn der Kurs das obere Band berührt oder durchquert, in der Annahme, dass es zu einem Pullback kommt. Die Strategie hilft auch bei der Erkennung von Volatilitätsspitzen und möglichen Trendumkehrungen.

Schritt-für-Schritt-Implementierung mit MQL5 

Wir beginnen mit der Einrichtung von Handelsgeschäften. Die Platzierung und Verwaltung von Aufträgen sind Handelsoperationen, die für die Implementierung einer Bollinger Band Strategie mit MQL5 gehandhabt werden müssen. Diese Operationen werden durch die integrierte Handelsbibliothek der Sprache MQL5 erleichtert. Lassen Sie uns über die Initialisierung der Handelsbibliothek sprechen und darüber, wie sie die Haupt-Handelslogik unterstützt.

#include<Trade\Trade.mqh> // Include the trade library

Wir müssen eine Instanz der Klasse CTrade erstellen, um die von der Handelsbibliothek angebotenen Funktionen nutzen zu können.

CTrade trade; // Create an instance of the CTrade class  

Wir können ihre Methoden für Handelsoperationen, wie das Öffnen, Schließen und Ändern von Aufträgen, verwenden, indem wir die Handelsbibliothek hinzufügen und das CTrade-Objekt initialisieren. Das CTrade-Objekt bietet mehrere Möglichkeiten zur Durchführung von Handelsgeschäften. Wir verwenden sie in unserem Bollinger Bänder EA, um Kauf- und Verkaufsaufträge unter den in der OnTick-Funktion angegebenen Handelsbedingungen auszulösen. Das Handelsobjekt wird zur Eröffnung von Kauf- und Verkaufsaufträgen verwendet. Ein Kaufauftrag wird vom EA eröffnet, wenn der Kurs unter das untere Bollinger Band fällt.

Mit dieser Konfiguration können wir die Handelsaktivitäten effektiv überwachen und uns auf die Entwicklung einer starken Handelslogik konzentrieren. Die Händler können die Art und Weise, wie ihr EA auf die Marktbedingungen reagiert und Handelsgeschäfte ausführt, verbessern, indem sie lernen, wie man die CTrade mit den Methoden für die Platzierung von Aufträgen verwendet.

Wir konfigurieren nun die Eingaben, indem wir die Handelsstrategie anpassen. Die Eingabe- und Konstanten-Deklarationen in MQL5 ermöglichen es Händlern, verschiedene Aspekte ihrer Handelsstrategie zu ändern und einzurichten. Je nach Marktlage und Handelspräferenzen können diese Eingaben geändert werden. Erläutern wir die Bedeutung dieser Parameter und wie die Bollinger-Bänder-Handelsmethode durch sie beeinflusst wird.

Die Variableneingaben können vom MetaTrader-Terminal aus geändert werden, ohne dass der Code geändert werden muss. Das Schlüsselwort input wird verwendet, um sie zu deklarieren. Der Bollinger Bänder EA verwendet die folgenden Eingabeparameter:

 // Input parameters for the Bollinger Bands strategy
 input int BandPeriod = 30;
 input double BandDeviation = 2.0;
 input double LotSize = 0.2;
 input int Slippage = 3;
 const double StopLoss = 70;
 const double TakeProfit = 140;

BandPeriod ist die Anzahl der Perioden, die bei der Berechnung des Bollinger Bandes verwendet werden. Während eine kürzere Zeitspanne die Empfindlichkeit des Bandes gegenüber Kursschwankungen erhöht, glättet ein längerer Zeitraum die Bänder und kann die Handelssignale verringern. Ändern Sie dies, um der Volatilität des Marktes oder den Anforderungen des Handelsplans Rechnung zu tragen.

BandDeviation werden die oberen und unteren Bänder durch Zählen der vom gleitenden Durchschnitt abweichenden Standardabweichungen bestimmt. Breitere und weniger wahrscheinlich berührte Bänder resultieren aus einer größeren Abweichung, die Handelssignale abschwächen kann. Je geringer die Divergenz, desto schmaler die Bänder und desto höher die Frequenz des Signals. Passen Sie diesen Wert an, um die Verantwortung der Bands für Preisänderungen zu regeln.

LotSize ist das Handelsvolumen des Vermögenswerts. Legt das Volumen der einzelnen Handelsgeschäfte fest. Größere Losgrößen erhöhen die Gewinnaussichten, aber sie passen diese auch an die Größe Ihres Kontos und Ihre Risikotoleranz an.

Slippage ist der höchste erlaubte Betrag für Schlupf, der die Reihenfolge der Punkte beeinflusst. Er sorgt dafür, dass die Aufträge in der Nähe des vorgesehenen Preises ausgeführt werden, wobei kleine Preisschwankungen zwischen den einzelnen Aufträgen berücksichtigt werden. Ist an die Marktlage und die Liquidität des Vermögenswerts anzupassen.

Konstanten sind unveränderliche Werte, die zur Kompilierzeit festgelegt werden und zur Laufzeit nicht verändert werden können. Das Schlüsselwort const wird verwendet, um sie zu definieren:

const double StopLoss = 70;           
const double TakeProfit = 140;   

StopLoss, der Punkte-Abstand zwischen Eröffnungspreis und Stop-Loss. Wenn sich der Markt um die angegebenen Punkte gegen Sie entwickelt, können Sie Ihre möglichen Verluste begrenzen, indem Sie das Handelsgeschäft schließen. Dieser Wert sollte auf der Grundlage der Marktvolatilität und Ihrer Risikomanagementrichtlinien festgelegt werden.

Take-Profit, der Punkte-Abstand zwischen Eröffnungspreis und Take-Profit. Erhalt den Ertrag durch Ausstieg aus dem Handelsgeschäft, wenn sich der Markt erholt. Mehrere Optionen für Anpassungen. Passen Sie die Höhe Ihres Gewinns und die Marktlage an.

Händler können die Bollinger-Bänder-Handelsmethode an ihren Handelsstil und die Marktlage anpassen, indem sie Eingabe- und konstante Parameter konfigurieren. Sie können die Leistung ihres EAs fein abstimmen und ihn durch die Änderung von Parametern an ihre Handelsziele anpassen. Es ist wichtig, diese Faktoren zu verstehen und zu wissen, wie sie die Strategie beeinflussen, um die Handelsleistung zu maximieren und das Risiko effizient zu verwalten.

Danach betrachten wir eine ganzzahlige Variable. Im gesamten Skript wird dieses Handle benötigt, um auf die Anzeige zu verweisen und mit ihr zu interagieren.

int Bb_Handle; // Handle for the Bollinger Bands indicator

Dieses Handle ist ein wesentlicher Bestandteil des Umgangs mit dem Bollinger Bänder Indikator von MQL5. Es garantiert, dass die Handelsstrategie reibungslos und effektiv ablaufen kann, indem es die Verwaltung von Indikatordaten und Ressourcen rationalisiert.

Wir gehen nun zur OnInit-Funktion eines EA über, der seine Handelslogik in diesem Tutorial auf die Bollinger-Bänder stützt. Wenn ein EA neu initialisiert oder an ein Chart angehängt wird, wird die OnInit-Funktion einmal aufgerufen. Mit dieser Funktion werden alle erforderlichen Handles für Indikatoren angelegt und die Startparameter eingestellt.

Der EA definiert vor der OnInit-Funktion mehrere gebrauchte, kostenpflichtige und unbrauchbare Eingabeparameter. Zu diesen Parametern gehören der Zeitraum, die Abweichung der Bollinger-Bänder, die Losgröße, der Slippage und der Stop.

Die Erstellung eines Handles für den Bollinger Bänder Indikator ist die Hauptaufgabe der OnInit Funktion. Dies geschieht mit der Funktion iBands.

int OnInit()
  {
   Bb_Handle = iBands(_Symbol, _Period, BandPeriod, BandDeviation, 0, PRICE_CLOSE);

Hier versuchen wir, den Bollinger Bänder-Indikator mit dem angegebenen Parameter zu erstellen und dem Handle den Namen Bb_Handle zuzuweisen.

Es ist wichtig zu überprüfen, ob die Erstellung des Handles erfolgreich war. Falls der Handle ungültig ist, wurde die Angabe nicht gemacht, um dieses Problem ordnungsgemäß zu verwalten, sollte der EA INIT_FAILED zurückgeben und eine Fehlermeldung ausgeben.

if(Bb_Handle == INVALID_HANDLE)
     {
      Print("Error creating Bollinger Bands indicator");
      return(INIT_FAILED);
     }

Die OnInit-Funktion sollte INIT_SUCCEEDED zurückgeben, um anzuzeigen, dass die Initialisierungsprozedur erfolgreich abgeschlossen wurde, wenn der Indikator-Handle gültig ist.

return(INIT_SUCCEEDED);
  }

Kombiniert man alle Schritte, sieht die OnInit-Funktion wie unten dargestellt aus:

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   // Create the Bollinger Bands indicator handle
   Bb_Handle = iBands(_Symbol, _Period, BandPeriod, BandDeviation, 0, PRICE_CLOSE); 
    { 
    if(Bb_Handle == INVALID_HANDLE)
     {
      Print("Error creating Bollinger Bands indicator"); 
      return(INIT_FAILED);
     }
   return(INIT_SUCCEEDED);
  }

Die OnInit-Funktion ist für die Konfiguration der Elemente, aus denen ein EA besteht, von wesentlicher Bedeutung. Der Algorithmus stellt sicher, dass er bereit ist, seine Handelslogik auszuführen, indem er einen Handle für den Bollinger-Band-Indikator erstellt und jegliches Risiko verwaltet.

Als Nächstes betrachten wir die OnDeinit-Funktion. Diese Funktion ist für die algorithmische als auch für die fundamentale Handelslogik entscheidend. Wenn Sie sicherstellen, dass Ihr Expert Advisor die Ressourcen bereinigt, können Sie Probleme vermeiden und den Handel stabil halten. Wenn der EA aus einem Chart gelöscht oder die Plattform geschlossen wird, wird die Funktion OnDeinit ausgelöst. Seine Aufgabe ist es, alle Ressourcen wie z. B. Indikator-Handles freizugeben, die während der Operationen des EA zugewiesen wurden. Dies garantiert, dass die Leistung der Plattform nicht durch Speicherlecks oder persistente Prozesse beeinträchtigt wird.

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   // Release the Bollinger Bands indicator hande
   IndicatorRelease(Bb_Handle);
  }

Die Freigabe des Handles des Indikators der Bollinger Bänder ist die Hauptaufgabe der OnDeinit Funktion in unserem Expert Advisor. Die Funktion IndicatorRelease wird verwendet.

Als Nächstes gehen wir zur Funktion OnTick über, die das Herzstück unseres Expert Advisors ist. Sie wird jedes Mal ausgelöst, wenn die Preisaktualisierung für das aktuelle Chartsymbol einen neuen Tick erhält. Die grundlegende Handelslogik, die die Reaktion des EA auf die Marktbedingungen steuert, ist in dieser Funktion enthalten.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
    double upperBand[], lowerBand[], middleBand[];
   
    // Copy the Bollinger Bands values into arrays
    if(CopyBuffer(Bb_Handle, 0, 0, 1, upperBand) <= 0||
      (CopyBuffer(Bb_Handle, 1, 0, 1, middleBand) <= 0||
      (CopyBuffer(Bb_Handle, 2, 0, 1, lowerBand) <= 0||
   {
     Print("Error copying band values");
     return;
    
     double upper = upperBand[0];
     double lower = lowerBand[0];
     double middle = middleBand[0];
     double price = Close[0];
     double Ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
     double Bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
     
     // Buy signal: price is below the lower band and no open positions 
    if(price < lower && ! IsPositionOpen(_symbol))
      {
       double sl, tp;
       CalculateSLTP(sl, tp, price, true);
      if(trade.Buy(LotSize, _symbol, Ask, sl, tp, "Buy Order"))
        Print("Buy order opened at price: ", price);
      else
      { 
       Print("Error opening BUY order:", trade.ResultRetcode());
     }
      // Sell signal: price is above the upper band no open positions
      else if(price > upper && ! IsPositionOpen(_symbol))
       {
        double sl, tp;
        CalculateSLTP(sl, tp, price, false);
       if(trade.Sell(LotSize, _Symbol, Bid, sl, tp, "Sell Order"));
         Print("Sell order opened at price:", Price);
      else
         print("Error opening SELL order:", trade.ResultRetcode())
    }
  }

Hier ist die detaillierte Aufschlüsselung der OnTick-Funktion zum besseren Verständnis:

Definieren und Abrufen der Werte der Bollinger-Bänder: Die erste Aufgabe besteht darin, die aktuellen Werte der Bollinger-Bänder abzurufen. Zu diesem Zweck wird die Funktion CopyBuffer verwendet, die die Indikatorwerte in Arrays kopiert.

double upperBand[], lowerBand[], middleBand[];
   
    // Copy the Bollinger Bands values into arrays
    if(CopyBuffer(Bb_Handle, 0, 0, 1, upperBand) <= 0||
      (CopyBuffer(Bb_Handle, 1, 0, 1, middleBand) <= 0||
      (CopyBuffer(Bb_Handle, 2, 0, 1, lowerBand) <= 0||
   {
     Print("Error copying band values");
     return;

Weisen wir den Variablen die Werte der Bänder zu: Die Werte aus den Arrays werden dann zur einfacheren Bezugnahme Variablen zugewiesen.

     double upper = upperBand[0];
     double lower = lowerBand[0];
     double middle = middleBand[0];
     double price = Close[0];

Abrufen der aktuellen Geld- und Briefkurse (ask & bid): Hier benötigen wir die aktuellen Geld- und Briefkurse, um die Handelsgeschäfte zu tätigen.

     double Ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
     double Bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);

Handelslogik basierend auf den Bollinger Bänder: Der Preis der Kauf-Bedingungen ist die Grundlage der Handelslogik.

• Kaufbedingung: Erteilen Sie einen Kaufauftrag, wenn es keine offene Position gibt und der Preis unter dem unteren Band liegt. 

   // Buy signal: price is below the lower band and no open positions 
    if(price < lower && ! IsPositionOpen(_symbol))
      {
       double sl, tp;
       CalculateSLTP(sl, tp, price, true);
      if(trade.Buy(LotSize, _symbol, Ask, sl, tp, "Buy Order"))
        Print("Buy order opened at price: ", price);
      else
      { 
       Print("Error opening BUY order:", trade.ResultRetcode());
     }

• Verkaufsbedingung: Erteilen Sie einen Verkaufsauftrag, wenn es keine offene Position gibt und der Preis über dem oberen Band liegt.

 // Sell signal: price is above the upper band no open positions
      else if(price > upper && ! IsPositionOpen(_symbol))
       {
        double sl, tp;
        CalculateSLTP(sl, tp, price, false);
       if(trade.Sell(LotSize, _Symbol, Bid, sl, tp, "Sell Order"));
         Print("Sell order opened at price:", Price);
      else
         print("Error opening SELL order:", trade.ResultRetcode())
    }
  }

In unserer Bollinger-Band-Handelsstrategie finden die eigentlichen Operationen in der OnTick-Funktion statt. Wir können eine zuverlässige und automatisierte Handelsstrategie entwickeln, indem wir die Werte der Bollinger Bänder sorgfältig ermitteln und unsere Handelsentscheidungen darauf stützen. Jeder Aspekt dieser Funktion ermöglicht eine effizientere Fehlersuche und Verbesserungen und garantiert, dass unser EA in einer Reihe von Marktszenarien mit höchster Effizienz arbeitet.

Neben der Hauptfunktion OnTick stützt sich unser Expert Advisor auf Hilfsfunktionen, um Positionen zu verwalten, Take-Profit- und Stop-Loss-Niveaus zu bestimmen und einen reibungslosen Handel zu gewährleisten. Die Unterstützungsfunktionen sind unerlässlich, um die Widerstandsfähigkeit und Wirksamkeit der Handelsstrategie zu erhalten. Wir werden die Hilfsfunktionen, die in unserem Bollinger Bänder EA verwendet werden, Schritt für Schritt durchgehen.

Die erste Hilfsfunktion ist die Prüfung auf offene Stellen. Die Funktion isPositionOpen ermittelt, ob das gelieferte Symbol zu diesem Zeitpunkt eine offene Position hatte. Dies ist notwendig, um sicherzustellen, dass der EA nicht gleichzeitig mehrere Positionen für dasselbe Symbol öffnet.

//+------------------------------------------------------------------+
//| Check if there's an open position for a symbol                   |
//+------------------------------------------------------------------+
   
   bool IsPositionOpen(string symbol)
   }
    for(int i = 0;  i< PositionsTotal(); i++)
    }
     if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol)
       return true;
     {
      return false;
    }

Schritt-für-Schritt-Aufschlüsselung der Prüfung auf offene Position:

• Schleife durch alle Positionen: 

for(int i = 0;  i< PositionsTotal(); i++)
    }

Gibt die Gesamtzahl der offenen Positionen an. Iteriert durch alle Positionen anhand seines Indexes.

• Auswahl der Position nach Index:  

if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol)
       

Diese Funktion wählt die Position des Index i. Ermittelt das Symbol der ausgewählten Position mit PositionGetString.

• Prüfen des Symbols und Rückgabe von true, bei Übereinstimmung

if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol)
       return true;
     

Vergleicht das Symbol der Position mit dem Eingabesymbol. Wenn eine Übereinstimmung gefunden wird, wird true zurückgegeben.

• Gibt false zurück, wenn keine Übereinstimmung gefunden wurde.

return false;
    }

Nachdem jede Position durchlaufen wurde, wird false zurückgegeben, wenn keine offene Position für das Symbol gefunden wurde.

Die zweite Hilfsfunktion unseres EA ist das Schließen aller Positionen für ein Symbol. Für das angegebene Symbol schließt die Funktion CloseAllPositions alle offenen Positionen. Bei Risikomanagement oder Strategieänderungen kann dies hilfreich sein.

//+------------------------------------------------------------------+
//|Close all positions for a symbol                                  |
//+------------------------------------------------------------------+
   void CloseAllPositions(string symbol)
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
    if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol)
     {
      ulong ticket = PositionGetInteger(POSITION_TICKET);
    if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
         trade.sell(LotSize, symbol, symbolInfoDouble(symbol, SYMBOL_BID), Slippage, 0, "Close Buy");
     {
     if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
          trade.Buy(LotSize, symbol, SymbolInfoDouble(symbol, SYMBOL_ASK), Slippage, 0, "Close Sell");
          // Wait for order to be processed before continuing
            Sleep(1000);
           }
          }
         }
        

Schritt-für-Schritt-Aufschlüsselung für das Schließen aller Positionen für eine Symbolfunktion:

• Schleife durch alle Positionen in umgekehrter Reihenfolge

for(int i = 0;  i< PositionsTotal(); i++)    

Kehrt nach dem Durchlaufen einer Schleife zum Ausgangspunkt zurück. Stellt sicher, dass das Schließen der Position die Indexreihenfolge nicht verändert.

• Auswahl der Position durch Index und Prüfzeichen:

   if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol

Wählt den Ort aus und stellt fest, ob das Eingabesymbol und das Symbol übereinstimmen.

• Holen Sie sich das Positionsticket und geben Sie es ein:

      ulong ticket = PositionGetInteger(POSITION_TICKET);

Ruft die Ticketnummer der Position ab.

• Schließen von Kauf- oder Verkaufspositionen:

if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
        trade.Sell(LotSize, symbol, SymbolInfoDouble(symbol, SYMBOL_BID), Slippage, 0, "Close Buy");
  else if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
        trade.Buy(LotSize, symbol, SymbolInfoDouble(symbol, SYMBOL_ASK), Slippage, 0, "Close Sell");

Schließt Kaufpositionen durch Verkäufe und Verkaufspositionen durch Verkäufe und Verkaufspositionen durch Käufe. Verwendet den aktuellen Brief- und Geldkurs.

• Eine Pause, um die Bearbeitung des Auftrags zu ermöglichen:

      // Wait for order to be processed before continuing
            Sleep(1000);
           }
          }
         }

Bevor er zum nächsten Schritt weitergeht, hält er kurz inne, um sich zu vergewissern, dass der Auftrag bearbeitet wurde.

Als Nächstes folgt unsere letzte Hilfsfunktion, die die Berechnung der Stop-Loss- und Take-Profit-Niveaus vorsieht. Die Niveaus für Stop Loss (SL) und Take Profit (TP) werden von der Funktion CalculateSLTP anhand des aktuellen Kurses und des Kauf-/Verkaufsstatus des Handels bestimmt.

//+------------------------------------------------------------------+
//| Calculate Stop Loss and Take Profit levels                       |
//+------------------------------------------------------------------+
   void CalculateSLTP(double &sl, double &tp, double price, bool isBuy)
   {
    if(isBuy)
     {
      sl = price - StopLoss *_Point;
      tp = price + TakeProfit *_Point;
     }
     else 
      {
       sl = price + StopLoss *_Point;
       tp = price - TakeProfit *_Point;
      }
     }

Die schrittweise Aufschlüsselung für die Berechnung der Niveaus der Funktionen Stop Loss und Take Profit:

• Definieren der Parameter der Funktion:

void CalculateSLTP(double &sl, double &tp, double price, bool isBuy)

sl: Die Stop-Loss-Stufe wurde bereits besprochen.

tp: Bezieht sich auf den Schwellenwert für die Gewinnmitnahme.

price: Der aktuelle Preis.Der boolesche Wert, der angibt, ob der Handel Kauf (true) oder Verkauf (false) ist isBuy. Bestimmen wir SL und TP für die Eröffnung einer Kaufpositionen:

if(isBuy)
  {
    sl = price - StopLoss * _Point;
    tp = price + TakeProfit * _Point;
  }

StopLoss: subtrahiert den definierten StopLoss (in Punkten) vom aktuellen Take Profit.

TakeProfit: Fügt den definierten TakeProfit (in Punkten) zu den aktuellen Preise. Berechnung von SL und TP für eine Verkaufsposition.

else
  {
    sl = price + StopLoss * _Point;
    tp = price - TakeProfit * _Point;
  }
}

StopLoss: Addiert zum aktuellen Preis StopLoss (in Punkten).

TakeProfit: Subtrahiert den angegebenen TakeProfit (in Punkten) vom aktuellen Kurs.

Der vollständige Code für die Hilfsfunktionen lautet wie folgt:

//+------------------------------------------------------------------+
//| Check if there's an open position for a symbol                   |
//+------------------------------------------------------------------+
   
   bool IsPositionOpen(string symbol)
   }
    for(int i = 0;  i< PositionsTotal(); i++)
    }
     if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol)
       return true;
     {
      return false;
    }
//+------------------------------------------------------------------+
//|Close all positions for a symbol                                  |
//+------------------------------------------------------------------+
   void CloseAllPositions(string symbol)
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
    if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol)
     {
      ulong ticket = PositionGetInteger(POSITION_TICKET);
    if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
         trade.sell(LotSize, symbol, symbolInfoDouble(symbol, SYMBOL_BID), Slippage, 0, "Close Buy");
     {
     if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
          trade.Buy(LotSize, symbol, SymbolInfoDouble(symbol, SYMBOL_ASK), Slippage, 0, "Close Sell");
          // Wait for order to be processed before continuing
            Sleep(1000);
           }
          }
         }
        
//+------------------------------------------------------------------+
//| Calculate Stop Loss and Take Profit levels                       |
//+------------------------------------------------------------------+
   void CalculateSLTP(double &sl, double &tp, double price, bool isBuy)
   {
    if(isBuy)
     {
      sl = price - StopLoss *_Point;
      tp = price + TakeProfit *_Point;
     }
     else 
      {
       sl = price + StopLoss *_Point;
       tp = price - TakeProfit *_Point;
      }
     }

Wir verwalten und organisieren die Grundlogik unseres Expert Advisors mit Hilfe der Hilfsfunktionen. Damit stellen wir sicher, dass der EA reibungslos läuft, die Positionen genau verwaltet und das Risikomanagement in unserer Bollinger Bänder Handelsstrategie berechnet wird. Wenn Sie diese Hilfsfunktionen verstehen und anwenden, können Sie die Zuverlässigkeit und Effizienz Ihrer MQL5-Handelsalgorithmen verbessern.

Der vollständige Code unseres Artikels ist nachstehend aufgeführt:

//+------------------------------------------------------------------+
//|                                               BollingerBands.mq5 |
//|                                  Copyright 2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"

 #include<Trade\Trade.mqh> // Include the trade library
 CTrade trade; // Create an instance of the CTrade class  

 // Input parameters for the Bollinger Bands strategy
 input int BandPeriod = 30;
 input double BandDeviation = 2.0;
 input double LotSize = 0.2;
 input int Slippage = 3;
 const double StopLoss = 70;
 const double TakeProfit = 140;
 
 int Bb_Handle; // Handle for the Bollinger Bands indicator 

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   // Create the Bollinger Bands indicator handle
   Bb_Handle = iBands(_Symbol, _Period, BandPeriod, BandDeviation, 0, PRICE_CLOSE); 
    { 
    if(Bb_Handle == INVALID_HANDLE)
     {
      Print("Error creating Bollinger Bands indicator"); 
      return(INIT_FAILED);
     }
   return(INIT_SUCCEEDED);
  }
 
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   // Release the Bollinger Bands indicator hande
   IndicatorRelease(Bb_Handle);
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
    double upperBand[], lowerBand[], middleBand[];
   
    // Copy the Bollinger Bands values into arrays
    if(CopyBuffer(Bb_Handle, 0, 0, 1, upperBand) <= 0||
      (CopyBuffer(Bb_Handle, 1, 0, 1, middleBand) <= 0||
      (CopyBuffer(Bb_Handle, 2, 0, 1, lowerBand) <= 0||
   {
     Print("Error copying band values");
     return;
    
     double upper = upperBand[0];
     double lower = lowerBand[0];
     double middle = middleBand[0];
     double price = Close[0];
     double Ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
     double Bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
     
     // Buy signal: price is below the lower band and no open positions 
    if(price < lower && ! IsPositionOpen(_symbol))
      {
       double sl, tp;
       CalculateSLTP(sl, tp, price, true);
      if(trade.Buy(LotSize, _symbol, Ask, sl, tp, "Buy Order"))
        Print("Buy order opened at price: ", price);
      else
      { 
       Print("Error opening BUY order:", trade.ResultRetcode());
     }
      // Sell signal: price is above the upper band no open positions
      else if(price > upper && ! IsPositionOpen(_symbol))
       {
        double sl, tp;
        CalculateSLTP(sl, tp, price, false);
       if(trade.Sell(LotSize, _Symbol, Bid, sl, tp, "Sell Order"));
         Print("Sell order opened at price:", Price);
      else
         print("Error opening SELL order:", trade.ResultRetcode())
    }
  }

//+------------------------------------------------------------------+
//| Check if there's an open position for a symbol                   |
//+------------------------------------------------------------------+
   
   bool IsPositionOpen(string symbol)
   }
    for(int i = 0;  i< PositionsTotal(); i++)
    }
     if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol)
       return true;
     {
      return false;
    }
//+------------------------------------------------------------------+
//|Close all positions for a symbol                                  |
//+------------------------------------------------------------------+
   void CloseAllPositions(string symbol)
  {
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
    if(PositionSelectByIndex(i) && PositionGetString(POSITION_SYMBOL) == symbol)
     {
      ulong ticket = PositionGetInteger(POSITION_TICKET);
    if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
         trade.sell(LotSize, symbol, symbolInfoDouble(symbol, SYMBOL_BID), Slippage, 0, "Close Buy");
     {
     if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
          trade.Buy(LotSize, symbol, SymbolInfoDouble(symbol, SYMBOL_ASK), Slippage, 0, "Close Sell");
          // Wait for order to be processed before continuing
            Sleep(1000);
           }
          }
         }
        
//+------------------------------------------------------------------+
//| Calculate Stop Loss and Take Profit levels                       |
//+------------------------------------------------------------------+
   void CalculateSLTP(double &sl, double &tp, double price, bool isBuy)
   {
    if(isBuy)
     {
      sl = price - StopLoss *_Point;
      tp = price + TakeProfit *_Point;
     }
     else 
      {
       sl = price + StopLoss *_Point;
       tp = price - TakeProfit *_Point;
      }
     }

Hurra! Jetzt haben wir ein Konzept für das Handeln der Bollinger Bänder erstellt, um Handelssignale zu generieren.

Backtest-Ergebnisse

Nach dem Test mit dem Strategietester sind die Ergebnisse wie folgt:

Grafik:

Ergebnisse:

Von 2016 bis 2019 führte die Strategie 1425 Handelsgeschäfte aus, 857 wurden mit Gewinn geschlossen, was 20,28% mehr ist als die Verlustpositionen.           

Bei den verwendeten Parametern handelt es sich um Standardwerte, sodass die Händler sie an ihre Handelssysteme anpassen können. Im Folgenden sind die verwendeten Parameter aufgeführt:

Hier sind die Einstellungen, die wir für unseren Test verwendet haben:

Schlussfolgerung

In diesem Artikel haben wir uns die grundlegenden Schritte angesehen, die für die Automatisierung der Bollinger Bänder Trading Strategie in MQL5 implementiert werden müssen. Wir haben die grundlegende Definition und Beschreibung der Strategie vorgenommen und gezeigt, wie sie in MQL5 umgesetzt werden kann. Händler können nun das gezeigte Wissen nutzen, um eine komplexere Bollinger-Band-Strategie zu entwickeln, die optimiert werden kann, um am Ende bessere Ergebnisse zu erzielen.

Haftungsausschluss: Der in diesem Artikel enthaltene Code dient ausschließlich zu Bildungszwecken und sollte nicht als professionelle Anlageberatung verstanden werden. So setzen Sie das Wissen sorgfältig ein, um Ihre Systeme zu erstellen und zu optimieren, damit sie zu Ihrem Handelsstil passen.

Wir hoffen, dass Sie es nützlich finden und dass es Ihnen hilft, eine besser optimierte Bollinger-Band-Strategie zu entwickeln. Wir haben die notwendigen Dateien mit den Beispielen beigefügt, die wir zur Veranschaulichung dieser Beispiele verwendet haben. Studieren Sie den Code und wenden Sie ihn auf Ihre spezifische Strategie an, um optimale Ergebnisse zu erzielen.