Einführung in MQL5 (Teil 13): Ein Anfängerleitfaden zur Erstellung nutzerdefinierter Indikatoren (II)

Einführung

Willkommen zurück zu unserer MQL5-Serie! In Teil 12 dieser Serie wurden die Grundlagen der Erstellung nutzerdefinierter Indikatoren in MQL5 untersucht. Wir haben einen Indikator für den gleitenden Durchschnitt von Grund auf neu erstellt und seine Logik manuell implementiert, anstatt auf integrierte Funktionen zurückzugreifen. Anschließend haben wir dieses Wissen erweitert, indem wir es in einen gleitenden Durchschnitt im Kerzenformat umgewandelt haben, um zu zeigen, wie man grafische Elemente innerhalb eines Indikators manipulieren kann.

Darauf aufbauend werden in diesem Artikel weitere interessante Konzepte zur Entwicklung von Indikatoren vorgestellt. Wie üblich werden wir einen projektbasierten Ansatz verwenden, um sicherzustellen, dass Sie die Themen verstehen, indem Sie sie in die Praxis umsetzen. Die Erstellung eines Heikin Ashi-Indikators und die Berechnung eines gleitenden Durchschnitts unter Verwendung seiner Daten werden die Hauptziele sein. Nachdem diese Indikatoren erstellt wurden, werden wir einen Expert Advisor entwickeln, der die Indikatoren Heikin Ashi und Gleitender Durchschnitt enthält. Sogar diejenigen, die MQL5 noch nicht kennen, können diesem Artikel folgen, denn er ist sehr anfängerfreundlich. Damit Sie nicht nur verstehen, wie die Implementierung funktioniert, sondern auch, warum jeder Schritt erforderlich ist, wird jede Zeile des Codes ausführlich erläutert.

Dieser Artikel befasst sich mit einer Strategie, die ausschließlich für Bildungszwecke gedacht ist. Es handelt sich nicht um eine Handelsstrategie, die Erfolg oder finanzielle Beratung garantiert. Bevor Sie eine Strategie im Live-Handel einsetzen, sollten Sie sie immer in einer risikofreien Umgebung testen.

Heikin Ashi (HA) und Gleitender Durchschnitt (MA)

In diesem Artikel erfahren Sie mehr über Folgendes:

• Wie man einen nutzerdefinierten Heikin Ashi Indikator von Grund auf in MQL5 erstellt.
• Verwendung von Heikin Ashi-Kerzendaten zur Berechnung des gleitenden Heikin Ashi-Durchschnitts.
• Verwendung der Funktion iCustom() für den Zugriff auf nicht eingebaute Indikatoren und die Integration ihrer Daten in Handelsstrategien.
• Festlegung von Einstiegsbedingungen mit Heikin Ashi und dem Kreuzen der MA.
• Effektives Risikomanagement durch dynamisches Setzen von Stop-Loss und Take-Profit auf der Grundlage von Heikin Ashi-Berechnungen.
• Anwendung eines Trailing-Stop unter Verwendung von Heikin Ashi-Kerzenmustern zur Sicherung von Gewinnen bei der Trendentwicklung.

1. Heikin Ashi Indikator

1.1. Den Heikin Ashi-Indikator verstehen

Der Indikator Heikin Ashi (HA) macht Trends leichter erkennbar. HA verwendet eine einzigartige Technik, um neue Werte auf der Grundlage gemittelter historischer Kursdaten zu ermitteln, im Gegensatz zu typischen Kerzen-Charts, die die genauen Eröffnungs-, Höchst-, Tiefst- und Schlusskurse für jeden Zeitraum anzeigen. Dies hilft den Händlern, das Durcheinander zu sortieren und sich auf das Wesentliche zu konzentrieren, indem ein klareres, verständlicheres Bild der Marktbewegungen entsteht.

Jede Kerze in einem typischen Kerzen-Chart zeigt die Bewegung des Kurses über einen bestimmten Zeitraum an. Während eine grüne (Aufwärts-) Kerze anzeigt, dass der Kurs höher geschlossen hat als sie eröffnet wurde, bedeutet eine rote (Abwärts-) Kerze das Gegenteil. Einen Eindruck von der Volatilität des Marktes erhalten Händler durch die dünnen Dochte oberhalb und unterhalb des Kerzenkörpers, die die höchsten und niedrigsten Kurse anzeigen, die während dieser Zeit erreicht wurden.

Aber Heikin Ashi-Kerzen machen es anders. Sie verwenden eine spezielle Berechnung, um Trends zu glätten, anstatt Kursbewegungen genau zu erfassen. Längere grüne Kerzen mit weniger Dochten deuten auf einen Aufschwung hin, was es einfacher macht, eine Aufwärtsdynamik zu erkennen und zu verfolgen. In ähnlicher Weise machen sich rote Kerzen während eines Abwärtstrends stärker bemerkbar und zeigen deutlich negative Ausschläge an. Kleinere Kerzen mit Dochten an beiden Enden tauchen häufig auf, wenn sich der Markt in einer Spanne befindet oder keine nennenswerte Dynamik aufweist, was auf das Zögern oder die Unentschlossenheit der Händler hinweist.

Der HA-Indikator ist insofern einzigartig, als er die konventionellen Kerzen-Berechnungen durch die Verwendung einer Mittelwertbildungstechnik modifiziert. Er erzeugt neue Werte, die eine gleichmäßigere, konsistentere Darstellung der Preisbewegung ergeben, als wenn die Eröffnungs-, Höchst-, Tiefst- und Schlusskurse des Marktes direkt aufgetragen werden. Durch die Beseitigung des „Rauschens“ kleiner Kursschwankungen sind Händler besser in der Lage, Trends zu erkennen und klügere Entscheidungen zu treffen.

Heikin Ashi, sein Schlusskurs

Der Durchschnitt der Eröffnungs-, Höchst-, Tiefst- und Schlusswerte der aktuellen Periode wird zur Bestimmung des Heikin Ashi-Schlusskurses verwendet. Eine ausgewogenere Sichtweise der Preisveränderung bieten die Standardkerzen, die lediglich den Schlusskurs verwenden.

Die Formel lautet:

Der Heikin Ashi Close glättet Kursschwankungen, indem er den Durchschnitt dieser vier Werte bildet, wodurch die Muster visuell deutlicher werden.

Heikin Ashi, sein Eröffnungskurs

Zur Bestimmung des Heikin Ashi-Eröffnungskurses wird die vorangegangene Heikin Ashi-Kerze und nicht die tatsächliche Markteröffnung herangezogen. Er wird durch die Durchschnittswerte der vorherigen Heikin Ashi Open und Close Werte bestimmt:

Heikin Ashi reduziert die unvorhersehbaren Sprünge, die in herkömmlichen Kerzen-Charts häufig auftreten, indem es einen kontinuierlichen Fluss der Kursbewegung durch die Verknüpfung des Eröffnungswerts jeder neuen Kerze mit dem der vorherigen Kerze herstellt.

Heikin Ashi, sein Hoch

Das Hoch von Heikin-Ashi ist der höchste Wert, der im gesamten Zeitraum erreicht wurde. Er berücksichtigt jedoch drei Werte: das Hoch des aktuellen Zeitraums, den Heikin-Ashi-Eröffnungskurs und den Heikin-Ashi-Schlusskurs und nicht nur das tatsächlichen Hoch des Marktes. Von diesen drei wird die höchste ausgewählt:

Heikin Ashi, sein Tief

In ähnlicher Weise wird das Heikin Ashi-Tief berechnet, indem der niedrigste Wert zwischen dem Heikin Ashi-Schlusskurs, dem Heikin Ashi-Eröffnungskurs und dem tatsächlichen Tief der Periode ausgewählt wird:

Dieser Ansatz wahrt die Konsistenz mit den Glättungsmethoden und garantiert gleichzeitig, dass das Heikin Ashi Tief den Tief der Kursschwankung erfasst. Der Heikin Ashi beseitigt geringfügige Schwankungen und vermittelt mit Hilfe dieser Berechnungen ein genaueres Bild der Marktrichtung. Wir werden diese Überlegungen nutzen, um im folgenden Teil unseren eigenen Heikin Ashi-Indikator in MQL5 zu konstruieren.

1.2. Vorteile der Verwendung von Heikin Ashi

Der Heikin Ashi-Indikator ist bei Händlern sehr beliebt, da er kleine Kursschwankungen eliminieren kann und das Erkennen von Trends wesentlich vereinfacht. Herkömmliche Kerzen-Charte sind aufgrund ihrer schnellen Farbwechsel schwer zu lesen und lassen Händler häufig im Unklaren darüber, ob der Markt aufwärts oder abwärts tendiert. Durch die Verwendung gemittelter Kursdaten zur Glättung des Charts behebt Heikin Ashi dieses Problem und hilft Ihnen, sich nicht in Details zu verzetteln.

