Wie man Smart Money Concepts (SMC) in Verbindung mit dem RSI-Indikator in einen EA integriert

Einführung

In der schnelllebigen Welt des Devisenhandels ist ein zuverlässiges und effizientes Handelssystem entscheidend für den Erfolg. Für den Handel im Allgemeinen gibt es eine Vielzahl von Begriffen, Konzepten und Strategien. Oftmals kann dies überfordernd sein, insbesondere für neue Händler, die noch versuchen, in der Handelsbranche Fuß zu fassen.  Smart Money Concept (SMC) ist eines der trendigen Konzepte im Devisenhandel, aber es kann manchmal für neue Händler oder für jeden schwierig sein, Smart-Money-Konzepte in ihrem Handel zu verwenden.

Um dieses Problem zu lösen, sollte es ein robustes Instrument zur Automatisierung von Handelsentscheidungen auf der Grundlage der Marktstruktur und der Preisentwicklung geben. Die Lösung besteht darin, das Smart Money Concept (Break of Structure) mit dem beliebten Indikator Relative Strength Index (RSI) zu verbinden. Diese Kombination verschafft einen strategischen Vorteil, indem sie sowohl die Preis- als auch die Momentum-Analyse nutzt, was die Genauigkeit der Handelsein- und -ausstiege erhöht und so die Handelsleistung optimiert.

Die Idee des Expert Advisor-Beispiels

Die Idee und Funktionalität dieses Expert Advisor-Beispiels ist, dass der Experte die Swing-Tiefs und die Swing-Hochs erkennt, da einige Smart Money Concepts die Swings nutzen. Der RSI-Indikator verwendet weiterhin die traditionelle Umrechnung des 70er Niveaus für einen überkauften Markt und des 30er Niveaus für einen überverkauften Markt, und der Zeitraum beträgt 8. Wenn der Marktpreis über dem zuvor festgestellten Hoch liegt, deutet dies auf den Bruch der Struktur nach oben hin. Ähnlich verhält es sich, wenn der Marktpreis unter dem zuvor festgestellten Tiefpunkt liegt, was auf einen Bruch der Struktur (Break Of Structure) nach unten hinweist.

Lassen Sie uns nun das Expert Advisor-Beispiel entwickeln

 Der EA zielt darauf ab, Kauf- und Verkaufsaufträge basierend auf den Marktbedingungen und RSI-Niveaus zu eröffnen. Genauer gesagt, er:

1. Identifiziert Hochs und Tiefs auf dem Markt.
2. Prüft, ob der Markt über dem vorherigen Swing-Hoch (für ein Verkaufssignal) oder unter dem vorherigen Swing-Tief (für ein Kaufsignal) liegt.
3. Bestätigt dann das Signal mit RSI-Ebenen.

Grundsätzlich sucht der Expert Advisor nach einem Bruch der Struktur oder einem Bruch der vorherigen Schwankungen (Hoch/Tief), und wenn der RSI-Wert innerhalb der festgelegten Einstellungen liegt, wird eine Marktorder ausgeführt (KAUFEN/VERKAUFEN).

Code-Aufschlüsselung

1. Eigenschaften und Einschlüsse

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

Diese Zeilen definieren die Eigenschaften des EA und enthalten die Handelsbibliothek, die für die Ausführung der Handelsgeschäfte erforderlich ist.

2. Globale Variablen und Eingaben

long MagicNumber = 76543;
double lotsize = 0.01;
input int RSIperiod = 8;
input int RSIlevels = 70;
int stopLoss = 200;
int takeProfit = 500;
bool closeSignal = false;

• MagicNumber: Ein eindeutiger Bezeichner für die Handelsgeschäfte des EA.
• Lotsize: Der Umfang der einzelnen Handelsgeschäfte.
• RSIperiod: Periodenlänge für die RSI-Berechnungen.
• RSIlevels: Schwellenwert für den RSI.
• Stoploss and takeProfit: SL- und TP-Niveau in Punkten.
• CloseSignal: Flag für das Schließen von Positionen auf der Grundlage des entgegengesetzten Signals im Vergleich zur aktuell offenen Position.
  

