Verwenden von Linien in MQL5

Einführung

Wir alle als Händler ziehen viele Linien während des Handels, um uns zu helfen, einige wichtige Niveaus zu beobachten, um eine geeignete Handelsentscheidung zu treffen, die auf ihnen basiert. Diese Linien sind also für uns als Händler sehr wichtig, und wir fragen uns vielleicht, ob es eine Methode gibt, mit der wir diese Linien zeichnen oder automatisch eine geeignete Entscheidung auf ihrer Grundlage treffen können, denn ich denke, dass uns das sehr helfen würde. Die Antwort ist ja, wir haben eine Methode, um das mit MQL5 (MetaQuotes Language 5) zu tun.

Dieser Artikel ist ein Beispiel, um zu lernen, wie wir mit diesen Zeilen durch MQL5 umgehen können, denn es gibt viele Methoden, um so etwas zu tun, und diese Methoden hängen davon ab, was Sie tun müssen. Es gibt viele Arten von Linien, aber wir werden in diesem Artikel nur drei von ihnen erwähnen, weil sie so beliebt sind, und das sind Trendlinien, Unterstützungs- und Widerstandslinien.

Wir werden sie anhand der folgenden Themen behandeln:

1. Trendlinien und MQL5
2. Unterstützungen und MQL5
3. Widerstände und MQL5
4. Schlussfolgerung

Im Allgemeinen gibt es viele Methoden, die verwendet werden können, um mit Linien von MQL5 umzugehen. Wir werden hier eine einfache Methode vorstellen und Sie können feststellen, ob Sie sie verwenden können, um Ihre Strategien zu entwickeln. Wir werden hier eine Methode mitteilen, um Preisniveaus zu erkennen und dann eine aktualisierte Art von Linie zu zeichnen.

Wir werden lernen, was Linien im Detail sind, indem wir ihre Arten identifizieren, wie wir sie manuell zeichnen können und wie wir sie beim Handel verwenden können. Wir lernen, wie wir MQL5 verwenden können, um mit Trendlinien, Unterstützungs- und Widerstandsniveaus umzugehen, die uns helfen, unseren Handelsprozess zu erleichtern und unsere Handelsergebnisse durch Automatisierung zu verbessern. Wir werden MQL5 (MetaQuotes Language 5) verwenden, um unsere Programme zu kodieren, die in das MetaTrader 5-Handelsterminal integriert ist. Wenn Sie nicht wissen, wie man sie verwendet, können Sie das Thema „Schreiben von MQL5-Code in MetaEditor“ aus einem früheren Artikel lesen, um mehr darüber zu erfahren.

Ich empfehle Ihnen, das Gelesene selbst zu programmieren und anzuwenden, da dieser Schritt sehr wichtig ist, um Ihre Programmierfähigkeiten zu verbessern und Ihr Verständnis zu vertiefen, sowie weitere Einblicke in das Thema dieses Artikels und/oder in ein verwandtes Thema zu erhalten, die für die Entwicklung und Verbesserung Ihrer Handelsergebnisse nützlich sein können.

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.

Trendlinien und MQL5

Linien sind technische Instrumente, die beim Handel eingesetzt werden können, um effektivere Ergebnisse zu erzielen. Diese Linien können bei wichtigen Preisen oder Niveaus werden, die als Auslöser für wirksame Entscheidungen dienen können, und es gibt viele Arten dieser Linien. Wir werden in diesem Artikel drei dieser wichtigen Linien erwähnen, nämlich Trendlinien, Unterstützungs- und Widerstandslinien.

Jetzt werden wir mit der Identifizierung und der Verwendung mit Trendlinien beginnen. Trendlinien sind Linien, die verwendet werden können, um Preisniveaus zu visualisieren, die als Abprallniveaus nach oben oder unten verwendet werden können. Er kann je nach Marktrichtung über oder unter den Kursen gezeichnet werden. Wir können also sagen, dass die Trendlinie uns helfen kann, die Richtung des Markttrends zu erkennen. Wenn der Kurs von mindestens drei Punkten auf dem gleichen Niveau der eingezeichneten Linie nach oben abprallt, handelt es sich um eine Aufwärtstrendlinie. Umgekehrt ist es eine Abwärtstrendlinie, wenn mindestens drei Punkte auf denselben Ebenen der eingezeichneten Linie nach unten abprallen. Es ist wichtig, an dieser Stelle zu erwähnen, dass eine Trendlinie nur ein Hilfsmittel ist und man sie erkennen und richtig zeichnen kann oder nicht.