Eine Reihe roter Kerzen deutet auf einen Abwärtstrend hin, während eine Reihe grüner Kerzen typischerweise auf einen starken Aufwärtstrend hinweist. Aufgrund dieser Klarheit ist es einfacher, zwischen realen, langfristigen Marktveränderungen und kurzfristigen Einbrüchen zu unterscheiden.  Heikin Ashi hilft Ihnen, Fehlsignale zu vermeiden und unnötige, durch kurzfristige Kursschwankungen verursachte Handelsgeschäfte zu verhindern. Durch die Verwendung historischer Daten wird das Marktrauschen herausgefiltert, was eine zuverlässigere Trendbestätigung ermöglicht. Viele Händler kombinieren ihn mit Tools wie RSI oder gleitenden Durchschnitten, um ihre Strategien zu verbessern. Mit seiner klareren Sicht auf die Kursentwicklung erleichtert der Heikin Ashi die Entscheidung, wann man in den Handel einsteigen oder ihn beenden sollte.

1.3. Implementierung von Heikin Ashi in MQL5

Die Implementierung des Heikin Ashi-Indikators in MQL5 ist der nächste Schritt, nachdem Sie seine Funktionsweise kennengelernt haben. Wir werden unseren eigenen Heikin Ashi-Indikator von Grund auf neu erstellen, da MetaTrader 5 keinen solchen Indikator hat. Dazu müssen die Heikin-Ashi-Formeln kodiert und auf die Kursdaten angewandt werden, und die Indikation muss auf dem Chart angezeigt werden.

Wie üblich beginnt die Entwicklung eines Programms mit dem Entwurf eines Pseudocodes, der die Logik skizziert, bevor wir mit dem Schreiben von Code beginnen. Dies garantiert, dass wir jede Phase vor der Umsetzung des Programms verstehen und hilft uns, es angemessen zu strukturieren.

Pseudocode:

EINRICHTEN DES INDIKATORS

• Stelle den Indikator so ein, dass er in einem separaten Chart-Fenster dargestellt wird.
• Stelle Zeichnungsdarstellung für Heikin Ashi-Kerzen ein.
• Definiere 4 Puffer zum Speichern von Heikin Ashi-Werten (Open, High, Low, Close).

DEFINIEREN DER PFUFFER

Erstelle folgende Puffer, um die berechneten Werte zu speichern:

• Die Eröffnungskurse der Heikin Ashi
• Die Hochs der Heikin Ashi
• Die Tiefs der Heikin Ashi
• Die Schlusskurse der Heikin Ashi

BERECHNEN DER HEIKIN-ASHI-WERTE 

In einer Schleife gehen wir durch die historischen Kursdaten, um die Heikin Ashi-Werte anhand der folgenden Formeln zu berechnen:

• HA Close = (Open + High + Low + Close) / 4
  
• HA Open = (vorheriges HA Open + vorheriges HA Close) / 2
  
• HA High = Maximum aus (High, HA Open, HA Close)
  
• HA Low = Minimum aus (Low, HA Open, HA Close)
  

1.3.1. Heikin Ashi erstellen und anpassen

Nachdem wir den Pseudocode erstellt haben, können wir nun mit der Programmierung fortfahren. Wie im letzten Artikel beschrieben, besteht der erste Schritt beim Entwerfen und Ändern einer Anzeige darin, sich vorzustellen, wie sie auf der Chart aussehen soll. Die Darstellung des Indikators, die Anzeige der Heikin Ashi-Kerzen und die Einbeziehung anderer Komponenten, wie z. B. Farben für Aufwärts- und Abwärtstrends, sollten vor der Erstellung des Codes festgelegt werden.

Wir müssen sicherstellen, dass unser nutzerdefinierter Indikator die normalen Kerzen-Charts durch seine eigenen berechneten Werte ersetzt, da Heikin Ashi das Erscheinungsbild der Kerzen verändert. Dazu müssen Puffer für den Eröffnungs-, Höchst-, Tiefst- und Schlusskurs eingerichtet und die Farben dynamisch geändert werden, um sowohl Abwärts- als auch Aufwärts-Trends anzuzeigen. Sobald wir diese klare Visualisierung haben, können wir die Struktur des Indikators festlegen und mit dem Schreiben des Codes beginnen. Wir müssen die Eigenschaftseinstellungen des Heikin Ashi-Indikators definieren, bevor wir seine Logik anwenden können. Diese Parameter bestimmen den Stil der gezeichneten Elemente (z. B. Heikin Ashi-Kerzen), die Anzahl der Puffer, die der Indikator verwendet, und die Art und Weise, wie die Anzeige auf dem Chart erscheinen soll.

Beispiel:

// PROPERTY SETTINGS
#property indicator_separate_window
#property indicator_buffers 5
#property indicator_plots   1

// PLOT SETTINGS FOR HEIKIN ASHI CANDLES
#property indicator_label1  "Heikin Ashi"
#property indicator_type1   DRAW_COLOR_CANDLES
#property indicator_color1  clrGreen, clrRed
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1

Erläuterung:

Eigenschaftseinstellungen

#property indicator_separate_window

Dies weist MetaTrader 5 an, dass der Indikator nicht im Hauptchart, sondern in einem anderen Fenster angezeigt werden soll. Diese Zeile würde entfernt werden, wenn wir wollen, dass sie auf dem Preischart gerade angezeigt wird.

Analogie

Betrachten Sie Ihr Handels-Chart als einen Arbeitsplatz, an dem Sie die Veränderungen des Marktes untersuchen. Die wichtigsten Instrumente, wie z. B. Kurskerzen und herkömmliche Indikatoren, werden auf dem Hauptchart platziert, das ähnlich wie eine Tischplatte funktioniert. Stellen Sie sich vor, Sie arbeiten an einem akribischen Nebenprojekt, das einen bestimmten Bereich benötigt, z. B. ein kleines Whiteboard neben Ihrem Schreibtisch. Wenn Sie diese Tätigkeit auf das Whiteboard verlagern, können Sie sich unabhängig davon darauf konzentrieren, anstatt den Hauptarbeitsbereich zu verstopfen.

In ähnlicher Weise vereinfacht #property indicator_separate_window die Untersuchung von Trends, ohne die Standard-Kerzen-Daten zu beeinträchtigen, indem der Heikin-Ashi-Indikator in ein eigenes Fenster verschoben wird, anstatt ihn in das Hauptpreischart einzublenden.

#property indicator_buffers 5

Hier wird angegeben, wie viele Puffer der Indikator verwenden soll. In diesem Fall werden fünf Puffer verwendet, einer für die Farbdarstellung und der andere für die Speicherung der berechneten Heikin Ashi-Werte (Open, High, Low und Close).

Analogie

Jetzt, wo Sie ein anderes Whiteboard neben Ihrer Werkbank für Ihr Nebenprojekt haben, stellen Sie sich vor, Sie bräuchten fünf verschiedene Ablagen, um den Überblick über Ihre Arbeit zu behalten. Skizzen, Messungen, Notizen usw. werden in verschiedenen Fächern aufbewahrt. So bleibt alles übersichtlich, und Sie können bei Bedarf schnell auf die relevanten Informationen zugreifen.

Ähnlich wie bei diesen Fächern sorgt #property indicator_buffers 5 dafür, dass verschiedene Heikin-Ashi-Datenpunkte auseinander gehalten werden. Hier haben wir fünf Puffer: einen für die Farbdarstellung und vier für die Heikin Ashi-Werte (Open, High, Low und Close). Diese Puffer sorgen dafür, dass die Berechnungen des Indikators strukturiert sind, was die Anzeige der richtigen Daten im Chart vereinfacht, ähnlich wie die Ablagefächer Ihren Arbeitsbereich in Ordnung halten.

#property indicator_plots 1

Hier wird angegeben, wie viele Charte der Indikator anzeigen soll. Wir benötigen nur ein Chart, da wir die Heikin Ashi-Kerzen als eine einzige Einheit darstellen.

Analogie

Nachdem Sie Ihre Materialien in verschiedenen Fächern angeordnet und Ihren Whiteboard-Arbeitsplatz eingerichtet haben, müssen Sie im nächsten Schritt entscheiden, wie Sie Ihre Arbeit ausstellen wollen. Anstatt mehrere verschiedene Charte zu erstellen, sollten Sie sich ein einziges, umfassendes Chart vorstellen, das alle Daten in einer einzigen, verständlichen visuellen Darstellung zusammenfasst.