3. RSI-Variablen

int handle;
double buffer[];
MqlTick currentTick;
CTrade trade;
datetime openTimeBuy = 0;
datetime openTimeSell = 0;

• Handle: Handle für den RSI-Indikator.
  
• Buffer: Array zum Speichern der RSI-Werte.
• currentTick: Struktur zur Speicherung der aktuellen Marktpreise.
• Trade: Dies ist das Objekt für die Handelsgeschäfte.
• openTimeBuy and openTimeSell: Die Zeitstempel für die letzten Kauf- und Verkaufssignale und Operationen.

4. Initialisierungsfunktion

int OnInit() {
    if (RSIperiod <= 1) {
        Alert("RSI period <= 1");
        return INIT_PARAMETERS_INCORRECT;
    }
    if (RSIlevels >= 100 || RSIlevels <= 50) {
        Alert("RSI level >= 100 or <= 50");
        return INIT_PARAMETERS_INCORRECT;
    }
    trade.SetExpertMagicNumber(MagicNumber);
    handle = iRSI(_Symbol, PERIOD_CURRENT, RSIperiod, PRICE_CLOSE);
    if (handle == INVALID_HANDLE) {
        Alert("Failed to create indicator handle");
        return INIT_FAILED;
    }
    ArraySetAsSeries(buffer, true);
    return INIT_SUCCEEDED;
}

• Validiert die RSI-Periode und -Stufen.
• Legt die magische Zahl für die Handelsidentifikation fest.
• Erzeugt einen RSI-Indikator-Handle.
• Legt den Puffer als Zeitreihe fest, um RSI-Werte in umgekehrter chronologischer Reihenfolge zu speichern.
  

5. Deinitialisierungsfunktion

void OnDeinit(const int reason) {
    if (handle != INVALID_HANDLE) {
        IndicatorRelease(handle);
    }
}

Gibt den Handle des RSI-Indikators frei, wenn der EA entfernt wird.

6. OnTick-Funktion

Wie wir alle wissen, enthält die OnTick-Funktion die Kernlogik für die Erkennung von Signalen und die Ausführung des Handels.