Wir können die Trendlinie beim Handel verwenden, indem wir unsere Aufträge auf der Grundlage des Trendlinientyps platzieren. Wenn es eine Aufwärtstrendlinie gibt, können wir erwarten, dass der Preis sich nach unten bewegt, um diese Trendlinie von oben zu testen und dann wieder nach oben zu steigen, und dann können wir unseren Kaufauftrag in der Nähe dieser Trendlinie platzieren. Umgekehrt, wenn es eine Abwärtstrendlinie gibt, kann es sein, dass der Preis sich nach oben bewegt, um diese Trendlinie von unten zu testen und dann nach unten abprallt, und dann können wir unseren Verkaufs- oder Leerverkaufsauftrag nahe dieser Abwärtstrendlinie platzieren.

Die folgenden Angaben beziehen sich auf die Aufwärtstrendlinie:

Wir können sehen, dass es in der vorherigen Abbildung klar ist, dass wir eine Aufwärtsbewegung haben, und wenn wir versuchen, eine Verbindung zwischen den letzten drei Tiefs herzustellen, können wir feststellen, dass sie auf der gleichen Linie nach oben verlaufen.

Nachfolgend ist ein Beispiel für die Aufwärtstrendlinie des Marktes zu sehen:

Wie wir in der vorhergehenden Grafik sehen können, haben wir eine Aufwärtstrendlinie, die mehrmals berührt wurde und nach dem Finden der Kaufkraft nach oben abprallte, was die Existenz eines Aufwärtstrends bestätigt.

Das Folgende gilt für die Abwärtstrendlinie:

Wir können sehen, dass in der vorherigen Abbildung deutlich eine Abwärtsbewegung existiert, und wenn wir versuchen, zwischen den letzten drei Hochs zu verbinden, können wir feststellen, dass sie auf der gleichen Linie sind, die sich nach unten bewegt.

Nachfolgend ist ein Beispiel für eine Abwärtstrendlinie des Marktes zu sehen:

Wie wir in der vorhergehenden Grafik sehen können, haben wir eine Abwärtstrendlinie, die mehrmals berührt wurde und sich erholte, nachdem sie die Verkaufskraft gefunden hatte, um sich nach unten zu bewegen, was die Existenz eines Abwärtstrends bestätigt.

1. Das System der Aufwärtstrendlinien

Wir müssen ein Programm erstellen, mit dem der MetaTrader 5 automatisch eine Aufwärtstrendlinie erstellen kann, die unter den Kursen für eine mögliche Aufwärtsbewegung zu sehen ist. Wir brauchen das Programm, um die Preistiefs zu überprüfen und um festzustellen, ob es eine Aufwärtstrendlinie bei jedem Tick gibt. Anschließend wird die vorherige Aufwärtstrendlinie gelöscht und eine aktualisierte blaue Linie unterhalb der Preistiefs erstellt. 

Dazu können wir die folgenden Schritte als eine der Methoden verwenden.

Erkennen der ersten Kerze durch Erstellen einer Integer-Variablen, die dem zurückgegebenen Wert der entsprechenden Eigenschaft des aktuellen Chart entspricht, indem die Funktion „ChartGetInteger“ verwendet wird. Deren Parameter sind:

• chart_id: Um das Chart zu bestimmen, wir verwenden 0 für das aktuelle Chart.
• prop_id: Um die ID der Charteigenschaft zu bestimmen, wir können hier einen der (ENUM_CHART_PROPERTY_INTEGER) Werte verwenden. Wir verwenden CHART_FIRST_VISIBLE_BAR.
• sub_window=0: Um die Anzahl der Unterfenster des Charts zu bestimmen. Wir verwenden 0 für das Hauptfenster des Charts.