Ebenso wird MetaTrader 5 durch #property indicator_plots 1 informiert, dass der Heikin Ashi-Indikator als einzelnes gezeichnetes Element angezeigt wird. Ähnlich wie bei Ihrem einzelnen Chart auf dem Whiteboard enthalten mehrere Puffer unterschiedliche Daten (Open, High, Low, Close und Farbe), die jedoch alle zusammen einen einzigen Satz von Kerzen ergeben. Wir brauchen nur ein Chart, um die Heikin Ashi-Kerzen auf dem Chart darzustellen, da wir nur diese aufzeichnen.

Plot-Einstellungen

#property indicator_label1  "Heikin Ashi"
#property indicator_type1   DRAW_COLOR_CANDLES  
#property indicator_color1  clrGreen, clrRed    
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1

Analogie

Nachdem Sie Ihre Materialien zusammengestellt und Ihren Whiteboard-Arbeitsplatz eingerichtet haben, ist es wichtig, dass Sie Ihre Ergebnisse klar und verständlich vermitteln. Um Trends deutlicher zu machen, verwenden Sie farblich gekennzeichnete Symbole, anstatt reinen Text zu schreiben oder abstrakte Muster zu entwerfen. Sie identifizieren eindeutig, was Ihr Chart symbolisiert, indem Sie es mit „Heikin Ashi“ für jeden, der das Whiteboard beobachtet, beschriften. Auf die gleiche Weise gibt #property indicator_label1 „Heikin Ashi“ dem Indikator einen Namen und garantiert, dass er in der Indikationsliste von MetaTrader 5 auftaucht. Auf diese Weise können Händler ihn inmitten anderer Indikatoren schnell auf ihren Charts erkennen.

#property indicator_type1 DRAW_COLOR_CANDLES weist MetaTrader 5 an, farbcodierte Kerzen anstelle von Linien oder Histogrammen zu verwenden. Die Farben werden durch #property indicator_color1 clrGreen, clrRed definiert, wobei grün für Aufwärtskerzen und rot für Abwärtskerzen steht. Diese visuelle Klarheit macht es einfacher, Trends auf einen Blick zu erkennen. Damit Ihr Whiteboard übersichtlich und gut lesbar bleibt, entscheiden Sie sich für einen durchgehenden anstelle von gestrichelten oder gepunkteten Linien.

In ähnlicher Weise sorgt #property indicator_style1 STYLE_SOLID dafür, dass die Heikin Ashi Kerzen mit einer Volltonfarbe gefüllt werden, wodurch sie sich visuell deutlich abheben. Genauso wie Sie es vermeiden, Ihre Linien zu dick zu machen, damit sie Ihr Chart nicht überladen, hält #property indicator_width1 1 die Kerzenumrisse in einer angemessenen Breite, um die Übersichtlichkeit zu gewährleisten, ohne das Chart zu überladen. Indem wir den Heikin Ashi-Indikator auf diese Weise einrichten, schaffen wir eine klare, strukturierte und visuell intuitive Darstellung der Markttrends, so wie Sie es mit Ihrem gut organisierten Whiteboard-Arbeitsbereich getan haben.

Nachdem wir nun die Eigenschaften des Indikators und die Plot-Einstellungen festgelegt haben, müssen wir als Nächstes die Puffer definieren, in denen die Heikin Ashi-Kerzenkurse gespeichert werden. Puffer dienen als Speicherbehälter für die berechneten Werte des Indikators, sodass MetaTrader 5 sie auf dem Chart anzeigen kann. In diesem Fall benötigen wir Puffer zum Speichern der Heikin Ashi Open-, High-, Low- und Close-Kurse sowie einen zusätzlichen Puffer für die Farbdarstellung. Wir werden auch ihre jeweiligen Pufferindizes festlegen, um sicherzustellen, dass jeder Puffer korrekt den vorgesehenen Daten entspricht.

Beispiel:

// PROPERTY SETTINGS
#property indicator_separate_window
#property indicator_buffers 5
#property indicator_plots   1

// PLOT SETTINGS FOR HEIKIN ASHI CANDLES
#property indicator_label1  "Heikin Ashi"
#property indicator_type1   DRAW_COLOR_CANDLES
#property indicator_color1  clrGreen, clrRed
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1

// INDICATOR BUFFERS
double HA_Open[];
double HA_High[];
double HA_Low[];
double HA_Close[];
double ColorBuffer[];

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
// SET BUFFERS
   SetIndexBuffer(0, HA_Open, INDICATOR_DATA);
   SetIndexBuffer(1, HA_High, INDICATOR_DATA);
   SetIndexBuffer(2, HA_Low, INDICATOR_DATA);
   SetIndexBuffer(3, HA_Close, INDICATOR_DATA);
   SetIndexBuffer(4, ColorBuffer, INDICATOR_COLOR_INDEX);

   return INIT_SUCCEEDED;
  }

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {

   return(rates_total);

  }

Erläuterung:

Wir erstellen Arrays (Puffer), die die Eröffnungs-, Höchst-, Tiefst- und Schlusskurse der modifizierten Kerzen speichern, um die berechneten Werte des Heikin Ashi-Indikators zu speichern. Wir steuern auch die Farbe jeder Kerze mit einem anderen Puffer.

double HA_Open[];
double HA_High[];
double HA_Low[];
double HA_Close[];
double ColorBuffer[];

Der HA_Open[]-Puffer enthält den Heikin Ashi-Eröffnungskurs jeder Kerze, während HA_High[] den Höchstkurs der Heikin Ashi-Kerze enthält. In ähnlicher Weise wird der Schlusskurs der Heikin Ashi-Kerze in HA_Close[] gespeichert, während der niedrigste Kurs in HA_Low[] erfasst wird. Zusätzlich wird der ColorBuffer[] verwendet, um die Farbe jeder Kerze zu bestimmen, um zwischen Aufwärtskerzen (grün) und Abwärtskerzen (rot) zu unterscheiden. Dank der Zusammenarbeit dieser Puffer kann der Chart die aktualisierten Heikin Ashi Kerzen speichern und anzeigen.

SetIndexBuffer(0, HA_Open, INDICATOR_DATA);
SetIndexBuffer(1, HA_High, INDICATOR_DATA);
SetIndexBuffer(2, HA_Low, INDICATOR_DATA);
SetIndexBuffer(3, HA_Close, INDICATOR_DATA);
SetIndexBuffer(4, ColorBuffer, INDICATOR_COLOR_INDEX);     

Die Funktion SetIndexBuffer im MetaTrader 5 verknüpft bestimmte Puffer mit den entsprechenden Indizes und stellt damit sicher, dass Heikin Ashi-Daten korrekt verarbeitet und angezeigt werden. Gemäß der Kerzen-Struktur der Plattform wird der Eröffnungskurs immer dem Index 0 zugeordnet, und die Werte für Hoch, Tief und Schluss werden den Indizes 1, 2 und 3 zugeordnet. Ohne eine ordnungsgemäße Indexierung erkennt MetaTrader 5 die Daten möglicherweise nicht als legitime Kerzen was zu fehlenden Chart-Elementen oder Darstellungsproblemen führen kann.

SetIndexBuffer(4, ColorBuffer, INDICATOR_COLOR_INDEX) gibt die Farbe jeder Kerze an, die steigende (grün) oder fallende (rot) Bewegungen anzeigt, um Trends visuell zu unterscheiden. Der Heikin Ashi-Indikator garantiert eine korrekte Kursdarstellung und visuelle Gestaltung, indem sie diese Puffer angemessen indiziert, sodass Händler Trends schnell analysieren und fundierte Entscheidungen treffen können.

Nach der Konfiguration der Indikatoreigenschaften, der Definition von Puffern und der Verknüpfung mit den entsprechenden Indizes müssen nun die Berechnungen durchgeführt werden, die die Heikin Ashi-Werte ergeben.

Beispiel:

// PROPERTY SETTINGS
#property indicator_separate_window
#property indicator_buffers 5
#property indicator_plots   1

// PLOT SETTINGS FOR HEIKIN ASHI CANDLES
#property indicator_label1  "Heikin Ashi"
#property indicator_type1   DRAW_COLOR_CANDLES
#property indicator_color1  clrGreen, clrRed
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1