void OnTick() {
    static bool isNewBar = false;
    int newbar = iBars(_Symbol, _Period);
    static int prevBars = newbar;
    if (prevBars == newbar) {
        isNewBar = false;
    } else if (prevBars != newbar) {
        isNewBar = true;
        prevBars = newbar;
    }

Erstens: Da die Funktion OnTick bei jedem Tick ausgeführt wird, müssen wir sicherstellen, dass wir ein Signal oder einen Handel nur einmal pro Balken ausführen, wenn wir es erkennen. Wir erreichen dies, indem wir eine statische boolesche Variable isNewBar deklarieren. Die wir zunächst auf false setzen und dann eine int-Variable newBar deklarieren, der die Funktion iBars zugewiesen wird, damit wir jeden Balken verfolgen können.

• static bool isNewBar: Verfolgt, ob sich ein neuer Balken (Kerze) gebildet hat.
• int newbar = iBars(_Symbol, _Period): Ermittelt die aktuelle Anzahl der Balken im Chart.
• static int prevBars = newbar: Initialisiert die vorherige Balkenzählung.
• Der if-else-Block prüft, ob sich die Balkenanzahl geändert hat, was auf einen neuen Balken hinweist. Wenn sich ein neuer Balken gebildet hat, wird „isNewBar“ auf „true“ gesetzt, andernfalls ist es „false“.

    const int length = 10;
    int right_index, left_index;
    int curr_bar = length;
    bool isSwingHigh = true, isSwingLow = true;
    static double swing_H = -1.0, swing_L = -1.0;

Anschließend müssen wir die Variablen für die Erkennung der Höchst- und Tiefstwerte der Schwankungen festlegen:

• const int length = 10: Legt den Bereich für die Erkennung der Schwellenhochs und Schwellentiefs fest.
• int right_index, left_index: Indizes der Balken rechts und links vom aktuellen Balken.
• int curr_bar = length: Setzt den aktuellen Balkenindex.
• bool isSwingHigh = true, isSwingLow = true: Dies sind Flags, um festzustellen, ob ein Balken ein Swing-Hoch oder ein Swing-Tief ist.
• static double swing_H = -1.0, swing_L = -1.0: Speichert die zuletzt erkannten Höchst- und Tiefstwerte der Schwankungen.

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

Die Variablen sind vom Typ double und die Variable „Ask“ wird verwendet, um den aktuellen Marktpreis ASK zu erhalten, und die Variable „Bid“ wird verwendet, um den aktuellen Marktpreis BID zu erhalten:

• double Ask: Ermittelt den aktuellen Briefkurs
• double Bid: Ermittelt den aktuellen Geldkurs
• NormalisierenDouble: Rundet den Preis auf die richtige Anzahl von Dezimalstellen.

    if (isNewBar) {
        for (int a = 1; a <= length; a++) {
            right_index = curr_bar - a;
            left_index = curr_bar + a;

            if ((high(curr_bar) <= high(right_index)) || (high(curr_bar) < high(left_index))) {
                isSwingHigh = false;
            }
            if ((low(curr_bar) >= low(right_index)) || (low(curr_bar) > low(left_index))) {
                isSwingLow = false;
            }
        }

        if (isSwingHigh) {
            swing_H = high(curr_bar);
            Print("We do have a swing high at: ", curr_bar, " H: ", high(curr_bar));
            drawswing(TimeToString(time(curr_bar)), time(curr_bar), high(curr_bar), 32, clrBlue, -1);
        }
        if (isSwingLow) {
            swing_L = low(curr_bar);
            Print("We do have a swing low at: ", curr_bar, " L: ", low(curr_bar));
            drawswing(TimeToString(time(curr_bar)), time(curr_bar), low(curr_bar), 32, clrRed, +1);
        }
    }

Anschließend wird nach Höchst- und Tiefstständen gesucht. Wird jedoch ein neuer Balken erkannt, prüft die Funktion zuvor die umliegenden Balken innerhalb der definierten „length“, um festzustellen, ob es Swing-Hochs oder Swing-Tiefs gibt. Die Variable length dient dazu, einen Bereich von Balken zu definieren, in dem nach Schwankungen gesucht wird. Für jeden Balken innerhalb des Bereichs vergleicht die Funktion das Hoch/Tief des aktuellen Balkens mit den benachbarten Balken.

Wenn das Hoch des aktuellen Balkens nicht höher ist als die umliegenden Balken, handelt es sich nicht um ein Swing-Hoch. Wenn das Tief des aktuellen Balkens nicht niedriger ist als die umliegenden Balken, handelt es sich nicht um ein Swing-Low. Wenn alle diese Bedingungen erfüllt sind, wird ein Swing-Hoch oder ein Swing-Tief bestätigt, der entsprechende Wert wird gespeichert, und dann wird eine Markierung auf dem Chart mit dem Befehl „drawswing“ Funktion.

    int values = CopyBuffer(handle, 0, 0, 2, buffer);
    if (values != 2) {
        Print("Failed to get indicator values");
        return;
    }

    Comment("Buffer[0]: ", buffer[0],
            "\nBuffer[1]: ", buffer[1]);

• copyBuffer(handle, 0, 0, 2, buffer): Kopiert die neuesten RSI-Werte in den Puffer.
• Wenn die Funktion die RSI-Werte nicht abrufen kann, wird sie beendet.
• Die RSI-Werte werden als Kommentar im Chart angezeigt.

    int cntBuy = 0, cntSell = 0;
    if (!countOpenPositions(cntBuy, cntSell)) {
        return;
    }

„countOpenPositions(cntBuy, cntSell)“ diese Funktion zählt die Anzahl der offenen Kauf- und Verkaufspositionen und, wenn die Funktion fehlschlägt, wird „OnTick“ beendet.

    if (swing_H > 0 && Ask > swing_H && buffer[0] >= 70) {
        Print("Sell Signal: Market is above previous high and RSI >= 70");
        int swing_H_index = 0;
        for (int i = 0; i <= length * 2 + 1000; i++) {
            if (high(i) == swing_H) {
                swing_H_index = i;
                break;
            }
        }
        drawBreakLevels(TimeToString(time(0)), time(swing_H_index), high(swing_H_index), time(0), high(swing_H_index), clrBlue, -1);

        if (cntSell == 0) {
            double Bid = NormalizeDouble(SymbolInfoDouble(_Symbol, SYMBOL_BID), _Digits);
            double sl = Bid + stopLoss * _Point;
            double tp = Bid - takeProfit * _Point;
            trade.PositionOpen(_Symbol, ORDER_TYPE_SELL, lotsize, currentTick.bid, sl, tp, "RSI EA");
        }

        swing_H = -1.0;
        return;
    }

Wie ich bereits erklärt habe, werden wir auf ein Verkaufssignal achten. Die Logik besteht darin, dass der Ask-Kurs über dem vorangegangenen Swing-Hoch liegen muss. Außerdem muss der RSI-Wert etwas größer oder gleich der 70er-Marke sein. Wenn die Bedingungen erfüllt sind, markiert es das Swing-Hoch und zeichnet ein Break-Level auf dem Chart. Wenn es keine offenen Verkaufspositionen gibt, wird eine Verkaufsposition eröffnet, die mit dem berechneten Stop-Loss- und Take-Profit-Niveau eröffnet wird, und dann wird der Swing-High-Wert zurückgesetzt.

    if (swing_L > 0 && Bid < swing_L && buffer[0] <= 30) {
        Print("Buy Signal: Market is below previous low and RSI <= 30");
        int swing_L_index = 0;
        for (int i = 0; i <= length * 2 + 1000; i++) {
            if (low(i) == swing_L) {
                swing_L_index = i;
                break;
            }
        }
        drawBreakLevels(TimeToString(time(0)), time(swing_L_index), low(swing_L_index), time(0), low(swing_L_index), clrRed, +1);

        if (cntBuy == 0) {
            double Ask = NormalizeDouble(SymbolInfoDouble(_Symbol, SYMBOL_ASK), _Digits);
            double sl = Ask - stopLoss * _Point;
            double tp = Ask + takeProfit * _Point;
            trade.PositionOpen(_Symbol, ORDER_TYPE_BUY, lotsize, currentTick.ask, sl, tp, "RSI EA");
        }

        swing_L = -1.0;
        return;
    }
}