int candles=ChartGetInteger(0,CHART_FIRST_VISIBLE_BAR,0);

Erstellung eines Arrays von Kerzen für deren Tiefs vom Typ double: pLow.

double pLow[];

Ausrichten des erstellten Arrays anhand der aktuellen Daten mit der Funktion „ArraySetAsSeries“, um einen booleschen Wert zurückzugeben, der im Erfolgsfall true und im anderen Fall false sein wird.

ArraySetAsSeries(pLow,true);

Füllen des erstellten pLow-Arrays mit Daten durch Verwendung der Funktion „CopyLow“, um die Tiefs des aktuellen Symbols zum aktuellen Zeitpunkt zu ermitteln. Die Parameter sind:

• symbol_name: Zur Bestimmung des Symbolnamens, wir verwenden „_Symbol“, das aktuelle Symbol des Charts.
• timeframe: Um den Zeitrahmen zu bestimmen, verwenden wir _Period, der für den aktuellen Zeitrahmen steht.
• start_pos: Um die Anfangsposition des zu kopierenden Elements zu bestimmen, wir verwenden 0.
  
• count: Um die Anzahl der zu kopierenden Daten zu bestimmen, wir verwenden die zuvor erstellte Variable „candles“.
  
• rates_array[]: Um das zu Zielarray zu bestimmen, wir verwenden das Array pLow.
  

CopyLow(_Symbol,_Period,0,candles,pLow);

Erstellen und Berechnen des Hochs der Kerze durch Erstellen einer Integer-Variablen „candleLow“, die dem Tief des Arrays entspricht, und Verwendung der Funktion „ArrayMinimum“, um das kleinste Element im Array zurückzugeben. Die Parameter:

• array[]: Um das Array zu bestimmen, es wird das Array pLow verwendet.
  
• start=0: Um den Index zu bestimmen, mit dem die Prüfung beginnen soll, wird der Wert 0 verwendet.
  
• count=WHOLE_ARRAY: Um die Anzahl der geprüften Elemente zu ermitteln, werden wir die (Kerzen) verwenden.
  

int candleLow = ArrayMinimum(pLow,0,candles);

Erstellung eines Preis-Arrays „pArray“ mit Hilfe der Funktion „MqlRates“, die Informationen über Preise, Volumen und Spread speichert.

MqlRates pArray[];

Ausrichten des Preis-Arrays „pArray“ mit Hilfe der Funktion „ArraySetAsSeries“.

ArraySetAsSeries(pArray,true);

Kopieren von Preisdaten in das Preis-Array, nachdem eine Integer-Variable mit dem Namen „Data“ erstellt wurde, und anschließendes Verwenden der Funktion „CopyRates“, um die historischen Daten der MqlRates-Struktur zu erhalten. Die Parameter sind:

• symbol_name: Zur Bestimmung des Symbolnamens, wir verwenden „_Symbol“, das aktuelle Symbol des Charts.
• timeframe: Um den Zeitrahmen zu bestimmen, verwenden wir _Period für den aktuellen Zeitrahmen.
• start_pos: Um die Startposition zu bestimmen, wir verwenden 0.
• count: Um die Anzahl der zu kopierenden Daten zu bestimmen, wir verwenden die erstellte Variable candles.
  
• rates_array[]: Um das zu Ziel-Array zu bestimmen, wir verwenden pArray.
  

int Data = CopyRates(_Symbol,_Period,0,candles,pArray);

Löschen einer zuvor erstellten Trendlinie mit der Funktion „ObjectDelete“, um ein bestimmtes Objekt aus einem bestimmten Chart zu entfernen. Die Parameter sind:

• chart_id: Zur Bestimmung des Chart-Identifikators wird 0 für das aktuelle Chart verwendet.
• Name: Um den Namen des zu entfernenden Objekts anzugeben, geben wir „UpwardTrendline“ als Namen an.

ObjectDelete(_Symbol,"UpwardTrendline");

Erstellen einer neuen Trendlinie mit der Funktion „ObjectCreate“, um ein Trendlinienobjekt zu erstellen. Die Parameter sind:

• chart_id: Zur Bestimmung des Chart-Identifikators wird 0 für das aktuelle Chart verwendet.
• name: Um den Namen des Objekts zu spezifizieren, geben wir „UpwardTrendline“ als Namen an.
• type: Um den Objekttyp zu bestimmen, werden wir die „OBJ_TREND“ verwenden, um eine Trendlinie zu erstellen.
• nwin: um den Fensterindex zu bestimmen, verwenden wir den Wert 0, um das Fenster den Hauptcharts verwenden.
• time1: Um den Zeitpunkt auf dem Chart zu bestimmen, wir verwenden pArray[candleLow].time.
• price1: Um den Preis des ersten Ankers zu bestimmen, wir verwenden pArray[candleLow].low.
• timeN: Um die Zeit des Ankerpunkts N zu bestimmen, wird pArray[0].time verwendet.
• priceN: Um den Preis des Ankerpunktes N zu bestimmen, wir verwenden pArray[0].low.

ObjectCreate(_Symbol,"UpwardTrendline",OBJ_TREND,0,pArray[candleLow].time,pArray[candleLow].low,pArray[0].time,pArray[0].low);

Bestimmung der Farbe der Trendlinie mit Hilfe der Funktion „ObjectSetInteger“, um den Wert als Farbe des Objekts festzulegen. Die Parameter sind:

• chart_id: Die ID des Charts, wir verwenden den Wert 0, der für das aktuelle Chart.
• name: Der Name des Objekts, wir verwenden den vordefinierten Namen des Objekts „UpwardTrendline“.
• prop_id: Die ID der Objekteigenschaft, wir werden eine der ENUM_OBJECT_PROPERTY_INTEGER verwenden: OBJPROP_COLOR.
• prop_value: Der Wert der Eigenschaft, wir werden die Farbe Blau (Blue) für die erstellte Trendlinie verwenden.

ObjectSetInteger(0,"UpwardTrendline",OBJPROP_COLOR,Blue);

Bestimmung des Stils der Trendlinie durch die Verwendung der Funktion „ObjectSetInteger“. Aber wir werden auch andere ganzzahligen Eigenschaften aus „NUM_OBJECT_PROPERTY_INTEGER“, nämlich „OBJPROP_STYLE“ und prop_value „STYLE_SOLID“ für den Stil der erstellten Trendlinie verwenden.

ObjectSetInteger(0,"UpwardTrendline",OBJPROP_STYLE,STYLE_SOLID);

Bestimmen der Breite der Trendlinie durch die Verwendung der Funktion „ObjectSetInteger“. Aber wir werden auch andere ganzzahligen Eigenschaften aus „NUM_OBJECT_PROPERTY_INTEGER“, nämlich „OBJPROP_WIDTH“ und für prop_value 3 als Breite der erstellten Trendlinie verwenden .

ObjectSetInteger(0,"UpwardTrendline",OBJPROP_WIDTH,3);

Bestimmen der Trendlinie als Strahl durch die Verwendung der Funktion „ObjectSetInteger“. Aber wir werden auch eine Eigenschaft aus „NUM_OBJECT_PROPERTY_INTEGER“ verwenden, „OBJPROP_RAY_RIGHT“ und der Wert von prop wird auf true gesetzt.

ObjectSetInteger(0,"UpwardTrendline",OBJPROP_RAY_RIGHT,true);

Im Folgenden finden Sie den vollständigen Code für dieses System, das automatisch eine Aufwärtstrendlinie erstellt:

//+------------------------------------------------------------------+
//|                                       UpwardTrendline System.mq5 |
//+------------------------------------------------------------------+
void OnTick()
  {
   int candles=ChartGetInteger(0,CHART_FIRST_VISIBLE_BAR,0);
   double pLow[];
   ArraySetAsSeries(pLow,true);
   CopyLow(_Symbol,_Period,0,candles,pLow);
   int candleLow = ArrayMinimum(pLow,0,candles);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int Data = CopyRates(_Symbol,_Period,0,candles,pArray);
   ObjectDelete(_Symbol,"UpwardTrendline");
   ObjectCreate(_Symbol,"UpwardTrendline",OBJ_TREND,0,pArray[candleLow].time,pArray[candleLow].low,pArray[0].time,pArray[0].low);
   ObjectSetInteger(0,"UpwardTrendline",OBJPROP_COLOR,Blue);
   ObjectSetInteger(0,"UpwardTrendline",OBJPROP_STYLE,STYLE_SOLID);
   ObjectSetInteger(0,"UpwardTrendline",OBJPROP_WIDTH,3);
   ObjectSetInteger(0,"UpwardTrendline",OBJPROP_RAY_RIGHT,true);
  }