// INDICATOR BUFFERS
double HA_Open[];
double HA_High[];
double HA_Low[];
double HA_Close[];
double ColorBuffer[];

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
// SET BUFFERS
   SetIndexBuffer(0, HA_Open, INDICATOR_DATA);
   SetIndexBuffer(1, HA_High, INDICATOR_DATA);
   SetIndexBuffer(2, HA_Low, INDICATOR_DATA);
   SetIndexBuffer(3, HA_Close, INDICATOR_DATA);
   SetIndexBuffer(4, ColorBuffer, INDICATOR_COLOR_INDEX);

   return INIT_SUCCEEDED;
  }

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {

   if(rates_total < 2)
      return 0; // ENSURE ENOUGH DATA

   for(int i = 1; i < rates_total; i++)  // START FROM SECOND BAR
     {
      // HEIKIN ASHI CLOSE FORMULA
      HA_Close[i] = (open[i] + high[i] + low[i] + close[i]) / 4.0;

      // HEIKIN ASHI OPEN FORMULA
      HA_Open[i] = (HA_Open[i - 1] + HA_Close[i - 1]) / 2.0;

      // HEIKIN ASHI HIGH FORMULA
      HA_High[i] = MathMax(high[i], MathMax(HA_Open[i], HA_Close[i]));

      // HEIKIN ASHI LOW FORMULA
      HA_Low[i] = MathMin(low[i], MathMin(HA_Open[i], HA_Close[i]));

      // SET COLOR: GREEN FOR BULLISH, RED FOR BEARISH
      ColorBuffer[i] = (HA_Close[i] >= HA_Open[i]) ? 0 : 1;
     }

   return(rates_total);

  }

Da der erste Balken keine vorherigen Daten enthält, berechnet diese Methode die Heikin Ashi-Werte ab dem zweiten Balken. Um Kursschwankungen zu glätten, ist der Schlusskurs der Mittelwert aus dem Eröffnungs-, Hoch-, Tief- und Schlusskurs des aktuellen Balkens. Der Eröffnungskurs sorgt für nahtlose Übergänge, indem er den Durchschnitt von Heikin Ashi Open und Close des vorherigen Balkens bildet. Der Höchst-/Tiefstwert des aktuellen Balkens und der Heikin Ashi Eröffnungs-/Schlusswert sind die höchsten und niedrigsten Werte, aus denen die Höchst- und Tiefstpreise berechnet werden. Schließlich werden die Kerzen rot (abwärts) eingefärbt, wenn der Schlusskurs kleiner oder gleich dem Eröffnungskurs ist, oder grün (aufwärts), wenn der Schlusskurs kleiner oder gleich dem Eröffnungskurs ist. Dies hilft den Händlern, Trends zu erkennen, indem es das Marktrauschen reduziert.

2. Erstellen eines gleitenden Durchschnitts aus Heikin Ashi-Daten

Nachdem wir nun erfolgreich Heikin Ashi-Kerzen generiert haben, besteht der nächste Schritt darin, einen gleitenden Durchschnitt (MA) zu erstellen, der auf den Heikin Ashi-Werten anstelle von Standardkursdaten basiert.

Pseudocode:

ÄNDERN DER INDIKATOREIGENSCHAFTEN

• Ändere die Anzahl der Puffer von fünf auf sechs, um Platz für den gleitenden Durchschnitt Heikin Ashi zu schaffen. 

• Ändere die Anzahl der „plots“ von 1 auf 2, damit die Kerzen und der gleitende Heikin Ashi-Durchschnitt zusammen angezeigt werden können.

PUFFER FÜR GLEITENDEN HEIKIN-ASHI-DURCHSCHNITT DEFINIEREN

• Erstelle einen Puffer zum Speichern der Werte des gleitenden Heikin Ashi-Durchschnitts.
• Definiere eine Eingangsvariable für die Periode des gleitenden Durchschnitts (z.B. 20).

FESTLEGEN DER PUFFER FÜR DEN GLEITENDEN DURCHSCHNITT DES HEIKIN-ASHI

• Verknüpfe den Puffer mit einem Index, um berechnete MA-Werte zu speichern.
• Stelle den Index „Plot“ so ein, dass er mit der Periode des gleitenden Durchschnitts beginnt, um eine korrekte Anzeige zu gewährleisten.

BERECHNEN DES HEIKIN ASHI GLEITENDER DURCHSCHNITTS

• Beginne die Schleife ab (Periode - 1), um genügend Datenpunkte zu erhalten.
• Berechne die Summe der letzten „n“ Heikin Ashi Close-Werte.
• Teile die Summe durch die Periode und speichern Sie das Ergebnis im Puffer.

Beispiel:

// PROPERTY SETTINGS
#property indicator_separate_window
#property indicator_buffers 6
#property indicator_plots   2

// PLOT SETTINGS FOR HEIKIN ASHI CANDLES
#property indicator_label1  "Heikin Ashi"
#property indicator_type1   DRAW_COLOR_CANDLES  
#property indicator_color1  clrGreen, clrRed    
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1

//PROPERTIES OF THE Heikin MA
#property indicator_label2  "Heikin MA"   
#property indicator_type2   DRAW_LINE  
#property indicator_style2  STYLE_DASH 
#property indicator_width2  1          
#property indicator_color2  clrBrown   

// INDICATOR BUFFERS
double HA_Open[];
double HA_High[];
double HA_Low[];
double HA_Close[];
double ColorBuffer[]; 

double Heikin_MA_Buffer[];
int input  heikin_ma_period = 20;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
    // SET BUFFERS
    SetIndexBuffer(0, HA_Open, INDICATOR_DATA);
    SetIndexBuffer(1, HA_High, INDICATOR_DATA);
    SetIndexBuffer(2, HA_Low, INDICATOR_DATA);
    SetIndexBuffer(3, HA_Close, INDICATOR_DATA);
    SetIndexBuffer(4, ColorBuffer, INDICATOR_COLOR_INDEX);
    
    SetIndexBuffer(5, Heikin_MA_Buffer, INDICATOR_DATA);  
    PlotIndexSetInteger(5, PLOT_DRAW_BEGIN, heikin_ma_period);
     
    return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
{
    if (rates_total < 2) return 0; // ENSURE ENOUGH DATA
      
    for (int i = 1; i < rates_total; i++) // START FROM SECOND BAR
    {
        // HEIKIN ASHI CLOSE FORMULA
        HA_Close[i] = (open[i] + high[i] + low[i] + close[i]) / 4.0;

        // HEIKIN ASHI OPEN FORMULA
        HA_Open[i] = (HA_Open[i - 1] + HA_Close[i - 1]) / 2.0;

        // HEIKIN ASHI HIGH FORMULA
        HA_High[i] = MathMax(high[i], MathMax(HA_Open[i], HA_Close[i]));

        // HEIKIN ASHI LOW FORMULA
        HA_Low[i] = MathMin(low[i], MathMin(HA_Open[i], HA_Close[i]));

        // SET COLOR: GREEN FOR BULLISH, RED FOR BEARISH
        ColorBuffer[i] = (HA_Close[i] >= HA_Open[i]) ? 0 : 1;
    }    
    
     for(int i = heikin_ma_period - 1; i < rates_total; i++)
     {

      double sum = 0.0;
      for(int j = 0; j < heikin_ma_period; j++)
        {
         sum += HA_Close[i - j];
        }

      Heikin_MA_Buffer[i] = sum / heikin_ma_period;

     }

    return rates_total;
}

Erläuterung:

Zunächst müssen wir die Puffer- und Plot-Einstellungen ändern, um den Heikin Ashi Moving Average (HA MA) in den Indikator zu integrieren. Mit #property indicator_buffers 6 wird die Anzahl der Puffer von 5 auf 6 erhöht, um sicherzustellen, dass ein freier Puffer für die Heikin-MA-Daten vorhanden ist. Die Heikin Ashi-Kerzen und der Heikin MA können beide auf dem Chart angezeigt werden, indem Sie #property indicator_plots 2 verwenden, um die Anzahl der Plots von 1 auf 2 zu ändern. Dadurch wird gewährleistet, dass der Indikator beide Datensätze effektiv verarbeiten kann.

Die Eigenschaften des Heikin-MA-Plots werden dann konfiguriert. #property indicator_label2 ist die Kennzeichnung. Durch die Kennzeichnung des gleitenden Durchschnitts mit „Heikin MA“ wird er in der Liste der Indikatoren sichtbar. Um festzulegen, dass der gleitende Durchschnitt als Linie anstelle von Kerzen angezeigt werden soll, wird der Typ mit #property indicator_type2 DRAW_LINE festgelegt. Wir setzen #property indicator_style2 STYLE_DASH, um die Linie gestrichelt darzustellen, und verwenden #property indicator_width2 1, um ihre Breite zu bestimmen, damit sie besser sichtbar ist. Mit #property indicator_color2 clrBrown wird die Farbe auf braun gesetzt, was einen starken Kontrast zu den Heikin Ashi-Kerzen garantiert.