Für das Kaufsignal gilt die gleiche umgekehrte Logik: Wenn der Bid-Kurs unter dem vorherigen Swing-Tief liegt und der RSI-Wert kleiner oder gleich der 30er-Marke ist, ist die Kauflogik technisch gesehen in Ordnung und die Bedingung erfüllt. Wenn die Bedingung erfüllt ist, wird das Schwungtief markiert und anschließend eine Bruchmarke auf dem Chart eingezeichnet.  Und wenn es keine offenen Kaufpositionen gibt, wird eine neuer Kaufposition mit den berechneten Stop-Loss- und Take-Profit-Niveaus eröffnet, und schließlich wird der Swing-Low-Wert zurückgesetzt.

Wir versuchen, Folgendes zu erreichen:

_ Ein Verkaufsgeschäft, bei dem alle Bedingungen erfüllt sind:

_ Ein Kaufgeschäft, bei dem alle Bedingungen erfüllt sind:

Die Zusammenfassung der Funktion OnTick:

Der Experte führt bei jedem Tick des Marktes die folgenden wichtigen Aktionen durch

1. Erkennen des neuen Balkens: Er prüft zunächst, ob sich seit dem letzten Tick ein neuer Balken gebildet haben könnte, und behält alle Balken im Auge.
2. Identifiziert „Swing-Highs“ and „Swing-Lows“: Er identifiziert dann Swing-Punkte im Markt, die als Referenzwerte für spätere Zeiten dienen, wenn der Marktpreis über dem Swing High oder unter dem Swing Low liegt.
3. Ruft die RSI-Werte ab: Ruft die neuesten RSI-Werte zur Signalbestätigung ab.
4. Zählt offene Positionen: Verfolgt die aktuell offenen Kauf- und Verkaufspositionen.
5. Erzeugt Handelssignale: Verwendet die Swing-Punkte, d. h. das Swing-Hoch und das Swing-Tief, sowie die RSI-Werte, um Kauf- oder Verkaufssignale zu generieren.
6. Ausführen des Handels: Eröffnet neue Positionen auf der Grundlage der generierten Signale, wenn alle Bedingungen erfüllt sind.

