MetaTrader 5 / Handel
English Русский 中文 Español 日本語 Português
preview
Wie man MQL5 verwendet, um Kerzenmuster zu erkennen

Wie man MQL5 verwendet, um Kerzenmuster zu erkennen

MetaTrader 5 — Handel | 24 Mai 2023, 11:33
535 0
Mohamed Abdelmaaboud
Mohamed Abdelmaaboud

Einführung

Kerzen sind ein sehr hilfreiches technisches Instrument, wenn wir sie richtig einsetzen, da wir anhand ihrer Muster eine potenzielle Bewegung erkennen können. Kerzen können bestimmte Muster auf dem Chart bilden, und diese Muster können in zwei Arten von Einzelkerzenmustern und gemischten Kerzenmustern (mehr als eine Kerze) unterteilt werden. In diesem Artikel werden wir lernen, wie wir MQL5 verwenden können, um einige dieser Muster automatisch im MetaTrader 5-Handelsterminal zu erkennen, wir werden das durch die folgenden Themen abdecken:

Ich muss erwähnen, dass es sehr wichtig ist, diese Muster zusammen mit anderen technischen Instrumenten zu verwenden, um aussagekräftige Signale zu erhalten. Sie müssen also die Hauptidee der Erkennung der erwähnten Muster durch MQL5 verstehen, um ein Teil Ihres Handelssystems zu sein, um Ihren Handel zu erleichtern und gute Ergebnisse zu erzielen.

Haftungsausschluss: Alle Informationen werden in der vorliegenden Form nur zu Informationszwecken bereitgestellt und sind nicht für Handelszwecke oder als Ratschläge gedacht. Die Informationen garantieren keinen Erfolg. Wenn Sie sich dafür entscheiden, diese Materialien auf einem Ihrer Handelskonten zu verwenden, tun Sie dies auf eigenes Risiko und Sie sind allein verantwortlich.

Muster einer Kerze

In diesem Teil sehen wir uns zwei Beispiele für verbreitet Muster aus einer Kerzen an, die im Chart erscheinen. Sie können sie in jedem Zeitrahmen zu sehen, aber sie gewinnen an Bedeutung, wenn sie in ihren Platz im Verhältnis zu den Preis-Aktionen erhalten.

Das Muster des Doji:

Es ist sehr bekannt unter den Kerzenmustern und es ist die Kerze, die fast den gleichen Eröffnungs- und Schlusskurs hat und einen sehr kleinen Kerzenkörper und eine senkrechte Linie auf dem Chart mit gleichem Preis für die obere und untere Körpergrenze. Die folgende Abbildung zeigt so eine Kerze:

Doji

Diese Doji-Kerze zeigt an, dass ein Gleichgewicht zwischen Käufern und Verkäufern besteht und niemand den Markt kontrolliert, um den Preis während des Zeitraums, in dem sie erscheint, nach oben oder unten zu bewegen. Er kann eine Umkehrung oder Korrektur des Marktes signalisieren, wenn er an der geeigneten Stelle im Chart vor einer Korrektur oder am Ende des Trends erscheint, und er ist aussagekräftiger, wenn er in einem größeren Zeitrahmen erscheint. Es gibt viele Arten und Formationen für diese Kerze und jeder hat eine Menge von Informationen, die zu unseren Gunsten im Handel wie Dragonfly und Long-legged verwendet werden können.

Was wir tun müssen, ist dem Computer mitzuteilen, dass er das Doji-Muster erkennen soll, indem er die Preise und die Zeit der letzten Kerze festlegt, und jeden Tick soll das Programm diese Werte zu diesem festgelegten Zeitpunkt überprüfen und vergleichen und die Positionen aller bestimmen. Wenn der Eröffnungs- gleich dem Schlusskurs ist, muss das Programm ein Signal zurückgeben, dass es sich um ein Doji-Kerzenmuster handelt.

Nun müssen wir ein Programm erstellen, das dieses Muster erkennen kann, und im Folgenden werden die Schritte einer Methode beschrieben, die dies tun kann:

Wir erstellen eine Funktion für diesen Doji (getDoji) und rufen sie in OnTick() auf, um jeden Tick auf dieses Muster zu prüfen

void OnTick()
  {
   getDoji();
  }

Erstellen der Funktion (getDoji), angelegt als Integer.

int getDoji()

Definition dieser Funktion durch Angabe von Zeit, Eröffnungs-, Höchst-, Tiefst- und Schlusskurs der letzten Kerze

Mit der Funktion iTime, die die Eröffnungszeit der Kerze zurückgibt, der Funktion iOpen, die den Eröffnungskurs der Kerze zurückgibt, der Funktion iHigh, die den Höchstkurs zurückgibt, der Funktion iLow, die den Tiefstkurs zurückgibt, und der Funktion iClose, die den Schlusskurs der Kerze zurückgibt. Die Parameter sind für alle gleich:

  • symbol: um den Symbolnamen zu definieren, verwenden wir (_Symbol) für das aktuelle Symbol.
  • timeframe: Um den Zeitrahmen des Charts zu definieren, verwenden wir (PERIOD_CURRENT) für den aktuellen Zeitrahmen.
  • shift: um den Index des zurückgegebenen Wertes zu definieren, wird (1) verwendet, um die letzte Kerze abzurufen.
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);

Einstellen der Bedingung des Doji, die wir mit Hilfe der if-Anweisung erkennen müssen:

if(open==close)

Wenn diese Bedingung erfüllt ist, muss das Programm ein Objekt erstellen, das auf der Funktion createObj basiert, die wir mit den Parametern Zeit, Preis, Pfeilcode, Farbe und dem benötigten Text erstellen werden. Dann wird die Funktion mit der Rückgabe von 1 beendet:

   if(open==close)
     {
      createObj(time,low,217, clrBlack,"Doji");
        {
         return 1;
        }
     }

Wir werden 0 zurückgeben, um die Funktion getDoji zu beenden:

   return 0;

Erstellen einer Funktion (createObj) mit den Parametern time, price, arrowcode, clr und txt, die keinen Wert (void) zurückgibt.

void createObj(datetime time, double price, int arrawCode, color clr, string txt)

Erstellen einer String-Variable (objName), der der Anfangswert " " zugewiesen wird:

string objName=" ";