//+------------------------------------------------------------------+

Nachdem wir diesen Code geschrieben haben, kompilieren wir ihn, er darf keine Fehler enthalten.  Danach finden wir den Expert Advisor (EA) im Navigator-Fenster wie im Folgenden dargestellt:

Wenn Sie diesen Experten auf das Chart ziehen, sehen Sie dies Fenster dieses Programms:

Nachdem Sie das Häkchen neben „Algo Trading zulassen“ gesetzt und auf „OK“ gedrückt haben, wird der EA auf dem Chart gestartet und wir sind bereit, die gewünschte Aktion basierend auf diesem EA zu sehen, wie im folgenden Beispiel:

Wie wir in der vorherigen Grafik sehen können, dass wir den EA haben, ist das gleiche wie es ist offensichtlich in der oberen rechten Ecke und wir haben die blaue Aufwärtstrendlinie ist unter den Preisen gezeichnet.

2. Das System der Abwärtstrendlinien

Wir müssen ein Programm erstellen, mit dem der MetaTrader 5 automatisch eine Abwärtstrendlinie erstellen kann, die über den Kursen für eine mögliche Abwärtsbewegung zu sehen ist. Das Programm muss bei jedem Tick prüfen, ob der Kurs einen Höchststand erreicht hat und ob es eine Abwärtstrendlinie gibt. Dann löschen wir die vorherige Abwärtstrendlinie und erstellen eine aktualisierte blaue Linie über den Höchstständen des Kurses. 

Um dies zu tun, können wir den unten stehenden vollständigen Code als eine der Methoden, die verwendet werden können.

//+------------------------------------------------------------------+
//|                                     DownwardTrendline System.mq5 |
//+------------------------------------------------------------------+
void OnTick()
  {
   int candles=ChartGetInteger(0,CHART_FIRST_VISIBLE_BAR,0);
   double pHigh[];
   ArraySetAsSeries(pHigh,true);
   CopyHigh(_Symbol,_Period,0,candles,pHigh);
   int candleHigh = ArrayMaximum(pHigh,0,candles);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int Data = CopyRates(_Symbol,_Period,0,candles,pArray);
   ObjectDelete(_Symbol,"DnwardTrendline");
   ObjectCreate(_Symbol,"DnwardTrendline",OBJ_TREND,0,pArray[candleHigh].time,pArray[candleHigh].high,pArray[0].time,pArray[0].high);
   ObjectSetInteger(0,"DnwardTrendline",OBJPROP_COLOR,Blue);
   ObjectSetInteger(0,"DnwardTrendline",OBJPROP_STYLE,STYLE_SOLID);
   ObjectSetInteger(0,"DnwardTrendline",OBJPROP_WIDTH,3);
   ObjectSetInteger(0,"DnwardTrendline",OBJPROP_RAY_RIGHT,true);
  }
//+------------------------------------------------------------------+

Unterschiede in diesem Code:

Schaffung eines Array mit den Hochs der Kerzen.

double pHigh[];

Ausrichten des erstellten Arrays anhand der aktuellen Daten.

ArraySetAsSeries(pHigh,true);

Füllen des Arrays mit Daten.

CopyHigh(_Symbol,_Period,0,candles,pHigh);

Erstellen und Berechnen des Hochs der (Kerzen-)Variable

int candleHigh = ArrayMaximum(pHigh,0,candles);

Löschung einer früheren Abwärtstrendlinie

ObjectDelete(_Symbol,"DnwardTrendline");

Schaffung einer neuen Abwärtstrendlinie