Nutzerdefinierte Funktionen für Hoch-, Tief- und Zeitwerte

double high(int index){
       return (iHigh(_Symbol, _Period, index));
}

double low(int index){
       return (iLow(_Symbol, _Period, index));
}

datetime time(int index){
       return (iTime(_Symbol, _Period, index));
}

Die Funktion high (int index) gibt den Höchstkurs des Balkens am angegebenen Index zurück. Sie nimmt index als Parameter vom Typ „int“ entgegen. Die integrierte MQL5-Funktion iHigh(_Symbol,_Periode,index) wird verwendet, um den Höchstpreis des Balkens bei index für das aktuelle Symbol und die aktuelle Periode zu erhalten. Gefolgt von low (int index) gibt diese Funktion den Tiefstkurs des Balkens am angegebenen index zurück und nimmt index als Parameter an, der vom Typ intund dann haben wir iLow(_Symbol, _Periode, index). Es ist auch eine in MQL5 integrierte Funktion, die das Tief des Balkens bei index für das aktuelle Symbol liefert. Schließlich gibt es noch time (int index), diese Funktion gibt die Zeit des Balkens am angegebenen Index zurück, iTime(_Symbol, _Periode, index) ist ebenfalls eine in MQL5 integrierte Funktion, um die Zeit des Balkens bei index für das aktuelle Symbol und die Periode zu erhalten. iTimes ist vom Datentyp datetime.

Die Funktion zum Zeichnen von Swing-Punkten

void drawswing(string objName, datetime time, double price, int arrCode, color clr, int direction){
   if(ObjectFind(0, objName) < 0){
      ObjectCreate(0, objName, OBJ_ARROW, 0, time, price);
      ObjectSetInteger(0, objName, OBJPROP_ARROWCODE, arrCode);
      ObjectSetInteger(0, objName, OBJPROP_COLOR, clr);
      ObjectSetInteger(0, objName, OBJPROP_FONTSIZE, 10);
      
      if(direction > 0){ObjectSetInteger(0, objName, OBJPROP_ANCHOR, ANCHOR_TOP);}
      if(direction < 0){ObjectSetInteger(0, objName, OBJPROP_ANCHOR, ANCHOR_BOTTOM);}
      
      string text = "";
      string Descr = objName + text;
      ObjectCreate(0, Descr, OBJ_TEXT, 0, time, price);
      ObjectSetInteger(0, Descr, OBJPROP_COLOR, clr);
      ObjectSetInteger(0, Descr, OBJPROP_FONTSIZE, 10);
      
      if(direction > 0){
         ObjectSetString(0, Descr, OBJPROP_TEXT,"  "+text);
         ObjectSetInteger(0, Descr, OBJPROP_ANCHOR, ANCHOR_LEFT_UPPER);
      }
      if(direction < 0){
         ObjectSetString(0, Descr, OBJPROP_TEXT,"  "+text);
         ObjectSetInteger(0, Descr, OBJPROP_ANCHOR, ANCHOR_LEFT_LOWER);
      }
   }
   ChartRedraw(0);
}