Kombinieren von Zeichenketten (string), um sie der Variablen (objName) zuzuweisen, unter Verwendung der Funktion (StringConcatenate), die eine Zeichenkette aus übergebenen Parametern bildet und die Größe des gebildeten Strings zurückgibt. Die Parameter sind:

  • string_var: Um die Zeichenkette zu definieren, die nach der Verkettung gebildet wird, verwenden wir (objName).
  • argument1: Um den Parameter eines beliebigen einfachen Typs zu definieren, verwenden wir den Text „Signal at“.
  • argument2: Um den Zeitpunkt der erkannten Kerze zu bestimmen, wird die Zeit der vorgegebenen Variablen verwendet.
  • argument3: Wir setzen den Text " at ".
  • argument4: Wir werden den Text des gerundeten Preises festlegen, indem wir DoubleToString verwenden, um den Double-Typ in eine Zeichenkette umzuwandeln.
  • argument5: Wir setzen den Text " (".
  • argument6: Wir weisen einen Wert für die vorgegebene Ganzzahlvariable (arrowcode) zu, die wir benötigen. Dieser Code kann durch die Suche in „Wingdings“ in der mql5-Referenz gefunden werden.
  • argument7: Wir setzen den Text ")".
StringConcatenate(objName, "Signal at ",time, " at ",DoubleToString(price,_Digits)," (",arrawCode,")");

Wir legen eine Bedingung fest, die mit der if-Anweisung und der Funktion (ObjectCreate) als Ausdruck ausgewertet wird. Die Funktion (ObjectCreate) erstellt ein Objekt für uns, indem sie den vordefinierten Namen (objName) verwendet und die Parameter sind:

  • chart_id: Zur Identifizierung des Charts, wir verwenden 0 für das aktuelle Chart.
  • name: Um den Objektnamen zu definieren, wird der vordefinierte Name (objName) verwendet.
  • type: Zur Definition des Objekttyps wird (OBJ_ARROW) verwendet.
  • nwin: Um die Nummer des Unterfensters des Charts zu definieren, verwenden wir (0) für das Hauptfenster des Charts.
  • time1: Um die Zeit des Ankers zu definieren, wird die vordefinierte Variable (time) verwendet.
  • price1: Um den Preis des Ankers zu definieren, wird die vordefinierte (Preis-)Variable verwendet.
if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))

Sobald diese Bedingung durch die Erstellung des Objekts erfüllt ist, müssen wir seine Eigenschaften einstellen, seine Form durch die Bestimmung des Pfeilcodes und seine Farbe durch die Verwendung der Funktion (ObjectSetInteger), die den Wert der Objekteigenschaft festlegt. Die Parameter sind:

  • chart_id: Zur Identifizierung des Charts, wir verwenden 0 für das aktuelle Chart.
  • name: Zur Definition des Objektnamens wird (objName) verwendet.
  • prop_id: Zur Definition der Eigenschaft des Objekts wird eine der ENUM_OBJECT_PROPERTY_INTEGER, die (OBJPROP_ARROWCODE) für den Pfeilcode und (OBJPROP_COLOR) für die Farbe verwendet.
  • prop_value: Um den Eigenschaftswert zu definieren, werden wir (arrawCode) für den Pfeilcode und die vordefinierte Variable (clr) für die Farbe verwenden.
ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);

Danach müssen wir den Text definieren, den wir als Definition der Kerze benötigen, indem wir eine String-Variable für (candleName) mit einer Zuweisung der vordefinierten Variablen (objName) und (txt) erstellen

string candleName=objName+txt;

Erstellen und Bearbeiten des Textobjekts mit Hilfe der if-Anweisung und der Funktion (ObjectCreate) als Ausdruck und der Operator wird (ObjectSetString) sein, um den String-Wert der Objekteigenschaft einzustellen, und (ObjectSetInteger), um die Farbe des Textobjekts einzustellen.

      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);

Jetzt können wir den vollständigen Code dieses Expert Advisors wie folgt sehen:

//+------------------------------------------------------------------+
//|                                        Doji pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
void OnTick()
  {
   getDoji();
  }