ObjectCreate(_Symbol,"DnwardTrendline",OBJ_TREND,0,pArray[candleHigh].time,pArray[candleHigh].high,pArray[0].time,pArray[0].high);

Festlegen der Farbe der abwärts gerichteten Trendlinie auf blau mit Hilfe des Parameters „OBJPROP_COLOR“.

ObjectSetInteger(0,"DnwardTrendline",OBJPROP_COLOR,Blue);

Festlegung des Stils der Abwärtstrendlinie als durchgezogene Linie durch Verwendung von „OBJPROP_STYLE“ und „STYLE_SOLID“

ObjectSetInteger(0,"DnwardTrendline",OBJPROP_STYLE,STYLE_SOLID);

Festlegung der Breite der Abwärtstrendlinie auf den Wert 3 mit Hilfe des Parameters „OBJPROP_WIDTH“.

ObjectSetInteger(0,"DnwardTrendline",OBJPROP_WIDTH,3);

Bestimmung des Abwärtstrendlinienstrahls mit Hilfe des „OBJPROP_RAY_RIGHT“

ObjectSetInteger(0,"DnwardTrendline",OBJPROP_RAY_RIGHT,true);

Nach dem fehlerfreien Kompilieren finden wir den Experten auch im Navigator-Fenster, wie bereits erwähnt. Nach dem Start des EAs können wir die erforderliche Aktion auf der Grundlage dieses EA in Form der Abwärtstrendlinie sehen:

Wie wir auf dem Chart in der oberen rechten Ecke sehen können, haben wir den EA gestartet und wir haben die Abwärtstrendlinie über den Preisen gezeichnet, da es eine Verkaufskraft um dieses Niveau gibt.

Unterstützungsniveaus und MQL5

Das Unterstützungsniveau ist ein Preisniveau oder eine Zone, die unter den aktuellen Preisen zu finden ist, und wir können einen Rebound nach oben in ihrer Nähe finden, weil es eine Kaufkraft dort gibt. Sie sind also sehr wichtig, da wir sie als Kaufpunkte verwenden können. Es gibt viele Formen von Unterstützungsebenen, eine davon ist die horizontale Unterstützungsebene. Ihre Form sieht folgendermaßen aus:

Nachfolgend ein Beispiel für das Unterstützungsniveau auf dem Markt:

Wie wir im vorherigen Chart sehen können, befindet sich unter den Kursen eine grüne Unterstützungslinie, die als Abprallniveau nach oben genutzt werden kann.

Wir brauchen das Programm, um die Preistiefs zu überprüfen und um festzustellen, ob für einen Tick eine Unterstützung gibt. Dann löschen wir die vorherige Unterstützungslinie und erstellen eine aktualisierte grüne Linie unter den Tiefstständen des Kurses. Wir können diese Unterstützungslinie mit MQL5 genauso zeichnen und behandeln wie den vollständigen Code unten:

//+------------------------------------------------------------------+
//|                                          Support Line System.mq5 |
//+------------------------------------------------------------------+
void OnTick()
  {
   int candles=ChartGetInteger(0,CHART_FIRST_VISIBLE_BAR,0);
   double pLow[];
   ArraySetAsSeries(pLow,true);
   CopyLow(_Symbol,_Period,0,candles,pLow);
   int candleLow = ArrayMinimum(pLow,0,candles);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int Data = CopyRates(_Symbol,_Period,0,candles,pArray);
   ObjectDelete(_Symbol,"supportLine");
   ObjectCreate(_Symbol,"supportLine",OBJ_HLINE,0,pArray[candleLow].time,pArray[candleLow].low,pArray[0].time,pArray[0].low);
   ObjectSetInteger(0,"supportLine",OBJPROP_COLOR,Green);
   ObjectSetInteger(0,"supportLine",OBJPROP_STYLE,STYLE_SOLID);
   ObjectSetInteger(0,"supportLine",OBJPROP_WIDTH,3);
   ObjectSetInteger(0,"supportLine",OBJPROP_RAY,true);
  }
//+------------------------------------------------------------------+

Der Unterschied in diesem Code.

Löschen aller bisherigen Unterstützungslinien mit dem Namen „supportLine“

ObjectDelete(_Symbol,"supportLine");