Nach dem Festlegen der Eigenschaften definieren wir einen Eingabeparameter int input heikin_ma_period = 20;, mit dem der Nutzer die Periode ändern kann, und deklarieren ein Array double Heikin_MA_Buffer[]; zur Aufnahme der gleitenden Durchschnittsdaten. SetIndexBuffer(5, Heikin_MA_Buffer, INDICATOR_DATA); wird verwendet, um den Puffer mit dem Indikator zu verknüpfen, damit MetaTrader 5 die Werte entsprechend verwalten und anzeigen kann. PlotIndexSetInteger(5, PLOT_DRAW_BEGIN, heikin_ma_period); garantiert auch, dass der gleitende Durchschnitt erst dann gezeichnet wird, wenn genügend Balken vorhanden sind.

Die Berechnung des gleitenden Heikin Ashi-Durchschnitts ist der letzte Schritt. Um sicherzustellen, dass wir genügend Datenpunkte für die Berechnung haben, beginnt die Schleife bei heikin_ma_period -1. Der gleitende Durchschnitt wird innerhalb der Schleife berechnet, indem die letzten n Heikin Ashi Close-Werte addiert und die Summe durch die Periode geteilt wird. Der Indikator stellt dann den gleitenden Durchschnitt zusammen mit den Heikin Ashi-Kerzen dar, nachdem er das Ergebnis in Heikin_MA_Buffer[i] gespeichert hat, und bietet Händlern ein geglättetes Trendfolge-Tool.

3. Integrieren eines nutzerdefinierten Indikators in einen Expert Advisor

Vielleicht fragen Sie sich jetzt, nachdem wir einen nutzerdefinierten Indikator erstellt haben, wie wir ihn zur Erstellung eines Expert Advisors verwenden können. Unter Verwendung der Heikin Ashi-Indikation, die im vorherigen Kapitel erstellt wurde, werden wir in diesem Kapitel unseren projektbasierten Ansatz fortsetzen und einen EA entwerfen. Unsere Technik wird dank der Verwendung von Heikin Ashi-Signalen zur Automatisierung von Handelsentscheidungen als funktionierender Trading-Bot umgesetzt.

Unsere Handelsstrategie basiert auf einer einfachen Kreuz-Strategie, die auf dem gleitenden Heikin Ashi-Durchschnitt (HA MA) und Heikin Ashi-Kerzen (HA) basiert. Diese Technik hilft bei der Identifizierung einer potenziellen Trendumkehr und Trendfortsetzung, indem sie die Beziehung zwischen dem Schlusskursen der Heikin Ashi-Kerzen und dem gleitenden Heikin Ashi-Durchschnitt betrachtet. Ein Aufwärtstrend und eine potenzielle Kaufgelegenheit werden durch eine Heikin Ashi Kerze angezeigt, die über dem gleitenden Heikin Ashi Durchschnitt schließt. Umgekehrt erzeugt eine Heikin-Ashi-Kerze, die unterhalb des gleitenden Heikin-Ashi-Durchschnitts schließt, ein Verkaufssignal, das auf eine rückläufige Trendumkehr und eine mögliche Verkaufsmöglichkeit hindeutet.

3.1. Abrufen der Indikatordaten

Wenn Sie einen nutzerdefinierten Indikator in einen EA integrieren, sollten Sie sich zunächst Gedanken darüber machen, wie Sie die Daten des Indikators in Ihren EA eingeben. Der EA ist nicht in der Lage, Handelsentscheidungen auf der Grundlage des Indikators zu treffen, wenn seine Werte unzugänglich sind. Zum Beispiel müssen die vier Werte, die eine Heikin Ashi-Kerze ausmachen, in unsere Heikin Ashi Moving Average Kreuz-Strategie importiert werden:

• HA Eröffnungspreis
• HA Hoch
• HA Tief
• HA Schlusskurs

Unsere Handelssignale basieren auf diesen Parametern, anhand derer wir beurteilen, ob eine Heikin Ashi-Kerze den HA MA über- oder unterschritten hat.

Beispiel:

// Declare arrays to store Heikin Ashi data from the custom indicator
double heikin_open[];   // Stores Heikin Ashi Open prices
double heikin_close[];  // Stores Heikin Ashi Close prices
double heikin_low[];    // Stores Heikin Ashi Low prices
double heikin_high[];   // Stores Heikin Ashi High prices
double heikin_ma[];     // Stores Heikin Ashi Moving Average values

int heikin_handle;      // Handle for the custom Heikin Ashi indicator

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
// Ensure arrays store data in a time series format (most recent data first)
   ArraySetAsSeries(heikin_open, true);
   ArraySetAsSeries(heikin_close, true);
   ArraySetAsSeries(heikin_low, true);
   ArraySetAsSeries(heikin_high, true);
   ArraySetAsSeries(heikin_ma, true);

// Load the custom Heikin Ashi indicator and get its handle
   heikin_handle = iCustom(_Symbol, PERIOD_CURRENT, "Project7 Heikin Ashi Indicator.ex5");

   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
// Nothing to clean up in this case, but can be used for resource management if needed
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
// Copy the latest 3 values of each buffer from the Heikin Ashi indicator
   CopyBuffer(heikin_handle, 0, 0, 3, heikin_open);  // Get HA Open values
   CopyBuffer(heikin_handle, 1, 0, 3, heikin_high);  // Get HA High values
   CopyBuffer(heikin_handle, 2, 0, 3, heikin_low);   // Get HA Low values
   CopyBuffer(heikin_handle, 3, 0, 3, heikin_close); // Get HA Close values
   CopyBuffer(heikin_handle, 5, 0, 3, heikin_ma);    // Get HA Moving Average values

// Print index 0 values to the terminal
   Print("HA Open: ", heikin_open[0],
         "\nHA High: ", heikin_high[0],
         "\nHA Low: ", heikin_low[0],
         "\nHA Close: ", heikin_close[0],
         "\nHA MA: ", heikin_ma[0]);
  }

Erläuterung:

Deklarieren von Arrays zum Speichern von Heikin Ashi-Daten

Die Deklaration von Arrays zur Aufnahme der vom Indikator gesammelten Daten ist der erste Schritt zur Integration eines nutzerdefinierten Indikators in einen Expert Advisor (EA). In dieser Instanz werden fünf Arrays deklariert, um die verschiedenen Komponenten des Heikin Ashi-Indikators zu speichern:

• heikin_open[]: Speichert die Eröffnungspreise der Heikin Ashi.
• heikin_close[]: Speichert die Schlusskurse der Heikin Ashi.
• heikin_low[]: Speichert die Tiefs der Heikin Ashi.
• heikin_high[]: Speichert die Hochs der Heikin Ashi.
• heikin_ma[]: Speichert die Werte des gleitenden Durchschnitts der Heikin Ashi.

Da sie dem EA Zugriff auf vergangene und aktuelle Heikin Ashi-Werte geben, sind diese Arrays von entscheidender Bedeutung. Der EA kann historische Kursbewegungen auswerten und Handelsentscheidungen anpassen, indem er diese Daten speichert. Diese Arrays müssen nicht mit festen Werten initialisiert werden, da sie mit Daten aus dem nutzerdefinierten Indikator aufgefüllt werden; stattdessen werden sie dynamisch aktualisiert, wenn neue Daten verfügbar werden.

Deklaration des Indikator-Handles

Das Handle des angepassten Heikin Ashi-Indikators wird in der Variablen heikin_handle gespeichert. Ein Handle in MQL5 ist ein eindeutiger Verweis auf eine im Hintergrund laufende Indikatorinstanz. Da es dem EA ermöglicht, mit dem Indikator zu interagieren und bei Bedarf Daten anzufordern, ist dieses Handle unerlässlich. Ohne einen Handle hätte der EA keinen Zugriff auf die Heikin Ashi-Werte. Später, wenn die Funktion iCustom() ausgeführt wird, wird dem Handle ein Wert zugewiesen. Der Indikator wurde nicht korrekt geladen, wenn das Handle ungültig ist (gibt -1 zurück), was den EA daran hindert, die erforderlichen Daten abzurufen.

Array-Initialisierung im Zeitreihenformat

Die Arrays müssen so konstruiert sein, dass die neuesten Daten bei ihrer Deklaration immer auf Index 0 stehen. Hierfür wird die Funktion ArraySetAsSeries() verwendet, die die Array-Komponenten in absteigender Reihenfolge anordnet, sodass die neuesten Daten zuerst gespeichert werden.

Die Funktion wird auf jedes der fünf Arrays wie folgt angewendet:

 ArraySetAsSeries(heikin_open, true);
 ArraySetAsSeries(heikin_close, true);
 ArraySetAsSeries(heikin_low, true);
 ArraySetAsSeries(heikin_high, true);
 ArraySetAsSeries(heikin_ma, true);