int getDoji()
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
//Doji
   if(open==close)
     {
      createObj(time,low,217, clrBlack,"Doji");
        {
         return 1;
        }
     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal at ",time, " at ",DoubleToString(price,_Digits)," (",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

Nach dem fehlerfreien Kompilieren dieses Codes können wir ihn im Navigatorfenster finden. Indem wir ihn zur Ausführung auf den Chart ziehen, können wir dann seine Signale erhalten, die das Doji-Muster erkennen. Das Folgende ist ein Beispiel aus dem Test:

Doji-Beispiel

Wie im vorherigen Chart zu sehen ist, haben wir ein schwarzes Pfeilobjekt unter der Kerze und den Doji-Text, um das Kerzenmuster zu definieren.

Das Muster Hammer:

Das Hammer-Muster ist ein sehr bekanntes Kerzenmuster, das wir auf dem Chart in vielen Zeitrahmen sehen können. Sein Name bezieht sich auf seine Form, da er einen langen Schatten und einen kleinen Körper hat. Es gibt zwei Arten von Hammermustern, Hammer und Umgekehrter (Inverted) Hammer, je nach Position des kleinen Körpers. Wenn die Kerze einen langen unteren Schatten hat und der Kerzenkörper darüber liegt, handelt es sich um einen Hammer und es kann sich um eine Auf- oder Abwärtskerze handeln, je nach Eröffnungs- und Schlusskurs. Die folgenden Abbildungen sind Beispiele für dieses Hammer-Muster:

  • Aufwärts-Hammer

Aufwärts-Hammer

Es zeigt an, dass die Verkäufer versucht haben, den Preis zu drücken, aber die Käufer kontrollieren den Markt und er schließt höher als bei der Eröffnung, was auf die Stärke der Käufer deutet.

  • Abwärts-Hammer

Abwärts-Hammer

Es zeigt an, dass die Verkäufer versucht haben, den Preis nach unten zu drücken, aber die Käufer scheinen etwa bei der Eröffnung auszusteigen, was bedeutet, dass die Käufer noch im Spiel sind.

Wenn die Kerze einen langen oberen Schatten hat und ihr Körper darunter liegt, handelt es sich um ein umgekehrtes Hammer-Muster (Inverted Hammer), das je nach der Position der Eröffnungs- und Schlusskurse auch auf- oder abwärts sein kann. Die folgenden Abbildungen sind Beispiele für diesen umgekehrten Hammer.

  • Umgekehrter Aufwärts-Hammer

Umgekehrter Aufwärts-Hammer

Es zeigt an, dass die Käufer versucht haben, die Preise nach oben zu treiben, aber die Verkäufer scheinen die Kerze um die Eröffnung und das Tief zu schließen, was bedeutet, dass die Verkäufer trotz der Stärke der Käufer noch im Spiel sind.

  • Umgekehrter Abwärts-Hammer

Umgekehrter Abwärts-Hammer

Es zeigt an, dass die Käufer versucht haben, den Preis nach unten zu drücken, aber die Verkäufer kontrollieren den Markt und schließen unter dem Eröffnungskurs, was auf eine Stärke der Verkäufer deutet.

Wie alle Kerzenmuster ist auch dieses Muster aussagekräftiger, wenn es mit anderen technischen Instrumenten kombiniert wird 

Jetzt müssen wir ein Programm erstellen, das diese Art von Mustern erkennen kann. Wir werden also dieses Programm die Kerzenpreise, die Zeit und die Kerzengröße finden lassen, um sie mit dem Körper und den Schatten der Kerze zu vergleichen, und wir brauchen das Programm, um sie kontinuierlich zu überprüfen und jeden Tick zu vergleichen, um ihre Positionen zu bestimmen. Wenn das Programm einen Hammer oder Umgekehrten Hammer (auf- oder abwärts) erkennt, müssen wir das Programm, um ein Objekt auf dem Chart mit seinem Typ Name und Pfeile Farbe grün oder rot basiert und unter oder über der Kerze auf der Grundlage der Farbe der Kerze (auf- oder abwärts) zurück.

Im Folgenden finden Sie den vollständigen Code für diese Art von Programm:

//+------------------------------------------------------------------+
//|                                      Hammer pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
void OnTick()
  {
   getHammer(0.07,0.7);
  }
int getHammer(double smallShadowRatio, double longShadowRatio)
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double candleSize=high-low;
   if(open<close)
     {
      if(high-close < candleSize*smallShadowRatio)
        {
         if(open-low>candleSize*longShadowRatio)
            createObj(time,low,217, clrGreen,"Hammer");
           {
            return 1;
           }
        }
     }
   if(open>close)
     {
      if(high-open<candleSize*smallShadowRatio)
        {
         if(close-low>candleSize*longShadowRatio)
            createObj(time,high,218,clrRed,"Hammer");
           {
            return 1;
           }
        }
     }
   if(open<close)
     {
      if(open-low < candleSize*smallShadowRatio)
        {
         if(high-close>candleSize*longShadowRatio)
            createObj(time,low,217, clrGreen,"Inverted Hammer");
           {
            return -1;
           }
        }
     }
   if(open>close)
     {
      if(close-low < candleSize*smallShadowRatio)
        {
         if(high-open>candleSize*longShadowRatio)
            createObj(time,high,218, clrRed,"Inverted Hammer");
           {
            return -1;
           }
        }
     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal@",time, "at",DoubleToString(price,_Digits),"(",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);
      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

Unterschiede in diesem Code sind die gleichen wie die folgenden:

Der Aufruf der Funktion getHammer in OnTick() mit Festlegung der gewünschten Parameter für smallShadowRatio und longShadowRatio

void OnTick()
  {
   getHammer(0.07,0.7);
  }

Erstellen der Funktion (getHammer) mit Parametern von zwei Variablen des Typs double (smallShadowRatio) und (longShadowRatio)

int getHammer(double smallShadowRatio, double longShadowRatio)

Erstellen einer Variablen des Typ double für CandleSize, die mit dem Verhältnis verglichen wird:

double candleSize=high-low;

Bedingungen der Hammer-Kerze.

Im Falle eines Aufwärts-Hammers (Open<Close) benötigen wir eine letzte Aufwärtskerze, der obere Schatten der Kerze (High-Close) ist kleiner als das Verhältnis des kleinen Schattens, das 0,07 beträgt, und der untere Schatten (Open-Low) ist größer als das Verhältnis des langen Schattens, das 0,7 beträgt. Erstellen wir einen grünen Pfeil mit dem Code (217) aus Wingdings und dem Textobjekt „Hammer“ im Chart unterhalb des Tiefpunkts dieser Hammer-Kerze und beenden die Funktion.

   if(open<close)
     {
      if(high-close < candleSize*smallShadowRatio)
        {
         if(open-low>candleSize*longShadowRatio)
            createObj(time,low,217, clrGreen,"Hammer");
           {
            return 1;
           }
        }
     }

Im Falle eines Abwärts-Hammers (open>close) benötigen wir eine letzte Abwärtskerze, der obere Schatten der Kerze (high-open) ist kleiner als das Verhältnis des kleinen Schattens, das 0,07 beträgt, und der untere Schatten (close-low) ist größer als das Verhältnis des langen Schattens, das 0,7 beträgt. Erstellen eines roten Pfeils mit dem Code (218) aus Wingdings und dem Textobjekt „Hammer“ im Chart über dem Hoch dieser Hammer-Kerze, und dem Beenden der Funktion.

   if(open>close)
     {
      if(high-open<candleSize*smallShadowRatio)
        {
         if(close-low>candleSize*longShadowRatio)
            createObj(time,high,218,clrRed,"Hammer");
           {
            return 1;
           }
        }
     }

Im Falle eines Umgekehrten Aufwärts-Hammers (open<close) benötigen wir eine letzte Aufwärtskerze, der untere Schatten der Kerze (open-low) ist kleiner als das Verhältnis des kleinen Schattens, das 0,07 beträgt, und der obere Schatten (high-close) ist größer als das Verhältnis des langen Schattens, das 0,7 beträgt. Erstellen eines grünen Pfeils mit dem Code (217) aus Wingdings und dem Textobjekt „Inverted Hammer“ im Chart unter dem Tief dieser Hammer-Kerze und dem Beenden der Funktion.

   if(open<close)
     {
      if(open-low < candleSize*smallShadowRatio)
        {
         if(high-close>candleSize*longShadowRatio)
            createObj(time,low,217, clrGreen,"Inverted Hammer");
           {
            return -1;
           }
        }
     }

Im Falle eines Umgekehrten Abwärts-Hammer (open>close) benötigen wir eine letzte Abwärtskerze, der untere Schatten der Kerze (close-low) ist kleiner als das Verhältnis des kleinen Schattens, das 0,07 beträgt, und der obere Schatten (high-open) ist größer als das Verhältnis des langen Schattens, das 0,7 beträgt. Erstellen eines roten Pfeils mit dem Code (218) aus Wingdings und dem Textobjekt „Inverted Hammer“ auf dem Chart über dem Hoch dieser Kerze und dem Beenden der Funktion.

   if(open>close)
     {
      if(close-low < candleSize*smallShadowRatio)
        {
         if(high-open>candleSize*longShadowRatio)
            createObj(time,high,218, clrRed,"Inverted Hammer");
           {
            return -1;
           }
        }
     }

Bearbeiten der Position des Pfeils und seiner Farbe auf der Grundlage des Kerzentyps mit Hilfe der (if-Anweisung) der Ausdruck wird die Farbe und der Operator, wenn es wahr ist, wird die Position des Pfeils mit Hilfe der Funktion (ObjectSetInteger).

Wenn es grün ist, ist es unter der Kerze.

      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);

Wenn es rot ist, ist es über der Kerze. 

      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);

Nach dem fehlerfreien Kompilieren dieses Codes und dem Ausführen können wir unser Signal erhalten, und es folgen Beispiele aus dem Test:

  • Aufwärts-Hammer:

Aufwärts-Hammer, Beispiel

Wie wir sehen können, befinden sich ein grüner Pfeil und das grüne Textobjekt „Hammer“ auf dem Chart unter dem Tiefpunkt der bullischen Hammer-Kerze.

  • Abwärts-Hammer:

Abwärts-Hammer, Beispiel

Wie wir sehen können, gubt es wir einen roten Pfeil und das Textobjekt des roten „Hammers“ auf dem Chart über dem Hoch der Abwärtskerze des Hammers.

  • Umgekehrter Aufwärts-Hammer:

Umgekehrter Aufwärts-Hammer, Beispiel

Wie wir sehen können, befinden sich ein grüner Pfeil und das grüne Textobjekt „Inverted Hammer“ auf dem Chart unter dem Tief der Aufwärtskerze mit dem Umgekehrten Hammer.

  • Umgekehrter Abwärts-Hammer:

Umgekehrter Abwärts-Hammer, Beispiel

Wie wir sehen können, haben wir einen roten Pfeil und das rote „Inverted Hammer“ Textobjekt auf dem Chart über dem Hoch der Abwärtskerze mit dem Umgekehrten Hammer.

Muster aus zwei Kerzen

In diesem Teil werden wir eine andere Art von Kerzenmustern sehen, die aus zwei Kerzen besteht. Wir werden zwei bekannte Muster vorstellen, Engulfing (Aufwärts bzw. Bullish und Abwärts bzw. Bearish) und die Muster von Bullische Piercing Line (nach oben durchbrochene Linie) und ihr entgegengesetztes Bearish Dark Cloud (nach unten durchbrochene Linie).

Engulfing-Muster:

Dieses Kerzenmuster ist auch ein sehr beliebtes Muster in der Chart- und technischen Analyse, das aus zwei Kerzen besteht, von denen eine die andere verschlingt (engl. engulf), was bedeutet, dass auf eine kleine Kerze eine größere folgt und diese größere Kerze die kleinere vollständig überdeckt.

Es gibt verschiedene Arten dieses Engulfing-Musters, die auf der Farbe oder der Art der Kerzen basieren:

  • Das Bullish Engulfing:

Auf eine kleine Abwärtskerze folgt eine große Aufwärtskerze, und diese Aufwärtskerze verschlingt die kleinere, wofür die folgende Abbildung steht:

Bullish engulfing

Je nach seiner Bedeutung zeigt es an, dass die Käufer den Markt kontrollieren und der Preis danach weiter steigen kann.

  • Das Bearish Engulfing:

Auf eine kleine Aufwärtskerze folgt eine große Abwärtskerze, und diese Abwärtskerze verschlingt die kleinere Aufwärtskerze, wie in der folgenden Abbildung zu sehen ist:

Bearish Engulfing

Je nach seiner Bedeutung zeigt er an, dass die Verkäufer den Markt kontrollieren und der Preis danach weiter sinken kann.

Wenn wir nun ein Programm zur automatischen Erkennung dieses Musters erstellen wollen, müssen wir die Zeit der letzten Kerze und die Preise der letzten beiden Kerzen definieren. Das Programm muss diese Werte kontinuierlich bei jedem Tick überprüfen und ihre Positionen zueinander bestimmen, um zu prüfen, ob wir diese Art von Engulfing-Muster haben oder nicht. Sobald wir dieses Engulfing-Muster haben, muss das Programm ein spezifisches Signal zurückgeben, das aus einem farbigen Pfeil und einem Textobjekt besteht, das auf seinem Typ basiert (Auf- oder Abwärts).

Es folgt der vollständigen Code zur Erstellung dieses Programms:

//+------------------------------------------------------------------+
//|                                   Engulfing pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
void OnTick()
  {
   getEngulfing();
  }
int getEngulfing()
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);
   if(open<close)
     {
      if(open2>close2)
        {
         if(high>high2&&low<low2)
           {
            if(close>open2&&open<close2)
              {
               createObj(time,low,217, clrGreen,"Bullish Engulfing");
                 {
                  return 1;
                 }
              }
           }
        }
     }
   if(open>close)
     {
      if(open2<close2)
        {
         if(high>high2&&low<low2)
           {
            if(close<open2&&open>close2)
              {
               createObj(time,high,218, clrRed,"Bearish Engulfing");
                 {
                  return -1;
                 }
              }
           }
        }
     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal@",time, "at",DoubleToString(price,_Digits),"(",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);
      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

Unterschiede in diesem Code:

Erstellen von Variablen des Typs datetime und double für die Zeit der letzten Kerze und die Preise der letzten beiden Kerzen bei der Erstellung der Funktion (getEngulfing). time, open, high, low, und close sind für die letzte Kerze und open2, high2, low2 und close2 sind für die vorherige Kerze:

   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);

Bedingungen, die diese Art von Kerzenmuster definieren.

Bei Bullish Engulfing ist die letzte Kerze bullish (open<close), die vorherige Kerze ist bearish (open2>close2), high ist größer als high2 und gleichzeitig low ist niedriger als low2, close ist größer als open2 und gleichzeitig open ist niedriger als close2. Nach der Identifizierung erstellen wir ein Objekt auf der Grundlage der erstellten Funktion (createObj) mit den folgenden Parametern:

  • time: Es ist die Zeit der letzten Kerze, die die vordefinierte Variable ist.
  • price: Es ist das Tief der letzten Kerze, die wir für das Objekt unter ihr brauchen.
  • arrowCode: Es wird 217 aus dem Wingdings verwendet.
  • clr: Es wird clrGreen verwendet.
  • txt: Es wird "Bullish Engulfing" verwendet.

Dann beenden wir die Funktion.

   if(open<close)
     {
      if(open2>close2)
        {
         if(high>high2&&low<low2)
           {
            if(close>open2&&open<close2)
              {
               createObj(time,low,217, clrGreen,"Bullish Engulfing");
                 {
                  return 1;
                 }
              }
           }
        }
     }

Bei Bearish Engulfing ist die letzte Kerze eine Abwärtskerze (open>close), die vorherige Kerze eine Aufwärtskerze (open2<close2), high ist größer als high2, und gleichzeitig ist das low niedriger als low2, close ist niedriger als open2 und gleichzeitig ist open größer als close2. Nach der Identifizierung erstellen wir ein Objekt auf der Grundlage der erstellten Funktion (createObj) mit den folgenden Parametern:

  • time: Es ist die Zeit der letzten Kerze, die die vordefinierte Variable ist.
  • price: Es ist das Hoch der letzten Kerze, die wir für das Objekt über ihr brauchen.
  • arrowCode: Es wird 218 aus dem Wingdings verwendet.
  • clr: Es wird clrRed verwendet.
  • txt: Es wird das "Bearish Engulfing" verwendet.

Dann beenden wir die Funktion.

   if(open>close)
     {
      if(open2<close2)
        {
         if(high>high2&&low<low2)
           {
            if(close<open2&&open>close2)
              {
               createObj(time,high,218, clrRed,"Bearish Engulfing");
                 {
                  return -1;
                 }
              }
           }
        }
     }

Nach dem fehlerfreien Kompilieren dieses Codes und dem Ausführen seines EA können wir seine Signale wie in den folgenden Beispielen aus dem Test erkennen:

  • Das Bullish Engulfing:

Bullish Engulfing, Beispiel

Wie im vorherigen Chart zu sehen, gibt es einen grünen Pfeil und einen Text zu Bullish Engulfing unter dem Tief der letzten Kerze des Musters.

  • Das Bearish Engulfing:

Bearish Engulfing, Beispiel

Wie auf dem obigen Chart zu sehen, gibt es einen roten Pfeil und einen Text zu Bearish Engulfing über dem Hoch der letzten Kerze des Musters.

Piercing Line und Dark Cloud Cover:

  • Das Muster der Piercing Line:

Es handelt sich um eine Aufwärtskerze, die ebenfalls aus zwei Kerzen besteht. Die erste ist eine Abwärtskerze, gefolgt von einer Aufwärtskerze, die niedriger eröffnet als die Abwärtskerze, sich dann nach oben bewegt und über dem Mittelpunkt der ersten Abwärtskerze schließt. Die folgende Abbildung zeigt ein Chart, das dies beschreibt:

Piercing-Linie

Dies bedeutet, dass die Käufer stärker werden und den Markt kontrollieren, nachdem die Verkäufer die Kontrolle verloren haben. Es handelt sich also um einen Dynamikwechsel von der Verkaufseite zur Kaufseite, da die Käufer den Preis über den Mittelpunkt der vorherigen Abwärtskerze schieben konnten, obwohl es bei der Eröffnung eine Lücke gab.

  • Muster der Dark Cloud Cover:

Es handelt sich um ein Abwärtsmuster, das aus zwei Kerzen besteht. Die erste ist eine Aufwärtskerze, gefolgt von einer Abwärtskerze mit einer Lücke bei ihrer Eröffnung, die unterhalb des Mittelpunkts der ersten bullischen Kerze schließt. Das folgende Schaubild zeigt dies:

Dark Cloud Cover

Dies bedeutet, dass die Verkäufer stärker werden und den Markt kontrollieren nachdem die Käufer die Kontrolle verloren haben. Es handelt sich also um einen Dynamikwechsel von der Kaufseite zur Verkaufsseite, da die Verkäufer den Preis unter den Mittelpunkt der vorherigen Aufwärtskerze drücken konnten, obwohl es bei der Eröffnung eine Lücke gab.

Wenn wir ein Programm erstellen wollen, das diese Art von Mustern erkennen kann, müssen wir die Zeit und die Preise der ersten Kerze (time, open, high, low, and close) und die Preise für die zweite Kerze (open2, high2, low2, and close2), die Kerzengröße der ersten Kerze (candleSize2) und den Mittelpunkt der ersten Kerze (candleMidPoint2) definieren. Das Programm muss diese Werte kontinuierlich überprüfen und ihre Positionen in Bezug zueinander bestimmen und ein spezifisches Signal auf der Grundlage bestimmter Bedingungen zurückgeben, die auf einem Auf- oder Abwärtstrend basieren.

Es folgt der vollständigen Code zur Erstellung dieses Programms:

//+------------------------------------------------------------------+
//|                      Piercing && Dark Cloud pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
void OnTick()
  {
   getPiercing();  
  }
int getPiercing()
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);
   double candleSize2=high2-low2;
   double candleMidPoint2=high2-(candleSize2/2);
   if(open<close)
     {
      if(open2>close2)
        {
         if(open<low2)
           {
            if(close>candleMidPoint2&&close<high2)
              {
               createObj(time,low,217, clrGreen,"Piercing");
                 {
                  return 1;
                 }
              }
           }
        }
     }
   if(open>close)
     {
      if(open2<close2)
        {
         if(open>high2)
           {
            if(close<candleMidPoint2&&close>low2)
              {
               createObj(time,high,218, clrRed,"Dark Cloud");
                 {
                  return -1;
                 }
              }
           }
        }
     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal@",time, "at",DoubleToString(price,_Digits),"(",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);
      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

Die Unterschiede in diesem Code

Festlegung von candleSize2 und candleMidPoint2:

   double candleSize2=high2-low2;
   double candleMidPoint2=high2-(candleSize2/2);

Bedingungen des Musters

Im Falle des Musters Piercing Line:

Wenn die letzte eine Aufwärtskerze ist (open<close) und open2 größer ist als close2, open niedriger ist als low2 und close größer ist als candleMidPoint2 und gleichzeitig close niedriger ist als high2, soll das Programm ein Objekt auf dem Chart mit einem grünen Pfeil und dem Text „Piercing“ unter dem Tiefpunkt des Musters zurückgeben und die Funktion beenden.

   if(open<close)
     {
      if(open2>close2)
        {
         if(open<low2)
           {
            if(close>candleMidPoint2&&close<high2)
              {
               createObj(time,low,217, clrGreen,"Piercing");
                 {
                  return 1;
                 }
              }
           }
        }
     }

Im Fall des Musters von Dark Cloud Cover:

Wenn die letzte eine Abwärtskerze ist (open>close) und open2 niedriger ist als close2, open größer ist als high2 und close niedriger ist als candleMidPoint2 und gleichzeitig close größer ist als low2, soll das Programm ein Objekt auf dem Chart mit einem roten Pfeil und dem Text „Dark Cloud“ über dem Hoch des Musters zurückgeben und dann die Funktion beenden.

   if(open>close)
     {
      if(open2<close2)
        {
         if(open>high2)
           {
            if(close<candleMidPoint2&&close>low2)
              {
               createObj(time,high,218, clrRed,"Dark Cloud");
                 {
                  return -1;
                 }
              }
           }
        }
     }

Nach dem Kompilieren dieses Codes und dem Ausführen seines EAs erhalten wir die gewünschten Signale, wie in den folgenden Beispielen aus dem Test:

  • Das Muster der Piercing Line:

Beispiel für ein Piercing Line

Wie wir in der obigen Grafik sehen können, gibt es unseren grünen Pfeil und den Text zur Piercing Line unter dem Tief des Musters, so wie wir es brauchen.

  • Muster der Dark Cloud Cover:

Beispiel für Dark Cloud Cover

Wie wir im obigen Chart sehen können, haben wir einen roten Pfeil und Dar Cloud Text über dem Hoch des Musters, wie wir es brauchen.

Muster aus drei Kerzen

In diesem Teil werden wir zwei Muster aus den gemischten Mustern sehen, und zwar die „Sternenmuster“ (Morning Star (Morgenstern), Evening Star (Abendstern)) und das Muster Three Inside (Auf- oder Abwärts).

Die „Sternenmuster“:

  • Der Morning Star:

Es handelt sich um eine Drei-Kerzen-Struktur, wie wir sie bereits erwähnt haben. Sie wird durch eine kleine Kerze zwischen zwei Kerzen gebildet, von denen die erste eine lange Abwärts- und die letzte eine lange Aufwärtskerze ist. Das folgende Schaubild zeigt dies:

Morning Star (Morgenstern)

Aufgrund seiner Bedeutung weist er auf eine Dynamikverschiebung von den Verkäufern zu den Käufern hin, da die Käufer den Markt kontrollieren und die Preis nach einem Rückgang durch die Kontrolle der Verkäufer nach oben treiben.

  • Das Muster Evening Star:
Es handelt sich um eine Drei-Kerzen-Struktur, wie wir sie bereits erwähnt haben. Sie wird durch eine kleine Kerze zwischen zwei Kerzen gebildet, von denen die erste eine lange Aufwärts- und die letzte eine lange Abwärtskerze ist. Das folgende Bild zeigt dies:

Evening Star (Abendstern)

Aufgrund seiner Bedeutung weist er auf eine Dynamikverschiebung von den Käufern zu den Verkäufern hin, da die Verkäufer den Markt kontrollieren und den Preis, nach einer Rallye durch die Käufer, nach unten drücken.

Wenn wir ein Programm erstellen wollen, das zur Erkennung dieser Art von Mustern verwendet werden kann, müssen wir die Zeit und den Preis der letzten Kerze und die Preisdaten der beiden vorangegangenen Kerzen der letzten Kerze, candleSize der letzten drei Kerzen definieren und sie miteinander vergleichen, um ihre Positionen in Bezug zueinander zu bestimmen, um spezifische Signale auf der Grundlage bestimmter Bedingungen zu erhalten.

Es folgt der vollständigen Code zur Erstellung dieses Programms:

//+------------------------------------------------------------------+
//|                                        Star pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
void OnTick()
  {
   getStar(0.5);
  }
int getStar(double middleCandleRatio)
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);
   double open3=iOpen(_Symbol,PERIOD_CURRENT,3);
   double high3=iHigh(_Symbol,PERIOD_CURRENT,3);
   double low3=iLow(_Symbol,PERIOD_CURRENT,3);
   double close3=iClose(_Symbol,PERIOD_CURRENT,3);
   double candleSize=high-low;
   double candleSize2=high2-low2;
   double candleSize3=high3-low3;
   if(open<close)
     {
      if(open3>close3)
        {
         if(candleSize2<candleSize*middleCandleRatio && candleSize2<candleSize3*middleCandleRatio)
           {
            createObj(time,low,217, clrGreen,"Morning Star");
              {
               return 1;
              }
           }
        }

     }
   if(open>close)
     {
      if(open3<close3)
        {
         if(candleSize2<candleSize*middleCandleRatio && candleSize2<candleSize3*middleCandleRatio)
           {
            createObj(time,high,218, clrRed,"Evening Star");
              {
               return -1;
              }
           }
        }

     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal@",time, "at",DoubleToString(price,_Digits),"(",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);
      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

Die Unterschiede in diesem Code

Erstellen von getStar mit dem Parameter auf middleCandleRatio:

int getStar(double middleCandleRatio)

Erstellen von Zeitvariablen für die letzte Kerze und die Preisdaten (open, high, low, close) und die Kerzengröße für die letzten drei Kerzen (candlesize, candleSize2 und candleSize3):

   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);
   double open3=iOpen(_Symbol,PERIOD_CURRENT,3);
   double high3=iHigh(_Symbol,PERIOD_CURRENT,3);
   double low3=iLow(_Symbol,PERIOD_CURRENT,3);
   double close3=iClose(_Symbol,PERIOD_CURRENT,3);
   double candleSize=high-low;
   double candleSize2=high2-low2;
   double candleSize3=high3-low3;

Bedingungen des Musters

Im Falle des Musters Morning Star:

Wenn die letzte eine Aufwärtskerze ist (open<close), die dritte eine Abwärtskerze (open3>close3), CandleSize2 kleiner ist als middleCandleRatio der CandleSize, die 0,5 beträgt, und gleichzeitig CandleSize2 kleiner ist als middleCandleRatio der CandleSize3, soll das Programm ein Objekt mit einem grünen Pfeil und dem Text „Morning Star“ unterhalb des Tiefs des Musters zurückgeben und dann die Funktion beenden:

   if(open<close)
     {
      if(open3>close3)
        {
         if(candleSize2<candleSize*middleCandleRatio && candleSize2<candleSize3*middleCandleRatio)
           {
            createObj(time,low,217, clrGreen,"Morning Star");
              {
               return 1;
              }
           }
        }
     }

Im Falle des Evening Star:

Wenn die letzte eine Abwärtskerze ist (open>close), die dritte eine Aufwärtskerze ist (open3<close3), candleSize2 kleiner ist als middleCandleRatio der candleSize, die 0,5 beträgt, und gleichzeitig candleSize2 kleiner ist als middleCandleRatio der candleSize3, soll das Programm ein Objekt mit einem roten Pfeil und dem Text „Evening Star“ über dem Hoch des Musters ausgeben und dann die Funktion beenden:

   if(open>close)
     {
      if(open3<close3)
        {
         if(candleSize2<candleSize*middleCandleRatio && candleSize2<candleSize3*middleCandleRatio)
           {
            createObj(time,high,218, clrRed,"Evening Star");
              {
               return -1;
              }
           }
        }
     }

Nach dem fehlerfreien Kompilieren dieses Codes und dem Ausführen seines EA erhalten wir Signale, die den folgenden Beispielen aus dem Test entsprechen:

  • Der Morning Star:

Beispiel für Morning Star

Wie wir sehen können, haben wir das gewünschte Signal des gewünschten Objekts auf dem Chart unterhalb des erkannten Musters.

  • Der Evening Star:

Beispiel für Evening Star

Wie wir sehen können, haben wir das gewünschte Signal des gewünschten Objekts auf dem Chart unterhalb des erkannten Musters.

Als Anmerkung für die „Sternenmuster“. Die identische Musterbildung zeigt eine Lücke der mittleren kleinen Kerze, Wir könnten das als zusätzliche Bedingung in den Code einfügen, wenn wir das identische Muster erhalten möchten.

Das Muster Three Inside:

  • Three Inside Up:

Three Inside Up (Drei Innen Aufwärts) ist ebenfalls ein Muster aus drei Kerzen: Die erste Kerze ist eine lange Abwärtskerze, die zweite ist eine kleine Aufwärtskerze, die innerhalb (innside) der ersten Kerze gehandelt wird, und die dritte ist eine lange Aufwärtskerze, die über dem Hoch der ersten Kerze schließt. Das folgende Bild zeigt dieses Muster.

Three Inside Up

Aufgrund seiner Bedeutung deutet er auf einen potenziellen Aufwärtstrend durch die Kontrolle der Käufer hin.

  • Three Inside Down:

Die erste Kerze ist eine lange Aufwärtskerze, die zweite ist eine kleine Abwärtskerze, die innerhalb der ersten Kerze gehandelt wird, und die dritte ist eine lange Abwärtskerze, die unter dem Tief der ersten Kerze schließt. Das folgende Bild zeigt dieses Muster.

Three Inside Down

Aufgrund seiner Bedeutung deutet er auf einen potenziellen Abwärtstrend durch die Kontrolle der Verkäufer hin. Wenn wir ein Programm erstellen wollen, das zur Erkennung dieser Art von Mustern verwendet werden kann, werden wir auch die Zeit der letzten Kerze und die Preisdaten der letzten drei Kerzen definieren, das Programm diese Werte jeden Tick überprüfen lassen und ihre Positionen zueinander bestimmen, um ein geeignetes Signal als Objekt auf dem Chart je nach Muster zurückzugeben. Im Folgenden finden Sie den vollständigen Code dieses Programms: 
//+------------------------------------------------------------------+
//|                                Three inside pattern detector.mq5 |
//|                                  Copyright 2023, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2023, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"
void OnTick()
  {
   getthreeInside();
  }
int getthreeInside()
  {
   datetime time=iTime(_Symbol,PERIOD_CURRENT,1);
   double open=iOpen(_Symbol,PERIOD_CURRENT,1);
   double high=iHigh(_Symbol,PERIOD_CURRENT,1);
   double low=iLow(_Symbol,PERIOD_CURRENT,1);
   double close=iClose(_Symbol,PERIOD_CURRENT,1);
   double open2=iOpen(_Symbol,PERIOD_CURRENT,2);
   double high2=iHigh(_Symbol,PERIOD_CURRENT,2);
   double low2=iLow(_Symbol,PERIOD_CURRENT,2);
   double close2=iClose(_Symbol,PERIOD_CURRENT,2);
   double open3=iOpen(_Symbol,PERIOD_CURRENT,3);
   double high3=iHigh(_Symbol,PERIOD_CURRENT,3);
   double low3=iLow(_Symbol,PERIOD_CURRENT,3);
   double close3=iClose(_Symbol,PERIOD_CURRENT,3);
   if(open3>close3)
     {
      if(open2<close2)
        {
         if(open2>low3&&close2<high3)
           {
            if(open<close&&open>open2&&open<close2)
              {
               if(close>high3)
                 {
                  createObj(time,low,217, clrGreen,"3 Inside Up");
                    {
                     return 1;
                    }
                 }
              }
           }
        }

     }
   if(open3<close3)
     {
      if(open2>close2)
        {
         if(open2<high3&&close2>low3)
           {
            if(open>close&&open<open2&&open>close2)
              {
               if(close<low3)
                 {
                  createObj(time,high,218, clrRed,"3 Inside Down");
                    {
                     return -1;
                    }
                 }
              }
           }
        }
     }
   return 0;
  }
void createObj(datetime time, double price, int arrawCode, color clr, string txt)
  {
   string objName=" ";
   StringConcatenate(objName, "Signal@",time, "at",DoubleToString(price,_Digits),"(",arrawCode,")");
   if(ObjectCreate(0,objName,OBJ_ARROW,0,time,price))
     {
      ObjectSetInteger(0,objName,OBJPROP_ARROWCODE,arrawCode);
      ObjectSetInteger(0,objName,OBJPROP_COLOR,clr);
      if(clr==clrGreen)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_TOP);
      if(clr==clrRed)
         ObjectSetInteger(0,objName,OBJPROP_ANCHOR,ANCHOR_BOTTOM);
     }
   string candleName=objName+txt;
   if(ObjectCreate(0,candleName,OBJ_TEXT,0,time,price))
     {
      ObjectSetString(0,candleName,OBJPROP_TEXT," "+txt);
      ObjectSetInteger(0,candleName,OBJPROP_COLOR,clr);
     }
  }

Die Unterschiede in diesem Code sind Bedingungen des Musters

Im Fall des Three Inside Up

   if(open3>close3)
     {
      if(open2<close2)
        {
         if(open2>low3&&close2<high3)
           {
            if(open<close&&open>open2&&open<close2)
              {
               if(close>high3)
                 {
                  createObj(time,low,217, clrGreen,"3 Inside Up");
                    {
                     return 1;
                    }
                 }
              }
           }
        }

     }

Im Fall der Three Inside Down

   if(open3<close3)
     {
      if(open2>close2)
        {
         if(open2<high3&&close2>low3)
           {
            if(open>close&&open<open2&&open>close2)
              {
               if(close<low3)
                 {
                  createObj(time,high,218, clrRed,"3 Inside Down");
                    {
                     return -1;
                    }
                 }
              }
           }
        }
     }

Nach dem fehlerfreien Kompilieren dieses Codes und dem Ausführen seines EA erhalten wir die gleichen Signale wie in den folgenden Beispielen:

  • Three Inside Up:

Beispiel: Three Inside Up

Wie wir auf dem Chart sehen können, haben wir das gewünschte Signal der Three Inside Up.

  • Three Inside Down:

Beispiel: Three Inside Down

Wie wir auf dem Chart sehen können, haben wir das gewünschte Signal der Three Inside Down.

Schlussfolgerung

Nach den vorangegangenen Themen in diesem Artikel haben Sie vermutlich eine Vorstellung davon bekommen, wie man den Code schreibt, um die Kerzenmuster in ihren verschiedenen Formationen zu erkennen, d.h. Einzelkerzen-, Doppelkerzen- und Drei-Kerzen-Muster:

  • Signalkerzenmuster: Wir haben gelernt, wie man die Muster von Doji und Hammer erkennt.
  • Duale Kerzenmuster: Wir lernten, wie man Engulfing-, Piecing-Line- und Dark Cloud Cover-Muster erkennt.
  • Drei-Kerzen-Muster: Wir haben gelernt, wie man ein Programm erstellt, das die Sternenmuster und die von Three Inside erkennen kann.

Ich hoffe, dass dieser Artikel für Sie nützlich ist und Ihnen zu besseren Einsichten verhilft.

Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/12385

Warnung: Alle Rechte sind von MetaQuotes Ltd. vorbehalten. Kopieren oder Vervielfältigen untersagt.

Andere Artikel von diesem Autor

Zur Diskussion im Händlerforum
Algorithmen zur Optimierung mit Populationen: Ein dem Elektro-Magnetismus ähnlicher Algorithmus (ЕМ) Algorithmen zur Optimierung mit Populationen: Ein dem Elektro-Magnetismus ähnlicher Algorithmus (ЕМ)
Der Artikel beschreibt die Prinzipien, Methoden und Möglichkeiten der Anwendung des elektromagnetischen Algorithmus bei verschiedenen Optimierungsproblemen. Der EM-Algorithmus ist ein effizientes Optimierungswerkzeug, das mit großen Datenmengen und mehrdimensionalen Funktionen arbeiten kann.
Erstellen eines EA, der automatisch funktioniert (Teil 12): Automatisierung (IV) Erstellen eines EA, der automatisch funktioniert (Teil 12): Automatisierung (IV)
Wenn Sie glauben, dass automatisierte Systeme einfach sind, dann haben Sie wahrscheinlich nicht ganz verstanden, was es braucht, um sie zu erstellen. In diesem Artikel werden wir über das Problem sprechen, das viele Expert Advisors umbringt. Das willkürliche Auslösen von schwebenden Aufträgen ist eine mögliche Lösung für dieses Problem.
Kategorientheorie in MQL5 (Teil 6): Monomorphe Pullbacks und epimorphe Pushouts Kategorientheorie in MQL5 (Teil 6): Monomorphe Pullbacks und epimorphe Pushouts
Die Kategorientheorie ist ein vielfältiger und expandierender Zweig der Mathematik, der erst seit kurzem in der MQL5-Gemeinschaft Beachtung findet. In dieser Artikelserie sollen einige der Konzepte und Axiome erforscht und untersucht werden, mit dem übergeordneten Ziel, eine offene Bibliothek einzurichten, die Einblicke gewährt und hoffentlich auch die Nutzung dieses bemerkenswerten Bereichs für die Strategieentwicklung von Händlern fördert.
Kategorientheorie in MQL5 (Teil 5): Differenzkern oder Egalisator Kategorientheorie in MQL5 (Teil 5): Differenzkern oder Egalisator
Die Kategorientheorie ist ein vielfältiger und expandierender Zweig der Mathematik, der erst seit kurzem in der MQL5-Gemeinschaft Beachtung findet. In dieser Artikelserie sollen einige der Konzepte und Axiome erforscht und untersucht werden, mit dem übergeordneten Ziel, eine offene Bibliothek einzurichten, die Einblicke gewährt und hoffentlich auch die Nutzung dieses bemerkenswerten Bereichs für die Strategieentwicklung von Händlern fördert.