Erstellen einer neuen Unterstützungslinie durch Verwendung von „OBJ_HLINE“ als Typ des gewünschten Objekts

ObjectCreate(_Symbol,"supportLine",OBJ_HLINE,0,pArray[candleLow].time,pArray[candleLow].low, pArray[0].time,pArray[0].low);

Bestimmung der Farbe der Stützlinie mit Hilfe des Parameters „OBJPROP_COLOR“.

ObjectSetInteger(0,"supportLine",OBJPROP_COLOR,Green);

Bestimmung des Unterstützungslinienstils mit Hilfe von „OBJPROP_STYLE“ und „STYLE_SOLID“

ObjectSetInteger(0,"supportLine",OBJPROP_STYLE,STYLE_SOLID);

Bestimmung der Unterstützungslinienbreite mit Hilfe des Parameters „OBJPROP_WIDTH“.

ObjectSetInteger(0,"supportLine",OBJPROP_WIDTH,3);

Bestimmung des Strahls der Unterstützungslinie mit Hilfe des „OBJPROP_RAY“

ObjectSetInteger(0,"supportLine",OBJPROP_RAY,true);

Nachdem wir diesen Code ohne Fehler kompiliert haben, können wir ihn wie zuvor beschrieben auf dem Chart starten. Danach finden wir ihn, wir er auf dem Chart läuft und wir können seine Aktion finden, wie wir die Unterstützungslinie finden können. Es ist das gleiche wie das unten gezeichnete Beispiel :

Wie wir in der obigen Chart sehen können, läuft der EA Support System, siehe obere rechte Ecke, und wir erkennen eine Unterstützungslinie unter den Preisen.

Widerstandsniveaus und MQL5

Das Widerstandsniveau ist ein Preisniveau oder eine Zone, die über den aktuellen Preisen zu finden ist, und wir können einen Rebound in seiner Nähe finden, weil es eine Verkaufskraft um diese Ebenen herum gibt. Sie sind also sehr wichtig, da wir sie als Verkaufsargumente nutzen können. Es gibt viele Formen dieser Widerstandsniveaus, und eines davon ist das horizontale Widerstandsniveau, das im Folgenden dargestellt wird:

Nachstehend ein Beispiel für ein Widerstandsniveau des Marktes:

Wie wir im obigen Chart sehen können, befindet sich über den Kursen eine rote Widerstandslinie, die als Abprallniveau nach unten verwendet werden kann , da um dieses Niveau herum eine Kaufkraft besteht. 

Das Programm muss bei jedem Tick das Hoch prüfen und, ob es eine Widerstandslinie gibt. Dann löschen wir die vorherige Widerstandslinie und erstellen eine aktualisierte rote Linie über den Hochs der Kurse. Wir können diese Widerstandslinie mit MQL5 genauso zeichnen und behandeln wie den vollständigen Code unten:

//+------------------------------------------------------------------+
//|                                       Resistance Line System.mq5 |
//+------------------------------------------------------------------+
void OnTick()
  {
   int candles=ChartGetInteger(0,CHART_FIRST_VISIBLE_BAR,0);
   double pHigh[];
   ArraySetAsSeries(pHigh,true);
   CopyHigh(_Symbol,_Period,0,candles,pHigh);
   int candleHigh = ArrayMaximum(pHigh,0,candles);
   MqlRates pArray[];
   ArraySetAsSeries(pArray,true);
   int Data = CopyRates(_Symbol,_Period,0,candles,pArray);
   ObjectDelete(_Symbol,"resistanceLine");
   ObjectCreate(_Symbol,"resistanceLine",OBJ_HLINE,0,pArray[candleHigh].time,pArray[candleHigh].high,pArray[0].time,pArray[0].high);
   ObjectSetInteger(0,"resistanceLine",OBJPROP_COLOR,Red);
   ObjectSetInteger(0,"resistanceLine",OBJPROP_STYLE,STYLE_SOLID);
   ObjectSetInteger(0,"resistanceLine",OBJPROP_WIDTH,3);
   ObjectSetInteger(0,"DnwardTrendline",OBJPROP_RAY_RIGHT,true);
  }