Mit dieser Funktion werden visuelle Markierungen für die Swing-Punkte (Hochs und Tiefs) im Chart erstellt. Sie benötigt die folgenden Parameter:

• ObjName: Ist der Name des zu erstellenden Objekts.
• Time: Der Zeitpunkt, zu dem der Ausschlag stattgefunden hat oder festgestellt wurde.
• Price: Der Preis, zu dem sich der „Swing“ gebildet hat.
• ArrCode: Pfeilcode für die visuelle Darstellung.
• Clr: Farbe des Pfeils.
• Direction: Richtung des „Swing“ (positiv für Hoch, negativ für Tief).

Funktionsweise

1. Erstellung von Objekten:

• ObjectFind(0, objName) < 0: Prüft, ob ein Objekt mit dem angegebenen Namen bereits existiert.
• ObjectCreate(0, objName, OBJ-ARROW, 0, time, price): Erzeugt ein Pfeilobjekt zum angegebenen Zeitpunkt und Preis.
• ObjectSetInteger(0, objName, OBJPROP-ARROWCODE, arrCode): Stellen Sie den Pfeilcode ein.
• ObjectSetInteger(0, objName, OBJPROP-COLOR, clr): Legt die Pfeilfarbe fest.
• ObjectSetInteger(0, objName, OBJPROP-FONTSIZE, 10): Legt die Schriftgröße fest.

2. Behandlung der Richtung:

• Legt die Ankerposition auf der Grundlage der Richtung fest.
• OBJPROP-ANCHOR: Legt die Position des Ankerpunkts für den Pfeil fest.

3. Erstellung von Textobjekten:

• Erstellt ein Textobjekt, das mit dem Pfeil verbunden ist, um zusätzliche Informationen anzuzeigen.
• Legt Farbe, Größe und Ankerpunkt für den Text auf der Grundlage der Richtung fest.

4. Chart-Update:

• ChartRedraw(0): Zeichnet das Chart neu, um die Änderungen wiederzugeben.
  

Funktion zum Zeichnen von Bruchlinien

void drawBreakLevels(string objName, datetime time1, double price1, datetime time2, double price2, color clr, int direction){
   if(ObjectFind(0, objName) < 0){
         ObjectCreate(0, objName, OBJ_ARROWED_LINE, 0, time1, price1, time2, price2);
         ObjectSetInteger(0, objName, OBJPROP_TIME, 0, time1);
         ObjectSetDouble(0, objName, OBJPROP_PRICE, 0, price1);
         ObjectSetInteger(0, objName, OBJPROP_TIME, 1, time2);
         ObjectSetDouble(0, objName, OBJPROP_PRICE, 1, price2);
         ObjectSetInteger(0, objName, OBJPROP_COLOR, clr);
         ObjectSetInteger(0, objName, OBJPROP_WIDTH, 2);
         
         string text = "Break";
         string Descr = objName + text;
         ObjectCreate(0, Descr, OBJ_TEXT, 0, time2, price2);
         ObjectSetInteger(0, Descr, OBJPROP_COLOR, clr);
         ObjectSetInteger(0, Descr, OBJPROP_FONTSIZE, 10);  
         
         if(direction > 0){
            ObjectSetString(0, Descr, OBJPROP_TEXT,text+"  ");
            ObjectSetInteger(0, Descr, OBJPROP_ANCHOR, ANCHOR_RIGHT_UPPER);
         }
         if(direction < 0){
            ObjectSetString(0, Descr, OBJPROP_TEXT,text+"  ");
            ObjectSetInteger(0, Descr, OBJPROP_ANCHOR, ANCHOR_RIGHT_LOWER);
         }          
   }
   ChartRedraw(0);
}

Diese Funktion erstellt die visuellen Darstellungen für den Bruch der Preisniveaus, die die Swing-Punkte sind, die zuvor auf dem Chart erkannt worden wären:

• objName: Name des zu erstellenden Objekts.
• time1, time2: Der Startzeitpunkt ist der Zeitpunkt, an dem sich der „Swing“ gebildet hat, und der Endzeitpunkt ist der Zeitpunkt, an dem der „Swing“ gebrochen wurde.
• price1, price2: Der Startpreis ist der Preis, zu dem das „Swing“-Hoch oder „Swing“-Tief eingetreten ist, und price2 ist der Preis, zu dem der Bruch des Swing-Hochs oder Swing-Tiefs erfolgt.
• Clr: Farbe des Pfeils.
• Direction: Richtung für die Verankerung von Text.

Funktionsweise

1. Erstellung von Objekten:

• ObjectFind(0, objName) < 0: Prüft, ob ein Objekt mit einem bestimmten Namen bereits existiert.
• ObjectCreate(0, objName, OBJ_ARROWED_LINE, 0, time1, price1, time2, price2): Erzeugt das Pfeilobjekt zu den angegebenen Zeiten und Preisen.
• Legt die Zeiten und Preise für die Start- und Endpunkte der Pfeillinie fest.
• ObjectSetInteger(0, objName, OBJPROP-COLOR, clr): Legt die Linienfarbe fest.
• ObjectSetInteger(0, objName, OBJPROP-WIDTH, 2): Legt die Linienbreite fest.

2. Erstellung von Textobjekten:

• Erzeugt ein Textobjekt, das mit der Zeile verbunden ist, um zusätzliche Informationen anzuzeigen.
• Legt Farbe, Schriftgröße und Ankerpunkt für den Text auf der Grundlage der Richtung fest.

3. Chart-Update:

• chartRedraw(0): Zeichnet das Chart neu, um die Änderungen wiederzugeben.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass die nutzerdefinierten Funktionen das Handelserlebnis verbessern, da sie einen bequemen Zugriff auf die Hoch-, Tief- und Zeitwerte der Balken ermöglichen. Durch die Kopplung des RSI-Indikators mit den SMC-Konzepten können wir die Indikatoren visualisieren und bestätigen, dass der EA die Anweisungen befolgt. Wenn die Funktion die Pfeillinie auf dem Chart zeichnet, markiert sie signifikante Punkte, die die Swing-Punkte (Hochs und Tiefs) sind. Darüber hinaus können wir die Ausbruchs-Levels beobachten. Außerdem gibt es die dynamische Aktualisierung, die dafür sorgt, dass das Chart in Echtzeit mit den neuesten Markern und Indikatoren aktualisiert wird, was die visuelle Analyse und Entscheidungsfindung erleichtert.

Dieser umfassende Leitfaden vermittelt ein umfassendes Verständnis dafür, wie das SMC-Konzept mit dem RSI-Indikator in die Struktur und Funktionalität eines jeden Expert Advisors integriert werden kann. Nach der schrittweisen Erläuterung sollte der Leser nun ein klares Verständnis für die Funktionsweise des SMC_RSI Expert Advisors haben, von der Initialisierung der Variablen bis zur Ausführung der Handelsgeschäfte auf der Grundlage von berechneten Signalen. Egal, ob Sie ein erfahrener Händler oder ein Anfänger sind, dieser umfassende Einblick sollte Sie mit dem notwendigen Wissen ausstatten, um diese leistungsstarken Tools effektiv für Ihre Handelsbemühungen zu nutzen und anzupassen.

Hier sind die Backtest-Ergebnisse unten, kann ich sagen, die EA selbst noch eine Art von Optimierung benötigen, um höhere Gewinn-Faktor zu erhalten, jetzt unten sind die Backtest-Ergebnisse:

Unten sehen wir die visuelle Darstellung der Aktienkurve. Ich habe sie nur 12 Monate lang getestet, wer kann also genau sagen, wie sie sich entwickeln würde, wenn man sie über einen Zeitraum von 12 Jahren testen würde.

Referenzen

Ursprünglicher Artikel: https://www.mql5.com/de/articles/15017