Durch die Konvertierung dieser Arrays in ein Zeitreihenformat ermöglicht der Index 0 dem EA, immer auf die aktuellsten Heikin Ashi-Daten zuzugreifen. Bei der Umsetzung von Handelstechniken in die Praxis ist dies besonders hilfreich, da es garantiert, dass der EA auf aktuelle Marktbewegungen und nicht auf historische Daten reagiert.

Laden des nutzerdefinierten Heikin Ashi-Indikators mit iCustom()

Wir benötigen eine Möglichkeit, auf die Daten zuzugreifen, um einen nutzerdefinierten Indikator in einen Expert Advisor (EA) einzubinden. Wir können mit der Funktion iCustom() einen nutzerdefinierten Indikator laden und ein Handle erhalten, das der EA verwenden kann, um Indikatorwerte abzufragen. Ohne dieses Handle kann der EA nicht auf die Daten des Indikators zugreifen.

heikin_handle = iCustom(_Symbol, PERIOD_CURRENT, "Project7 Heikin Ashi Indicator.ex5");

• _Symbol: Damit wird die Funktion angewiesen, den Indikator auf das aktuelle Handelssymbol anzuwenden (z.B. EUR/USD, GBP/JPY, etc.). Dadurch wird sichergestellt, dass der Indikator Daten für denselben Vermögenswert verarbeitet, auf dem der EA läuft.
• PERIOD_CURRENT: Dadurch wird der Indikator auf denselben Zeitrahmen wie der EA angewendet. Wenn der EA auf einem H1-Chart läuft, wird der Indikator auch auf H1 angewendet.
• "Project7 Heikin Ashi Indicator.ex5": Hier wird der Dateiname des nutzerdefinierten Indikators angegeben, den der EA verwenden soll. Die Erweiterung .ex5 zeigt an, dass es sich um eine kompilierte MQL5-Indikator-Datei handelt.

Stellen Sie sicher, dass die Indikator-Datei im entsprechenden MetaTrader 5-Verzeichnis gespeichert ist. Der Indikator muss sich im Ordner Indicators des MQL5-Verzeichnisses befinden. Der gesamte Pfad dieses Verzeichnisses lautet:

MQL5/Indicators/

Die Hauptfunktion, die einen nutzerdefinierten Indikator mit einem EA verbindet, ist iCustom(), um es kurz zu machen. Sie übergibt dem EA einen Handle, der die dynamische Extraktion von Indikatorwerten ermöglicht. Die Funktion funktioniert nur dann richtig, wenn der Indikator im Verzeichnis Indicators (oder einem Unterordner darin) abgelegt ist.

Kopieren von Indikatordaten in die Arrays

Nachdem der EA den Handle erhalten hat, kann er mit der Funktion CopyBuffer() die letzten Heikin Ashi-Werte aus dem Indikator abrufen. Die Daten werden mit der Funktion CopyBuffer() aus den internen Puffern eines Indikators in die Arrays des EA kopiert. Dieser EA ruft die Methode fünfmal auf, einmal für jedes Datenelement:

CopyBuffer(heikin_handle, 0, 0, 3, heikin_open);  // Get HA Open values
CopyBuffer(heikin_handle, 1, 0, 3, heikin_high);  // Get HA High values
CopyBuffer(heikin_handle, 2, 0, 3, heikin_low);   // Get HA Low values
CopyBuffer(heikin_handle, 3, 0, 3, heikin_close); // Get HA Close values
CopyBuffer(heikin_handle, 5, 0, 3, heikin_ma);    // Get HA Moving Average values

Die Daten werden aus dem nutzerdefinierten Indikator abgerufen, wobei bei jedem Aufruf von CopyBuffer() die gleiche Struktur verwendet wird. Der von der Funktion iCustom() abgerufene Handle ist der erste Parameter, heikin_handle. Der EA kann auf die Daten des nutzerdefinierten Heikin Ashi-Indikators zugreifen, indem er dieses Handle als Referenz verwendet. Ohne dieses Handle kann der EA keine Indikatorwerte abfragen. Die Pufferindizes für die verschiedenen Komponenten des Heikin Ashi-Indikators werden durch die folgenden Parameter (0, 1, 2, 3, 5) dargestellt. In MQL5 verwenden Indikatoren Puffer, um ihre Daten zu speichern, und jedem Puffer wird ein eindeutiger Index zugewiesen. Die Heikin Ashi-Eröffnungskurse werden in diesem Fall durch Puffer 0, die Hochs durch Puffer 1, die Tiefs durch Puffer 2, die Schlusskurse durch Puffer 3 und der gleitende Heikin Ashi-Durchschnitt durch Puffer 5 dargestellt. Durch die Bereitstellung dieser Indizes stellen wir sicher, dass die richtigen Daten aus dem Indikator gewonnen werden.

Die Daten sollten beginnend mit dem jüngsten Balken (aktuelle Kerze) dupliziert werden, entsprechend der dritten Option, 0. Dies garantiert, dass der EA immer die aktuellsten Marktdaten verwendet, was für Handelsentscheidungen in Echtzeit notwendig ist. Entsprechend dem vierten Parameter, 3, sind drei Datenpunkte zu replizieren. Die Abfrage mehrerer Werte ermöglicht es dem EA, sowohl historische als auch aktuelle Heikin Ashi-Daten zu untersuchen, was für die Entdeckung von Mustern oder die Validierung von Trends hilfreich ist. 

Schließlich werden die zugehörigen Arrays - heikin_open, heikin_high, heikin_low, heikin_close und heikin_ma - zur Speicherung der wiederhergestellten Daten verwendet. Die abgerufenen Werte werden in diesen Arrays gespeichert, damit der EA sie verarbeiten und in seiner Handelslogik verwenden kann. Damit der EA fundierte Handelsentscheidungen auf der Grundlage von Preistrends treffen kann, ist es unerlässlich, dass er über aktuelle Informationen zum Heikin Ashi-Indikator verfügt.

3.2. Verwendung von Indikatordaten in unserer Handelsstrategie

Nachdem wir gelernt haben, wie man Daten aus dem nutzerdefinierten Indikator extrahiert, müssen wir nun verstehen, wie wir diese Daten auf unsere Handelsstrategie anwenden können. Auf diese Weise können wir den Heikin Ashi-Indikator erfolgreich in einem EA einsetzen und zeigen, wie man Handelsentscheidungen auf der Grundlage der ermittelten Zahlen treffen kann. Darüber hinaus bietet dieses Verfahren die Möglichkeit, bestimmte wichtige MQL5-Ideen zu untersuchen, was unser Verständnis im weiteren Verlauf des Textes verbessert. 

Wir können jedoch nicht einfach die Argumentation anwenden, ohne entscheidende Elemente der EA zu berücksichtigen. Eine ordnungsgemäße Verwaltung des Handels erfordert die Einbeziehung bestimmter Merkmale. Dazu gehören die Überwachung der Anzahl offener Positionen, das Setzen von Trailing-Stops, die Kontrolle von Risikoparametern und die Sicherstellung, dass der EA Handelsgeschäfte methodisch ausführt. Durch die Einbeziehung dieser wesentlichen Elemente schaffen wir ein zuverlässigeres und nützlicheres Handelssystem, das auch in der Praxis gut funktioniert.

3.2.1. Verfolgung offener Kauf- und Verkaufspositionen im Expert Advisor

Wir müssen sicherstellen, dass nur eine Kauf- und eine Verkaufsposition gleichzeitig offen sind, damit die Handelstechnik richtig funktioniert. Dies verringert das unnötige Risiko vieler Positionen in dieselbe Richtung und hilft, die Kontrolle über die Ausführung der Positionen zu behalten. Der EA kann anhand der Anzahl der offenen Positionen entscheiden, ob er eine neue Position aufbaut oder wartet, bis eine bestehende Position geschlossen ist, bevor er eine weitere ausführt. Diese Methode garantiert, dass die Strategie wie geplant funktioniert und verbessert das Positionsmanagement.

Beispiel:

int totalPositions = 0;
int position_type_buy = 0;
int position_type_sell = 0;