//+------------------------------------------------------------------+

Der Unterschied in diesem Code.

Löschen einer früheren Widerstandslinie mit dem Namen „resistanceLine“

ObjectDelete(_Symbol,"resistanceLine");

Erstellen einer neuen Widerstandslinie durch Verwendung von „OBJ_HLINE“ als Typ des gewünschten Objekts

ObjectCreate(_Symbol,"resistanceLine",OBJ_HLINE,0,pArray[candleHigh].time,pArray[candleHigh].high,pArray[0].time,pArray[0].high);

Bestimmung der Farbe der Widerstandslinie mit Hilfe von OBJPROP_COLOR

ObjectSetInteger(0,"resistanceLine",OBJPROP_COLOR,Red);

Bestimmung des Widerstandslinien-Stils mit Hilfe von „OBJPROP_STYLE“ und „STYLE_SOLID“

ObjectSetInteger(0,"resistanceLine",OBJPROP_STYLE,STYLE_SOLID);

Bestimmung der Breite der Widerstandslinie mit Hilfe von OBJPROP_WIDTH

ObjectSetInteger(0,"resistanceLine",OBJPROP_WIDTH,3);

Bestimmung des Widerstandslinienstrahls mit Hilfe von OBJPROP_RAY_RIGHT

ObjectSetInteger(0,"DnwardTrendline",OBJPROP_RAY_RIGHT,true);

Nachdem wir diesen Code ohne Fehler kompiliert haben, können wir ihn wie zuvor beschrieben auf dem Chart starten. Danach werden wir feststellen, dass der EA Resistance System auf dem Chart gestartet wurde und wir können seine Aktion wie die folgende finden:

Wie wir im obigen Chart sehen können, läuft der EA Resistance System und wir haben eine Widerstandslinie über den Preisen erstellt.

Schlussfolgerung

Es wird nun vorausgesetzt, dass Sie drei der wichtigen Linien, die in unserem Handel verwendet werden können, im Detail verstehen. Die Trendlinien (Aufwärts- und Abwärtstrendlinien), Unterstützungs- und Widerstandslinien, wie wir gelernt haben, was sie sind und wie wir sie nutzen können. Wir haben auch gelernt, wie wir mit MQL5 umgehen können, um sie automatisch zu zeichnen, indem wir unser eigenes System für jeden einzelnen von ihnen erstellen. Sie können diesen Code auch weiterentwickeln, indem Sie das Senden von Aufträgen hinzufügen, um darauf basierende Handel auszuführen, aber Sie müssen alles testen, bevor Sie es auf Ihrem realen Konto verwenden, um sicherzustellen, dass es profitabel ist, da das Hauptziel dieses Artikels nur pädagogisch ist.

Ich hoffe, dass dieser Artikel für Sie nützlich war und Sie gelernt haben, wie Sie die genannten Tools zu Ihren Gunsten einsetzen können, indem Sie sie als Teil eines anderen fortgeschrittenen Systems oder einzeln verwenden. Ich hoffe also, dass Sie nützliche Einblicke in das Thema dieses Artikels oder eines verwandten Themas erhalten haben, um bessere Handelsergebnisse zu erzielen und diese mit nützlichen und profitablen Tools zu verbessern. Ich hoffe auch, dass Sie versucht haben, die erwähnten Codes selbst zu testen und zu schreiben, um davon zu profitieren und Ihre Programmierfähigkeiten zu verbessern.

Wenn Sie diesen Artikel nützlich finden und Sie möchten mehr Artikel über die MQL5 lesen und wie man ein Handelssystem mit den beliebtesten technischen Indikatoren entwirft, können Sie meine früheren Artikel lesen, um mehr darüber zu erfahren, wie man ein Handelssystem auf der Grundlage der beliebtesten technischen Indikatoren wie der gleitende Durchschnitt, RSI, MACD, Stochastik, Parabolic SAR etc. entwirft.

Wenn Sie auch mehr über einige der Grundlagen von MQL5 erfahren möchten und warum und wie Sie Ihr algorithmisches Handelssystem entwerfen, können Sie auch meinen früheren Artikel darüber lesen.