for(int i = 0; i < PositionsTotal(); i++)
  {
   ulong ticket = PositionGetTicket(i);

   if(PositionSelectByTicket(ticket))
     {
      if(PositionGetInteger(POSITION_MAGIC) == MagicNumber && PositionGetString(POSITION_SYMBOL) == ChartSymbol(ChartID())
     {
      totalPositions++;
      if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
           {
            position_type_buy++;
           }
         if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
           {
            position_type_sell++;
           }
        }
     }
  }

Der EA zählt die Anzahl der Käufe, Verkäufe und Gesamtabschlüsse, um den Überblick über offene Positionen zu behalten. Es durchläuft die offenen Positionen, klassifiziert sie als Kauf oder Verkauf und verwendet die magische Zahl und das Chart-Symbol, um zu bestätigen, dass sie mit der Strategie übereinstimmen. Da jeweils nur ein Kauf- und ein Verkaufshandel zulässig sind, ist ein kontrolliertes Positionsmanagement gewährleistet.

3.2.2. Verfolgung der täglichen Handelslimits im Expert Advisor

Die Summe der während einer bestimmten Handelssitzung getätigten Abschlüsse ist das Hauptthema dieses Abschnitts. Der Expert Advisor stellt sicher, dass die Strategie das zulässige tägliche Handelslimit nicht überschreitet, indem er einen vorher festgelegten Zeitraum festlegt und die Kauf- und Verkaufstransaktionen zusammenfasst. Durch die Vermeidung eines übermäßigen Handels während der zugewiesenen Zeit hilft diese Strategie bei der Aufrechterhaltung eines kontrollierten Handelsverhaltens.

Beispiel:

input int daily_trades = 6; // Total Daily Trades

// Start and end time for
string start = "00:00";
string end = "23:50";

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {

   datetime start_time = StringToTime(start);
   datetime end_time = StringToTime(end);
   bool success = HistorySelect(start_time, end_time);

// Getting total trades
   int totalDeal = 0;
   int deal_type_buy = 0;
   int deal_type_sell = 0;
   if(success)
     {
      for(int i = 0; i < HistoryDealsTotal(); i++)
        {
         ulong ticket = HistoryDealGetTicket(i);

         if(HistoryDealGetInteger(ticket, DEAL_MAGIC) == MagicNumber && HistoryDealGetString(ticket,DEAL_SYMBOL) == ChartSymbol(chart_id))
           {
            if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_IN)
              {
               totalDeal++;
               if(HistoryDealGetInteger(ticket, DEAL_TYPE) == DEAL_TYPE_BUY)
                 {

                  deal_type_buy++;

                 }
               if(HistoryDealGetInteger(ticket, DEAL_TYPE) == DEAL_TYPE_SELL)
                 {

                  deal_type_sell++;

                 }
              }
           }
        }
     }
  }

Erläuterung:

Der Expert Advisor übersetzt zunächst die angegebenen Start- und Endzeiten in das Datumsformat, um die Gesamtzahl der während einer bestimmten Handelssitzung getätigten Handelsgeschäfte zu erfassen. Die Funktion HistorySelect() wird dann verwendet, um den Handelsverlauf auszuwählen, der in diesen Zeitrahmen fällt. Der EA richtet Zähler ein, um die Gesamtzahl der durchgeführten Handelsgeschäfte und die Anzahl der Kauf- und Verkaufsgeschäfte unabhängig voneinander aufzuzeichnen, wenn die Auswahl erfolgreich ist.

Der EA extrahiert dann die Ticketnummer für jeden Handel, indem er über die Handelshistorie iteriert. Um sicherzustellen, dass nur relevante Handelsgeschäfte gezählt werden, wird überprüft, ob der Handel mit der gleichen Magic Number und dem gleichen Symbol wie im aktuellen Chart eröffnet wurde. Die Gesamtzahl der Handelsgeschäfte wird erhöht, wenn festgestellt wird, dass es sich bei dem Handelsgeschäft um einen Einstieg handelt. Nach der Entscheidung, ob der Handel platziert wurde, aktualisiert der EA die entsprechenden Zähler. Dadurch wird gewährleistet, dass die Strategie die ausgeführten Transaktionen überwacht und das tägliche Handelslimit nicht überschritten wird.

3.2.3. Verhindern von wiederholten Handelsgeschäfte innerhalb derselben Kerze

In einigen Fällen kann der EA einen neuen Handel sofort nach dem Schließen einer bestehenden Position eröffnen, wenn Sie möchten, dass neue Handelsgeschäfte nur zum Eröffnungskurs eines neuen Balkens abgeschlossen werden. Dies gilt vor allem dann, wenn die Handelsbedingungen noch immer dieselben sind. Dies kann dazu führen, dass ungewollt aufeinanderfolgende Handelsgeschäfte innerhalb derselben Kerze getätigt werden. In diesem Teil werden wir uns ansehen, wie man dies verhindern kann, z. B. indem man sicherstellt, dass Handelsgeschäfte nur zum Eröffnungskurs des folgenden Balkens ausgeführt werden, indem man die Handelskontrolle verbessert und indem man sinnlose Wiedereintritte verhindert.

Beispiel:

// Declare an array to store time data
datetime time[];

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
// Ensure the time array is structured as a time series (most recent data first)
   ArraySetAsSeries(time, true);

   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
// Retrieve the latest three time values from the current symbol and timeframe
   CopyTime(_Symbol, PERIOD_CURRENT, 0, 3, time);

// Select trading history from the earliest recorded time to the current time
   bool trade_control = HistorySelect(time[0], TimeCurrent());

// Variable to count the number of closed trades
   int total_deals_out = 0;

// If the trading history selection is successful, process the data
   if(trade_control)
     {
      // Loop through all closed trades in the history
      for(int i = 0; i < HistoryDealsTotal(); i++)
        {
         // Get the ticket number of the historical trade
         ulong ticket = HistoryDealGetTicket(i);

         // Check if the trade matches the current EA's Magic Number and symbol
         if(HistoryDealGetInteger(ticket, DEAL_MAGIC) == MagicNumber && HistoryDealGetString(ticket, DEAL_SYMBOL) == ChartSymbol(chart_id))
           {
            // If the trade was an exit trade, increment the counter
            if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_OUT)
              {
               total_deals_out++;
              }
           }
        }
     }
  }

Erläuterung:

Diese Funktion verhindert, dass der EA nach dem Schließen einer Kerze einen neuen Handel innerhalb derselben Kerze eröffnet. Mithilfe von CopyTime(), das die Zeitstempel der jüngsten Balken liefert, ruft das Verfahren zunächst die jüngsten Zeitwerte aus dem Chart ab. Als Nächstes wählt der EA von der ersten aufgezeichneten Balkenzeit (time[0]) bis zur aktuellen Marktzeit (TimeCurrent()) den Handelsverlauf innerhalb des Zeitrahmens aus.

Um geschlossene Handelsgeschäfte zu finden, die mit der magischen Zahl und dem Symbol des EA übereinstimmen, durchläuft er die Handelshistorie. Der Zähler total_deals_out wird erhöht, wenn ein geschlossenes Handelsgeschäft - genauer gesagt ein Exit-Handelsgeschäft (DEAL_ENTRY_OUT) - gefunden wird. Wenn ein Handel vor kurzem innerhalb derselben Kerze geschlossen wurde, kann dieser Zähler Ihnen helfen, dies herauszufinden. Um sicherzustellen, dass Handelsgeschäfte nur zu Beginn eines neuen Balkens ausgeführt werden und um einen unerwünschten sofortigen Wiedereinstieg zu vermeiden, wird der EA kein neues Handelsgeschäft initiieren, bis eine neue Kerze beginnt.

3.2.4. Implementierung von Risikomanagement und Handelsausführung mit Heikin Ashi

Um zu gewährleisten, dass Kauf- und Verkaufstransaktionen in Übereinstimmung mit den Heikin Ashi-Signalen ausgeführt werden, werden wir in diesem Abschnitt die Anforderungen für die Handelsausführung festlegen. Darüber hinaus werden wir das Risikomanagement integrieren, indem wir die Losgrößen entsprechend einem vorgegebenen Dollar-Risiko pro Handel und einem Risiko-Gewinn-Verhältnis (Risk-to-Reward-Ratios, RRR) festlegen. Diese Strategie vermeidet ein übermäßiges Risiko und gewährleistet gleichzeitig einen kontrollierten Handel.

Beispiel:

input  double dollar_risk = 12.0; // How Many Dollars($) Per Trade?
input double RRR = 3;

double ask_price;
double lot_size;
double point_risk;
double take_profit;

// Variable to store the time of the last executed trade
datetime lastTradeBarTime = 0;

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {

// Get the opening time of the current bar
   datetime currentBarTime = iTime(_Symbol, PERIOD_CURRENT, 0);

// Check conditions for opening a buy position
// Ensures Heikin Ashi candle crosses above the moving average
// Limits trades per day and prevents multiple trades in the same candlestick
   if(heikin_open[1] < heikin_ma[1] && heikin_close[1] > heikin_ma[1] &&
      deal_type_buy < (daily_trades / 2) && total_deals_out < 1 &&
      totalPositions < 1 && currentBarTime != lastTradeBarTime)
     {
      // Calculate risk in points (distance from entry to stop loss)
      point_risk = ask_price - heikin_low[1];

      // Calculate take profit based on risk-to-reward ratio (RRR)
      take_profit = ((ask_price - heikin_low[1]) * RRR) + ask_price;

      // Determine lot size based on the dollar risk per trade
      lot_size = CalculateLotSize(_Symbol, dollar_risk, point_risk);

      // Execute a buy trade
      trade.Buy(lot_size, _Symbol, ask_price, heikin_low[1], take_profit);

      // Store the current bar time to prevent multiple trades in the same candle
      lastTradeBarTime = currentBarTime;
     }

// Check conditions for opening a sell position
// Ensures Heikin Ashi candle crosses below the moving average
// Limits trades per day and prevents multiple trades in the same candlestick
   if(heikin_open[1] > heikin_ma[1] && heikin_close[1] < heikin_ma[1] &&
      deal_type_sell < (daily_trades / 2) && total_deals_out < 1 &&
      totalPositions < 1 && currentBarTime != lastTradeBarTime)
     {
      // Calculate risk in points (distance from entry to stop loss)
      point_risk = heikin_high[1] - ask_price;

      // Calculate take profit based on risk-to-reward ratio (RRR)
      take_profit = MathAbs(((heikin_high[1] - ask_price) * RRR) - ask_price);

      // Determine lot size based on the dollar risk per trade
      lot_size = CalculateLotSize(_Symbol, dollar_risk, point_risk);

      // Execute a sell trade
      trade.Sell(lot_size, _Symbol, ask_price, heikin_high[1], take_profit);

      // Store the current bar time to prevent multiple trades in the same candle
      lastTradeBarTime = currentBarTime;
     }
  }

//+------------------------------------------------------------------+
//| Function to calculate the lot size based on risk amount and stop loss
//+------------------------------------------------------------------+
double CalculateLotSize(string symbol, double riskAmount, double stopLossPips)
  {
// Get symbol information
   double point = SymbolInfoDouble(symbol, SYMBOL_POINT);
   double tickValue = SymbolInfoDouble(symbol, SYMBOL_TRADE_TICK_VALUE);

// Calculate pip value per lot
   double pipValuePerLot = tickValue / point;

// Calculate the stop loss value in currency
   double stopLossValue = stopLossPips * pipValuePerLot;

// Calculate the lot size
   double lotSize = riskAmount / stopLossValue;

// Round the lot size to the nearest acceptable lot step
   double lotStep = SymbolInfoDouble(symbol, SYMBOL_VOLUME_STEP);
   lotSize = MathFloor(lotSize / lotStep) * lotStep;

   return lotSize;
  }

Erläuterung:

Um Trends zu validieren, hängt die Handelsausführungslogik davon ab, dass Heikin Ashi-Kerzen einen gleitenden Durchschnitt (MA) kreuzen. Eine Aufwärts-Umkehr ist angezeigt, wenn der Eröffnungskurs unter dem MA liegt und der Schlusskurs darüber, und ein Verkauf, wenn das Gegenteil der Fall ist. Das System schränkt den täglichen Handel ein, stellt sicher, dass keine offenen Positionen vorhanden sind, und führt nur bei neuen Kerzen Handelsgeschäfte durch, um übermäßigen Handel zu verhindern. Stop-Loss bei früheren Heikin-Ashi-Hochs oder -Tiefs, Take Profit auf der Grundlage des Verhältnisses von Risiko zum Gewinn (Risk-to-Reward-Ratios, RRR) und dynamische Losgrößen sind allesamt Bestandteile des Risikomanagements.

3.2.5. Verwendung von Heikin Ashi-Kerzen zur Platzierung eines Trailing-Stops

Die Implementierung eines Trailing-Stop-Mechanismus unter Verwendung von Heikin Ashi-Kerzen ist das Hauptziel dieses Abschnitts. Es stellt sicher, dass die Stop-Loss dynamisch als Reaktion auf Veränderungen des Heikin Ashi-Kurses angepasst werden.

Beispiel:

input bool    allow_trailing  = false; // Do you Allow Trailing Stop?

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {

   // Check if trailing stop is enabled
   if(allow_trailing == true)
     {
      // Variables to store trade-related information
      double positionProfit = 0;
      double positionopen = 0;
      double positionTP = 0;
      double positionSL = 0;

      // Loop through all open positions
      for(int i = 0; i < PositionsTotal(); i++)
        {
         // Get the ticket number of the position
         ulong ticket = PositionGetTicket(i);

         // Select the position using its ticket number
         if(PositionSelectByTicket(ticket))
           {
            // Check if the position belongs to the EA by verifying the magic number and symbol
            if(PositionGetInteger(POSITION_MAGIC) == MagicNumber && PositionGetString(POSITION_SYMBOL) == ChartSymbol(chart_id))
              {
               // Retrieve trade details: open price, take profit, profit, and stop loss
               positionopen = PositionGetDouble(POSITION_PRICE_OPEN);
               positionTP = PositionGetDouble(POSITION_TP);
               positionProfit = PositionGetDouble(POSITION_PROFIT);
               positionSL = PositionGetDouble(POSITION_SL);

               // Apply trailing stop logic for buy positions
               if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
                 {
                  // Adjust stop loss if Heikin Ashi low is above the entry price and the candle is bullish
                  if(heikin_low[1] > positionopen && heikin_close[1] > heikin_open[1])
                    {
                     trade.PositionModify(ticket, heikin_low[1], positionTP);
                    }
                 }

               // Apply trailing stop logic for sell positions
               if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
                 {
                  // Adjust stop loss if Heikin Ashi high is below the entry price and the candle is bearish
                  if(heikin_high[1] < positionopen && heikin_close[1] < heikin_open[1])
                    {
                     trade.PositionModify(ticket, heikin_high[1], positionTP);
                    }
                 }
              }
           }
        }
     }
  }

Erläuterung:

Um Gewinne zu sichern und die Stop-Loss dynamisch anzupassen, wird in diesem Abschnitt ein Trailing-Stop mit Heikin-Ashi-Kerzen implementiert. Die Eingangsvariable allow_trailing steuert, ob die Funktion eines Trailing-Stop aktiviert ist. Ist sie auf true gesetzt, durchläuft das System alle offenen Positionen, ruft ihre Details ab und überprüft, ob sie zum EA gehören, indem es die magische Zahl und das Symbol überprüft. Um die Trailing-Stop-Logik zu vereinfachen, werden die wichtigsten Handelsinformationen extrahiert, einschließlich Eröffnungskurs, Take Profit, Gewinn und Stop Loss.

Indem das System prüft, ob das vorherige Heikin Ashi-Tief über dem Einstiegskurs liegt und ob der Heikin Ashi-Schlusskurs über dem Eröffnungskurs liegt, prüft es offene Positionen und bestätigt einen Aufwärtstrend. Um die Gewinne zu schützen und gleichzeitig eine weitere Aufwärtsbewegung zu ermöglichen, wird der Stop-Loss bei Erreichen des Heikin Ashi-Tiefs gesetzt. Indem sichergestellt wird, dass das vorangegangene Heikin Ashi-Hoch unter dem Einstiegskurs liegt und dass der Heikin Ashi-Schlusskurs unter dem Eröffnungskurs liegt, wird ein Abwärtstrend für Verkaufsgeschäfte bestätigt. Um den Handel abzusichern und weitere Marktschwankungen aufzufangen, wird der Stop Loss auf das Heikin Ashi-Hoch gesetzt, wenn diese Bedingungen erfüllt sind.

Schlussfolgerung

In diesem Artikel haben wir einen Heikin Ashi-Indikator von Grund auf neu entwickelt, ihn mit einem gleitenden Durchschnitt integriert, der Heikin Ashi-Kerzendaten verwendet, und untersucht, wie man einen nutzerdefinierten Indikator in einen EA einbindet, um eine nahtlose Integration für den automatisierten Handel zu gewährleisten. Wir haben Risikomanagementtechniken wie die Begrenzung des täglichen Handels, die Verhinderung mehrerer geschlossener Handelsgeschäfte innerhalb derselben Kerze und die dynamische Berechnung von Losgrößen eingeführt. Darüber hinaus haben wir einen Trailing-Stop eingeführt, der die Kerzen des Heikin-Ashi zur Anpassung der Stop-Loss verwendet. Diese Konzepte bilden eine solide Grundlage für die Entwicklung und Verfeinerung automatisierter Handelsstrategien in MQL5.