Entwicklung des Price Action Analysis Toolkit (Teil 26): Pin Bar, Engulfing Patterns und RSI Divergence (Multi-Pattern) Tool
55
0
Einführung
In meinem letzten Artikel habe ich mich auf die Identifizierung von vier Kerzenformationen konzentriert: Pin Bar, Doji, Engulfing und Marubozu. Diese Muster wurden verwendet, um sofort nach ihrer Erkennung Kauf- oder Verkaufssignale zu generieren. Dieser Ansatz führte jedoch manchmal zu falschen Signalen, da sich die Bestätigung ausschließlich auf die Mustererkennung ohne zusätzliche Filter stützte.
In diesem Artikel wird ein neues Tool vorgestellt, das sich auf zwei wichtige Muster konzentriert: Pin Bar und Engulfing. Diese Muster werden mit der RSI-Divergenz kombiniert, um jedes Signal zu bestätigen. Die RSI-Divergenz ist ein Instrument, das ich in der Vergangenheit als eigenständigen Indikator auf der Grundlage der Preisentwicklung entwickelt habe. Durch die Integration von Mustererkennung und RSI-Divergenz schaffen wir eine robustere und leistungsfähigere Analysemethode, die tiefere Einblicke bietet und die Handelsgenauigkeit durch eine umfassende Preisaktionsanalyse verbessert.
Wir werden zunächst die beiden Muster genauer untersuchen, gefolgt von einem Überblick über die Strategie, einer Aufschlüsselung der Code-Komponenten, Backtest-Ergebnissen und Analysen. Abschließend werden wir die wichtigsten Erkenntnisse zusammenfassen. Bitte beachten Sie das nachstehende Inhaltsverzeichnis.
- Verstehen von Kerzenmustern
- Überblick über die Strategie
- Aufschlüsselung der Code-Komponenten
- Backtesting und Ergebnisse
- Schlussfolgerung
Verstehen von Kerzenmustern
Kerzenmuster sind eine Art von Chart, das in der technischen Analyse verwendet wird, um die Preisbewegungen auf den Finanzmärkten zu analysieren. Sie stellen die Eröffnungs-, Höchst-, Tiefst- und Schlusskurse eines Marktes über einen bestimmten Zeitraum visuell dar und bieten so Einblicke in die potenzielle Marktrichtung und -stimmung. Es gibt viele Kerzenmuster, aber wie in diesem Artikel erwähnt, konzentrieren wir uns auf zwei Hauptmuster: den Pin Bar und das Engulfing-Muster. Diese Muster können als eine oder zwei Kerzen auf höheren Zeitskalen oder als mehrere Kerzen auf niedrigeren Zeitskalen erscheinen. Schauen wir uns die nachstehende Präsentation an, in der ich ausführlich erläutern werde, was ich meine.Das erste Chart (Abb. 1) veranschaulicht ein Abwärts-Engulfing-Muster auf dem M30-Zeitrahmen. Sie besteht aus zwei Kerzen: Die erste ist eine Aufwärtskerze mit einem kleinen Körper, gefolgt von einer Abwärtskerze mit einem größeren Körper, der die vorherige Aufwärtskerze verschlingt.
Abb. 1. Abwärts-Engulfing M30
Dasselbe Muster kann durch mehrere Kerzen dargestellt werden, wenn es in einem niedrigeren Zeitrahmen betrachtet wird. Schauen wir uns das folgende Chart an (Abb. 2). Es zeigt dasselbe Kerzenmuster wie zuvor, jetzt aber auf dem M5-Zeitrahmen, wo es durch eine Reihe mehrerer Kerzen dargestellt wird.
Abb. 2. Abwärts-Engulfing M5
Fahren wir fort mit der Erörterung der beiden Muster, auf die wir uns konzentrieren, dem Pin Bar und dem Engulfing-Muster, sowie der RSI-Divergenz. Wir werden hier nicht näher auf diese Themen eingehen, da wir sie in unserem vorherigen Artikel ausführlich behandelt haben. Sie können diesen Artikel über den angegebenen Link aufrufen.
Stiftleiste
Ein Pin Bar ist eine Kerzenart, die durch einen kleinen echten Körper und einen hervorstehenden Docht gekennzeichnet ist und eine deutliche Ablehnung des Preises auf einem bestimmten Niveau signalisiert. Es handelt sich um eine einzelne Kerze, die oft eine potenzielle Umkehr oder einen kritischen Wendepunkt auf dem Markt anzeigt. Der verlängerte Docht zeigt, dass sich die Kurse stark in eine Richtung bewegt haben, aber schnell wieder zurückgeworfen wurden, was auf eine Änderung der Marktstimmung und eine mögliche Verschiebung der Dynamik hindeutet.
Engulfing-Muster
Ein Engulfing-Kerzenmuster ist ein beliebtes Instrument der technischen Analyse, das eine mögliche Umkehr der Marktrichtung signalisiert. Sie besteht aus zwei aufeinanderfolgenden Kerzen, wobei der Körper der zweiten Kerze den Körper der ersten Kerze vollständig "verschlingt", was auf eine Veränderung der Marktstimmung hinweist. Dieses Muster dient als Umkehrsignal und deutet darauf hin, dass der vorherige Trend zu Ende geht und ein neuer Trend beginnt, entweder ein Aufwärtstrend, wenn eine größere Aufwärtskerze eine kleinere Abwärtskerze verschlingt, oder ein Abwärtstrend, wenn eine größere Abwärtskerze eine kleinere Aufwärtskerze verschlingt.
RSI-Divergenz
Eine Divergenz des RSI (Relative Strength Index) tritt auf, wenn sich der Kurs eines Vermögenswerts und der RSI-Indikator in entgegengesetzte Richtungen bewegen, was eine potenzielle Änderung der Dynamik und eine mögliche Trendumkehr signalisiert. Diese Divergenz zeigt sich, wenn der Kurs neue Höchst- oder Tiefststände bildet, der RSI die entsprechenden Höchst- oder Tiefststände jedoch nicht bestätigt. Es gibt zwei Haupttypen: die Abwärts-Divergenz, die auftritt, wenn der Kurs ein neues Hoch erreicht, während der RSI ein niedrigeres Hoch bildet, was auf eine nachlassende Aufwärtsdynamik und einen möglichen bevorstehenden Rückgang hindeutet; die Aufwärts-Divergenz, bei der der Kurs ein neues Tief erreicht, der RSI aber ein höheres Tief bildet, was darauf hindeutet, dass die Abwärtsdynamik nachlässt und eine Aufwärtsbewegung folgen könnte.
Der RSI misst als Momentum-Oszillator die Geschwindigkeit und Veränderung von Kursbewegungen und hilft Händlern, überkaufte oder überverkaufte Zustände zu erkennen, zeigt aber auch Divergenzmuster auf. Wenn der Kurs neue Extremwerte erreicht, ohne dass der RSI eine entsprechende Bewegung aufweist, signalisiert dies eine mögliche Verschiebung des Momentums und eine Trendumkehr.
Abwärts-Divergenz,
Abb. 3. Abwärts-RSI-Divergenz
Aufwärts gerichtete RSI-Divergenz
Abb. 4. Aufwärts-RSI-Divergenz
Überblick über die Strategie
Unser Tool sucht gründlich nach Pin-Bar- und Engulfing-Mustern und erkennt diese, während es gleichzeitig auf RSI-Divergenzen prüft, um jedes Signal zu bestätigen, egal ob es sich um ein Kauf- oder Verkaufssignal handelt. Mit anderen Worten: Wenn ein Pin Bar oder ein Engulfing-Muster erkannt wird, überprüft der EA die RSI-Divergenz als Bestätigung, bevor er das Signal validiert. Nur wenn der RSI das Muster bestätigt, zeigt das Tool das Handelssignal an. Das nachstehende Chart veranschaulicht, wie ein Pin Bar durch eine Aufwärts-RSI-Divergenz bestätigt werden kann.
Abb. 5. Pin-Bar-Bestätigung
Aufschlüsselung der Code-Komponenten
1. Metadaten und Initialisierungseigenschaften
Der Startabschnitt des EA definiert wichtige Metadaten, die zur Identifizierung und Verwaltung des Skripts in der MetaTrader-Umgebung dienen. Der Copyright-Vermerk, der Link und die Versionsnummer sorgen für die Zuordnung und Versionskontrolle, sodass die Nutzer den Ursprung und den Aktualisierungsstatus des Skripts kennen. Die Direktive #propertystrict erzwingt strengere Kompilierungsregeln, fängt potenzielle Fehler frühzeitig ab und fördert bessere Kodierungspraktiken. Diese Konfiguration stellt sicher, dass der EA die erwarteten Standards einhält und erleichtert die Wartung, die Fehlerbehebung und die Identifizierung, wenn mehrere Skripte gleichzeitig ausgeführt werden.
//+------------------------------------------------------------------+ //| Multi-Pattern Signal EA| //| Copyright 2025, MetaQuotes Ltd.| //| https://www.mql5.com/de/users/lynnchris| //+------------------------------------------------------------------+ #property copyright "Copyright 2025, MetaQuotes Ltd." #property link "https://www.mql5.com/de/users/lynnchris" #property version "1.0" #property strict
2. Einbindung von Bibliotheken und Definition von Nutzereingaben
Der EA enthält die Bibliothek <Trade/Trade.mqh>, um Orderoperationen wie das Öffnen, Schließen und Verwalten von Handelsgeschäfte zu ermöglichen. Während sich diese Version in erster Linie auf die Erkennung von Mustern und Warnungen konzentriert, ermöglicht die integrierte Handelsbibliothek eine zukünftige Erweiterung auf den automatisierten Handel. Die Eingabeparameter sind für die individuelle Anpassung von entscheidender Bedeutung: Händler können die RSI-Periode anpassen, um die Empfindlichkeit zu steigern, überkaufte und überverkaufte Schwellenwerte für die Erkennung von Divergenzen festlegen und Stop-Loss- und Take-Profit-Level in Pips konfigurieren.
Der EntryBuffer fungiert als Pufferzone, um zu verhindern, dass der Einstieg zu nahe an den letzten Kursextremen erfolgt, wodurch Fehlsignale reduziert werden. Benachrichtigungsflags aktivieren oder deaktivieren akustische Benachrichtigungen, Push-Benachrichtigungen und E-Mails, sodass Händler selbst bestimmen können, wie sie Benachrichtigungen erhalten. Diese Parameter zusammen machen den EA anpassungsfähig an verschiedene Handelsstile und Marktbedingungen.
#include <Trade/Trade.mqh> input int RSI_Period = 14; // RSI calculation period input double RSI_Overbought = 70.0; // RSI level indicating overbought input double RSI_Oversold = 30.0; // RSI level indicating oversold input double SL_Pips = 20.0; // Default stop loss in pips input double TP_Pips = 20.0; // Default take profit in pips input double EntryBuffer = 5.0; // Buffer in points for entry price input bool EnableSound = true; // Enable sound alerts input bool EnablePush = true; // Enable push notifications input bool EnableEmail = false; // Enable email alerts
3. Initialisierung: Erstellen von Indikatorhandles und Puffern
Während der Ersteinrichtung erstellt der EA mit iRSI() ein Handle für den RSI-Indikator und gibt dabei die Parameter Symbol, Periode und RSI an. Dieser Handle ist für die Abfrage von Live-RSI-Werten bei jedem Tick unerlässlich und bildet das Rückgrat der Divergenzerfassung. Die Arrays sind als Serie angelegt, d. h. die neuesten Daten befinden sich immer bei Index 0. Die internen Puffer für Zeit, Eröffnungs-, Höchst-, Tiefst- und Schlusskurs werden initialisiert, um historische Daten für die Analyse zu speichern. Die lastBarTime-Variable verfolgt den Zeitstempel der letzten verarbeiteten Kerze und verhindert so, dass mehrere Signale innerhalb derselben Kerze erzeugt werden, wodurch redundante Alarme vermieden und die Signalgenauigkeit gewährleistet wird.
int OnInit() { rsiHandle = iRSI(_Symbol, _Period, RSI_Period, PRICE_CLOSE); if(rsiHandle == INVALID_HANDLE) return INIT_FAILED; // Set arrays as series for easier access to recent data ArraySetAsSeries(rsiBuffer, true); ArraySetAsSeries(timeBuffer, true); ArraySetAsSeries(openBuffer, true); ArraySetAsSeries(highBuffer, true); ArraySetAsSeries(lowBuffer, true); ArraySetAsSeries(closeBuffer, true); return INIT_SUCCEEDED; }
4. Kontinuierliche Datenüberwachung und -verarbeitung in OnTick()
Die Funktion OnTick() wird bei jedem Markttick ausgeführt und dient als Kernschleife des EA. Zunächst wird überprüft, ob mindestens 20 Balken vorhanden sind, damit genügend historische Daten für die Mustererkennung vorliegen. Anschließend kopiert es die letzten 20 Datenpunkte für Zeitstempel und Kursdaten - Open, High, Low, Close - in interne Puffer. Dieser Schritt ist von entscheidender Bedeutung, da die Marktdaten ständig aktualisiert werden und die Analyse auf aktuellen und genauen Daten beruht. Wenn ein Kopiervorgang fehlschlägt, wird die Funktion angehalten, um Fehler oder falsche Signale zu vermeiden.
Um mehrere Signale innerhalb derselben Kerze zu vermeiden, wird geprüft, ob der Zeitstempel der vorherigen Kerze mit lastBarTime übereinstimmt. Wenn ja, wird die Verarbeitung übersprungen; andernfalls wird lastBarTime mit dem Zeitstempel der neuen Kerze aktualisiert. Anschließend werden die RSI-Daten aktualisiert. Sobald die Daten vorbereitet sind, wird FindSignalBar() aufgerufen, um die letzten Balken auf die Signale von Divergenz- und Kerzenmuster zu analysieren, die die Grundlage für die Generierung von Warnungen bilden.
void OnTick() { // Ensure enough data is available if(Bars(_Symbol, _Period) < 20) return; // Copy recent market data if(CopyTime(_Symbol, _Period, 0, 20, timeBuffer) <= 0 || CopyOpen(_Symbol, _Period, 0, 20, openBuffer) <= 0 || CopyHigh(_Symbol, _Period, 0, 20, highBuffer) <= 0 || CopyLow(_Symbol, _Period, 0, 20, lowBuffer) <= 0 || CopyClose(_Symbol, _Period, 0, 20, closeBuffer) <= 0) return; // Prevent multiple signals in the same candle if(timeBuffer[1] == lastBarTime) return; lastBarTime = timeBuffer[1]; // Update RSI data if(CopyBuffer(rsiHandle, 0, 0, 20, rsiBuffer) <= 0) return; // Detect potential divergence and pattern int dir = FindSignalBar(); if(dir == 0) return; // Determine direction and compute entry/stop levels bool isBullish = (dir > 0); int idx = 1; // most recent completed bar double entry = isBullish ? highBuffer[idx] + EntryBuffer * _Point : lowBuffer[idx] - EntryBuffer * _Point; double stopL = isBullish ? lowBuffer[idx] - SL_Pips * _Point : highBuffer[idx] + SL_Pips * _Point; // Visualize and notify DrawSignal(idx, isBullish, entry, stopL); }
5. Mustererkennung durch die Analyse der Divergenz- und Kerzenmuster
Die Funktion FindSignalBar() spielt eine entscheidende Rolle bei der Identifizierung potenzieller Umkehrsignale. Es scannt die jüngsten Balken (5 bis 15 Balken zurück), um Divergenzmuster zu erkennen. Eine Aufwärts-Divergenz wird bestätigt, wenn die Tiefststände steigen, während der RSI unter den überverkauften Bereich fällt, was auf eine potenzielle Umkehr nach oben hinweist. Umgekehrt bedeutet eine Abwärts-Divergenz, dass die Höchststände fallen, während der RSI überkauft ist, was auf eine mögliche Abwärtsbewegung hindeutet.
Die Funktion prüft auch den letzten Balken auf unterstützende Kerzenmuster, wie Pin Bars und Engulfing-Kerzen, die für ihre Bedeutung als Umkehrkerzen bekannt sind. Wenn sowohl die Divergenz- als auch die Musterbedingungen erfüllt sind, wird +1 für ein Aufwärtssignal oder -1 für ein Abwärtssignal zurückgegeben; andernfalls wird 0 zurückgegeben, was bedeutet, dass zu diesem Zeitpunkt kein gültiges Setup vorliegt. Dieser mehrschichtige Ansatz kombiniert Momentum-Divergenz mit Kursbewegungen, um die Zuverlässigkeit der Signale zu verbessern.
int FindSignalBar() { bool bullDiv = false, bearDiv = false; for(int i = 5; i <= 15; i++) { // Bullish divergence condition if(lowBuffer[i] > lowBuffer[1] && rsiBuffer[i] < rsiBuffer[1] && rsiBuffer[1] < RSI_Oversold) bullDiv = true; // Bearish divergence condition if(highBuffer[i] < highBuffer[1] && rsiBuffer[i] > rsiBuffer[1] && rsiBuffer[1] > RSI_Overbought) bearDiv = true; } // No divergence detected if(!bullDiv && !bearDiv) return 0; // Check for candlestick patterns supporting divergence bool bullPat = IsBullishPinBar(1) || IsBullishEngulfing(1); bool bearPat = IsBearishPinBar(1) || IsBearishEngulfing(1); // Confirmed signals if(bullDiv && bullPat) return +1; if(bearDiv && bearPat) return -1; return 0; // No valid signal }
6. Erkennung von Kerzenmustern zur Bestätigung
Diese Funktionen analysieren einzelne Kerzen, um Umkehrsignale zu bestätigen.IsBullishPinBar() prüft, ob die Kerze einen kleinen Körper mit einem langen unteren Docht aufweist, was auf die Ablehnung niedrigerer Kurse hindeutet - ein Hinweis auf eine Aufwärts-Umkehr. IsBearishPinBar() macht das Gegenteil. IsBullishEngulfing() bestätigt, wenn der Körper der aktuellen Kerze die vorherige Kerze verschlingt, was einen starken Kaufdruck signalisiert, während IsBearishEngulfing() auf starken Verkaufsdruck hinweist. Diese Mustererkennungsfunktionen verwenden proportionale Messungen von Kerzenkörpern und Dochten im Verhältnis zu ihrem Hoch-Tief-Bereich, um sicherzustellen, dass nur wohlgeformte Muster berücksichtigt werden, was falsch-positive Ergebnisse reduziert und die Zuverlässigkeit der Signale erhöht.
// Bullish Pin Bar Pattern bool IsBullishPinBar(int i) { double body = MathAbs(openBuffer[i] - closeBuffer[i]); double rng = highBuffer[i] - lowBuffer[i]; double lw = MathMin(openBuffer[i], closeBuffer[i]) - lowBuffer[i]; double uw = highBuffer[i] - MathMax(openBuffer[i], closeBuffer[i]); return closeBuffer[i] > openBuffer[i] && lw > 2.0 * body && uw < 0.5 * body && body > 0.1 * rng; } // Bearish Pin Bar Pattern bool IsBearishPinBar(int i) { double body = MathAbs(openBuffer[i] - closeBuffer[i]); double rng = highBuffer[i] - lowBuffer[i]; double uw = highBuffer[i] - MathMax(openBuffer[i], closeBuffer[i]); double lw = MathMin(openBuffer[i], closeBuffer[i]) - lowBuffer[i]; return closeBuffer[i] < openBuffer[i] && uw > 2.0 * body && lw < 0.5 * body && body > 0.1 * rng; } // Bullish Engulfing Pattern bool IsBullishEngulfing(int i) { if(closeBuffer[i] <= openBuffer[i]) return false; if(openBuffer[i] > closeBuffer[i+1]) return false; if(closeBuffer[i] < openBuffer[i+1]) return false; return true; } // Bearish Engulfing Pattern bool IsBearishEngulfing(int i) { if(closeBuffer[i] >= openBuffer[i]) return false; if(openBuffer[i] < closeBuffer[i+1]) return false; if(closeBuffer[i] > openBuffer[i+1]) return false; return true; }
7. Visualisierung und Alarmierung
Sobald ein gültiges Muster und eine Divergenz bestätigt sind, visualisiert DrawSignal() das Setup durch das Zeichnen von Pfeilen an Einstiegspunkten, horizontalen Linien für Einstiegs- und Stop-Loss-Niveaus und Trendlinien, die das Divergenzmuster illustrieren. Die Farbe und der Code des Pfeils spiegeln die Richtung wider, grün für aufwärts, rot für abwärts. Die Trendlinien verbinden die jüngsten Tiefst- oder Höchststände, um die Divergenz visuell zu bestätigen.
Die Funktion erstellt auch eine detaillierte Warnmeldung, die den Mustertyp, die Seite, das Symbol, die Zeit, den Einstieg und das Stop-Loss-Niveau enthält. Je nach den Präferenzen des Nutzers werden dann Benachrichtigungen ausgelöst, z. B. in Form eines Tons, einer Push-Benachrichtigung oder einer E-Mail, sodass der Händler umgehend informiert wird und schnell handeln kann. Dieses umfassende Visualisierungs- und Warnsystem verbessert das Situationsbewusstsein und die Entscheidungsfindung.
void DrawSignal(int i, bool isBullish, double entry, double stopL) { string tag = TimeToString(timeBuffer[i], TIME_SECONDS); string nameA = "Arr_" + tag; string nameE = "Ent_" + tag; string nameS = "SL_" + tag; string nameL = "Div_" + tag; color clrArr = isBullish ? clrLime : clrRed; int code = isBullish ? 233 : 234; // Arrow at entry point ObjectCreate(0, nameA, OBJ_ARROW, 0, timeBuffer[i], entry); ObjectSetInteger(0, nameA, OBJPROP_COLOR, clrArr); ObjectSetInteger(0, nameA, OBJPROP_ARROWCODE, code); ObjectSetInteger(0, nameA, OBJPROP_WIDTH, 2); // Horizontal lines for entry and stop-loss ObjectCreate(0, nameE, OBJ_HLINE, 0, 0, entry); ObjectSetInteger(0, nameE, OBJPROP_COLOR, clrAqua); ObjectCreate(0, nameS, OBJ_HLINE, 0, 0, stopL); ObjectSetInteger(0, nameS, OBJPROP_COLOR, clrOrangeRed); ObjectSetInteger(0, nameS, OBJPROP_STYLE, STYLE_DASH); // Divergence trend line for visual confirmation for(int j = i + 5; j < i + 15; j++) { if(isBullish && lowBuffer[j] > lowBuffer[i]) { ObjectCreate(0, nameL, OBJ_TREND, 0, timeBuffer[j], lowBuffer[j], timeBuffer[i], lowBuffer[i]); ObjectSetInteger(0, nameL, OBJPROP_COLOR, clrDodgerBlue); break; } if(!isBullish && highBuffer[j] < highBuffer[i]) { ObjectCreate(0, nameL, OBJ_TREND, 0, timeBuffer[j], highBuffer[j], timeBuffer[i], highBuffer[i]); ObjectSetInteger(0, nameL, OBJPROP_COLOR, clrOrange); break; } } // Construct alert message string pattern = isBullish ? (IsBullishEngulfing(i) ? "Engulfing" : "PinBar") : (IsBearishEngulfing(i) ? "Engulfing" : "PinBar"); string side = isBullish ? "Buy" : "Sell"; string txt = StringFormat( "%s + RSI Divergence %s Signal\nSymbol: %s\nTime: %s\nEntry: %.5f\nSL: %.5f", pattern, side, _Symbol, TimeToString(timeBuffer[i], TIME_MINUTES), entry, stopL ); // Notify trader Alert(txt); if(EnableSound) PlaySound("alert.wav"); if(EnablePush) SendNotification(txt); if(EnableEmail) SendMail("Signal EA Alert", txt); Print(txt); }
Vollständiger EA in MQL5
//+------------------------------------------------------------------+ //| Multi-Pattern Signal EA| //| Copyright 2025, MetaQuotes Ltd.| //| https://www.mql5.com/de/users/lynnchris| //+------------------------------------------------------------------+ #property copyright "Copyright 2025, MetaQuotes Ltd." #property link "https://www.mql5.com/de/users/lynnchris" #property version "1.0" #property strict #include <Trade/Trade.mqh> input int RSI_Period = 14; input double RSI_Overbought = 70.0; input double RSI_Oversold = 30.0; input double SL_Pips = 20.0; // in pips input double TP_Pips = 20.0; // in pips input double EntryBuffer = 5.0; // in points input bool EnableSound = true; input bool EnablePush = true; input bool EnableEmail = false; CTrade trade; // internal buffers double rsiBuffer[]; datetime timeBuffer[]; double openBuffer[], highBuffer[], lowBuffer[], closeBuffer[]; int rsiHandle; datetime lastBarTime = 0; //+------------------------------------------------------------------+ int OnInit() { rsiHandle = iRSI(_Symbol, _Period, RSI_Period, PRICE_CLOSE); if(rsiHandle == INVALID_HANDLE) return INIT_FAILED; ArraySetAsSeries(rsiBuffer, true); ArraySetAsSeries(timeBuffer, true); ArraySetAsSeries(openBuffer, true); ArraySetAsSeries(highBuffer, true); ArraySetAsSeries(lowBuffer, true); ArraySetAsSeries(closeBuffer, true); return INIT_SUCCEEDED; } //+------------------------------------------------------------------+ void OnTick() { if(Bars(_Symbol,_Period) < 20) return; if(CopyTime(_Symbol,_Period,0,20,timeBuffer) <= 0 || CopyOpen(_Symbol,_Period,0,20,openBuffer) <= 0 || CopyHigh(_Symbol,_Period,0,20,highBuffer) <= 0 || CopyLow(_Symbol,_Period,0,20,lowBuffer) <= 0 || CopyClose(_Symbol,_Period,0,20,closeBuffer) <= 0) return; if(timeBuffer[1] == lastBarTime) return; lastBarTime = timeBuffer[1]; if(CopyBuffer(rsiHandle,0,0,20,rsiBuffer) <= 0) return; int dir = FindSignalBar(); if(dir == 0) return; int idx = 1; bool isBullish = (dir > 0); double entry = isBullish ? highBuffer[idx] + EntryBuffer * _Point : lowBuffer[idx] - EntryBuffer * _Point; double stopL = isBullish ? lowBuffer[idx] - SL_Pips * _Point : highBuffer[idx] + SL_Pips * _Point; DrawSignal(idx, isBullish, entry, stopL); } //+------------------------------------------------------------------+ int FindSignalBar() { bool bullDiv = false, bearDiv = false; for(int i = 5; i <= 15; i++) { if(lowBuffer[i] > lowBuffer[1] && rsiBuffer[i] < rsiBuffer[1] && rsiBuffer[1] < RSI_Oversold) bullDiv = true; if(highBuffer[i] < highBuffer[1] && rsiBuffer[i] > rsiBuffer[1] && rsiBuffer[1] > RSI_Overbought) bearDiv = true; } if(!bullDiv && !bearDiv) return 0; bool bullPat = IsBullishPinBar(1) || IsBullishEngulfing(1); bool bearPat = IsBearishPinBar(1) || IsBearishEngulfing(1); if(bullDiv && bullPat) return +1; if(bearDiv && bearPat) return -1; return 0; } //+------------------------------------------------------------------+ bool IsBullishPinBar(int i) { double body = MathAbs(openBuffer[i] - closeBuffer[i]); double rng = highBuffer[i] - lowBuffer[i]; double lw = MathMin(openBuffer[i], closeBuffer[i]) - lowBuffer[i]; double uw = highBuffer[i] - MathMax(openBuffer[i], closeBuffer[i]); return closeBuffer[i] > openBuffer[i] && lw > 2.0 * body && uw < 0.5 * body && body > 0.1 * rng; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ bool IsBearishPinBar(int i) { double body = MathAbs(openBuffer[i] - closeBuffer[i]); double rng = highBuffer[i] - lowBuffer[i]; double uw = highBuffer[i] - MathMax(openBuffer[i], closeBuffer[i]); double lw = MathMin(openBuffer[i], closeBuffer[i]) - lowBuffer[i]; return closeBuffer[i] < openBuffer[i] && uw > 2.0 * body && lw < 0.5 * body && body > 0.1 * rng; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ bool IsBullishEngulfing(int i) { if(closeBuffer[i] <= openBuffer[i]) return false; if(openBuffer[i] > closeBuffer[i+1]) return false; if(closeBuffer[i] < openBuffer[i+1]) return false; return true; } //+------------------------------------------------------------------+ //| | //+------------------------------------------------------------------+ bool IsBearishEngulfing(int i) { if(closeBuffer[i] >= openBuffer[i]) return false; if(openBuffer[i] < closeBuffer[i+1]) return false; if(closeBuffer[i] > openBuffer[i+1]) return false; return true; } //+------------------------------------------------------------------+ void DrawSignal(int i, bool isBullish, double entry, double stopL) { string tag = TimeToString(timeBuffer[i], TIME_SECONDS); string nameA = "Arr_" + tag; string nameE = "Ent_" + tag; string nameS = "SL_" + tag; string nameL = "Div_" + tag; color clrArr = isBullish ? clrLime : clrRed; int code = isBullish ? 233 : 234; ObjectCreate(0, nameA, OBJ_ARROW, 0, timeBuffer[i], entry); ObjectSetInteger(0, nameA, OBJPROP_COLOR, clrArr); ObjectSetInteger(0, nameA, OBJPROP_ARROWCODE, code); ObjectSetInteger(0, nameA, OBJPROP_WIDTH, 2); ObjectCreate(0, nameE, OBJ_HLINE, 0, 0, entry); ObjectSetInteger(0, nameE, OBJPROP_COLOR, clrAqua); ObjectCreate(0, nameS, OBJ_HLINE, 0, 0, stopL); ObjectSetInteger(0, nameS, OBJPROP_COLOR, clrOrangeRed); ObjectSetInteger(0, nameS, OBJPROP_STYLE, STYLE_DASH); for(int j = i + 5; j < i + 15; j++) { if(isBullish && lowBuffer[j] > lowBuffer[i]) { ObjectCreate(0, nameL, OBJ_TREND, 0, timeBuffer[j], lowBuffer[j], timeBuffer[i], lowBuffer[i]); ObjectSetInteger(0, nameL, OBJPROP_COLOR, clrDodgerBlue); break; } if(!isBullish && highBuffer[j] < highBuffer[i]) { ObjectCreate(0, nameL, OBJ_TREND, 0, timeBuffer[j], highBuffer[j], timeBuffer[i], highBuffer[i]); ObjectSetInteger(0, nameL, OBJPROP_COLOR, clrOrange); break; } } string pattern = isBullish ? (IsBullishEngulfing(i) ? "Engulfing" : "PinBar") : (IsBearishEngulfing(i) ? "Engulfing" : "PinBar"); string side = isBullish ? "Buy" : "Sell"; string txt = StringFormat( "%s + RSI Divergence %s Signal\nSymbol: %s\nTime: %s\nEntry: %.5f\nSL: %.5f", pattern, side, _Symbol, TimeToString(timeBuffer[i], TIME_MINUTES), entry, stopL ); Alert(txt); if(EnableSound) PlaySound("alert.wav"); if(EnablePush) SendNotification(txt); if(EnableEmail) SendMail("Signal EA Alert", txt); Print(txt); } //+------------------------------------------------------------------+
Backtesting und Ergebnisse
Bei Backtests wird eine Handelsstrategie anhand historischer Marktdaten evaluiert, um abzuschätzen, wie sie sich in der Vergangenheit entwickelt hätte. Mit dieser Simulation können Händler sehen, wie ihre vordefinierten Regeln unter realen Marktbedingungen funktioniert hätten, und erhalten so einen Einblick in potenzielle Rentabilität und Risiken. Durch die Analyse der Ergebnisse dieser simulierten Handelsgeschäfte können Händler fundierte Entscheidungen darüber treffen, ob sie die Strategie im Live-Handel umsetzen wollen.
Der erste Schritt bei den Backtests besteht darin, die Handelsstrategie klar zu definieren. Dazu gehört die Festlegung spezifischer Regeln für den Einstieg in den Handel und den Ausstieg aus dem Handel, einschließlich der Indikatoren, Kursmuster oder anderer Bedingungen, die Kauf- oder Verkaufssignale auslösen. Eine gut definierte Strategie gewährleistet konsistente Tests und genaue Ergebnisse. Als Nächstes müssen Händler relevante historische Daten, wie Preis-Charts, Volumen und andere relevante Informationen für den Zeitraum, den sie analysieren möchten, sammeln. Genaue und umfassende Daten sind für zuverlässige Backtest-Ergebnisse unerlässlich.
Die Wahl der richtigen Backtest-Plattform ist entscheidend. Es gibt verschiedene Software-Tools, von denen einige eine manuelle Analyse ermöglichen, während andere vollautomatische Tests unterstützen. Die ausgewählte Plattform sollte in der Lage sein, den Handel auf der Grundlage Ihrer Strategieregeln genau zu simulieren und detaillierte Leistungskennzahlen zu liefern. Sobald die Plattform ausgewählt ist, muss der Händler die Backtest-Umgebung einrichten. Dazu gehört die Konfiguration von Parametern wie Zeitrahmen, Transaktionskosten, Slippage und anderen Faktoren, die die Performance beeinflussen können, um sicherzustellen, dass die Simulation den realen Handelsbedingungen so nahe wie möglich kommt.
Nach der Einrichtung ist der nächste Schritt die Anwendung der Strategie durch die Durchführung eines Backtests. Die Plattform generiert dann simulierte Handelsgeschäfte nach den von Ihnen vordefinierten Regeln und den historischen Marktdaten. Während dieses Prozesses ist es wichtig, die Ergebnisse gründlich zu analysieren. Wichtige Kennzahlen wie Gesamtgewinn oder -verlust, Gewinnquote, maximaler Drawdown und Risiko-Ertrags-Verhältnis liefern wertvolle Erkenntnisse über die Effektivität und Robustheit der Strategie.
Auf der Grundlage der Analyse sollten die Händler ihre Strategie verfeinern und optimieren. Anpassungen von Parametern oder Regeln können die Leistung verbessern und dazu beitragen, während der Tests festgestellte Schwachstellen zu beseitigen. Um die Verlässlichkeit der Strategie zu gewährleisten und eine Überanpassung zu vermeiden, ist es unerlässlich, sie mit Daten außerhalb der Stichprobe zu validieren. Die Anwendung der verfeinerten Strategie auf einen separaten Satz historischer Daten trägt dazu bei, ihre Robustheit und ihr Potenzial für eine gute Performance auf realen Märkten zu bestätigen.
Nachfolgend finden Sie die Ergebnisse meines Backtests.
Abb. 6. Bestätigung des Aufwärts-Engulfing
Die obige Abbildung (Abb. 6) zeigt einen Screenshot aus dem Backtest von EURUSD auf dem M30-Zeitrahmen, der ein Muster des Aufwärts-Engulfing zeigt, das durch eine Aufwärts-Divergenz bestätigt wurde.
Abb. 7. USDCHF Backtest
Die obige Abbildung (Abb. 7) zeigt einen Screenshot aus dem Backtest von EURUSD auf dem M30-Zeitrahmen, der ein Muster des Aufwärts-Engulfing zeigt, das durch eine Aufwärts-Divergenz bestätigt wird. Außerdem finden Sie unten ein GIF, das den Backtest-Prozess für das Währungspaar USDCHF zeigt und verdeutlicht, wie mehrere Signale identifiziert wurden.
Schlussfolgerung
Dieser EA ist ein Beispiel für einen fortschrittlichen Ansatz zur Mustererkennung und Divergenzerfassung innerhalb einer Handelsstrategie. Durch die Kombination von technischen Indikatoren wie dem RSI mit der Analyse von Kerzenmustern wie Pin-Bars und Engulfing-Mustern lassen sich mit hoher Wahrscheinlichkeit Umkehrsignale erkennen. Der modulare Aufbau des EA ermöglicht es ihm, aktuelle Marktdaten in Echtzeit zu analysieren, visuelle Signale auf dem Chart zu generieren und zeitnahe Warnungen zu senden, was ihn zu einem wertvollen Werkzeug für Händler macht, die systematische und disziplinierte Einstiege suchen.
Die Backtest-Ergebnisse zeigen, dass der EA hohe Gewinnraten erzielen kann, insbesondere wenn die Signale durch mehrere Kriterien bestätigt werden. Wie bei jeder automatisierten Strategie ist es jedoch entscheidend, ihre Robustheit bei verschiedenen Währungspaaren und Marktbedingungen durch Out-of-Sample-Tests zu überprüfen. Die richtige Optimierung der Parameter und das Risikomanagement sind entscheidend für die Maximierung der Rentabilität und die Verringerung von Drawdowns. Insgesamt zeigt dieser EA das Potenzial der Kombination von Mustererkennung und Divergenzanalyse und legt damit eine solide Grundlage für die weitere Integration von maschinellem Lernen und intelligenter Entscheidungsfindung in Handelssystemen.
| Datum | Name des Tools | Beschreibung | Version | Aktualisierungen | Hinweis |
|---|---|---|---|---|---|
| 01/10/24 | Chart Projector | Skript zur Überlagerung der Kursentwicklung des Vortages mit einem Ghost-Effekt. | 1.0 | Erste Veröffentlichung | Tool Nummer 1 |
| 18/11/24 | Analytical Comment | Er liefert Informationen zum Vortag in Tabellenform und nimmt die zukünftige Marktentwicklung vorweg. | 1.0 | Erste Veröffentlichung | Tool Nummer 2 |
| 27/11/24 | Analytics Master | Reguläre Aktualisierung der Marktmetriken alle zwei Stunden. | 1.01 | Zweite Veröffentlichung | Tool Nummer 3 |
| 02/12/24 | Analytics Forecaster | Reguläre Aktualisierung der Marktmetriken alle zwei Stunden mit Telegram-Integration. | 1.1 | Dritte Ausgabe | Tool Nummer 4 |
| 09/12/24 | Volatility Navigator | Der EA analysiert die Marktbedingungen anhand der Indikatoren Bollinger Bands, RSI und ATR. | 1.0 | Erste Veröffentlichung | Tool Nummer 5 |
| 19/12/24 | Mean Reversion Signal Reaper | Analysiert den Markt anhand der Strategie „Umkehr zur Mitte“ und liefert Signale. | 1.0 | Erste Veröffentlichung | Tool Nummer 6 |
| 9/01/25 | Signal Pulse | Analysator für mehrere Zeitrahmen. | 1.0 | Erste Veröffentlichung | Tool Nummer 7 |
| 17/01/25 | Metrics Board | Bedienfeld mit Taste für die Analyse. | 1.0 | Erste Veröffentlichung | Tool Nummer 8 |
| 21/01/25 | External Flow | Analytik durch externe Bibliotheken. | 1.0 | Erste Veröffentlichung | Tool Nummer 9 |
| 27/01/25 | VWAP | Volumengewichteter Durchschnittspreis | 1.3 | Erste Veröffentlichung | Tool Nummer 10 |
| 02/02/25 | Heikin Ashi | Trendglättung und Identifizierung von Umkehrsignalen | 1.0 | Erste Veröffentlichung | Tool Nummer 11 |
| 04/02/25 | FibVWAP | Signalerzeugung durch Python-Analyse | 1.0 | Erste Veröffentlichung | Tool Nummer 12 |
| 14/02/25 | RSI DIVERGENCE | Kursentwicklung versus RSI-Divergenzen | 1.0 | Erste Veröffentlichung | Tool Nummer 13 |
| 17/02/25 | Parabolic Stop and Reverse (PSAR) | Automatisierung der PSAR-Strategie | 1.0 | Erste Veröffentlichung | Tool Nummer 14 |
| 20/02/25 | Quarters Drawer Script | Einzeichnen der Ebenen der Viertel auf dem Chart | 1.0 | Erste Veröffentlichung | Tool Nummer 15 |
| 27/02/25 | Intrusion Detector | Erkennen und warnen, wenn der Preis ein Viertel-Niveau erreicht | 1.0 | Erste Veröffentlichung | Tool Nummer 16 |
| 27/02/25 | TrendLoom Tool | Analysepanel für mehrere Zeitrahmen | 1.0 | Erste Veröffentlichung | Tool Nummer 17 |
| 11/03/25 | Quarters Board | Bedienfeld mit Tasten zum Aktivieren oder Deaktivieren der Viertel-Ebenen | 1.0 | Erste Veröffentlichung | Tool Nummer 18 |
| 26/03/25 | ZigZag Analyzer | Zeichnen von Trendlinien mit dem ZigZag-Indikator | 1.0 | Erste Veröffentlichung | Tool Nummer 19 |
| 10/04/25 | Correlation Pathfinder | Plotten von Währungskorrelationen mit Python-Bibliotheken. | 1.0 | Erste Veröffentlichung | Tool Nummer 20 |
| 23/04/25 | Market Structure Flip Detector Tool | Erkennung von Marktstrukturschwankungen | 1.0 | Erste Veröffentlichung | Tool Nummer 21 |
| 08/05/25 | Correlation Dashboard | Beziehung zwischen verschiedenen Paaren | 1.0 | Erste Veröffentlichung | Tool Nummer 22 |
| 13/05/25 | Currency Strength Meter | Messung der Stärke der einzelnen Währungen über alle Paare hinweg | 1.0 | Erste Veröffentlichung | Werkzeug Nummer 23 |
| 21/05/25 | PAQ-Analyse-Tool | Detektor für Kerzenmuster-Formationen | 1.0 | Erste Veröffentlichung | Werkzeug Nummer 24 |
| 23/05/25 | Pin Bar, Engulfing und RSI-Divergenz | Verwendung der RSI-Divergenz zur Bestätigung von Pin-Bar- und Engulfing-Muster-Signalen | 1.0 | Erste Veröffentlichung | Tool Nummer 25 |
Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/17962
Warnung: Alle Rechte sind von MetaQuotes Ltd. vorbehalten. Kopieren oder Vervielfältigen untersagt.
Dieser Artikel wurde von einem Nutzer der Website verfasst und gibt dessen persönliche Meinung wieder. MetaQuotes Ltd übernimmt keine Verantwortung für die Richtigkeit der dargestellten Informationen oder für Folgen, die sich aus der Anwendung der beschriebenen Lösungen, Strategien oder Empfehlungen ergeben.
Automatisieren von Handelsstrategien in MQL5 (Teil 18): Envelopes Trend Bounce Scalping - Kerninfrastruktur und Signalgenerierung (Teil I)
MQL5-Assistenten-Techniken, die Sie kennen sollten (Teil 66): Verwendung von FrAMA-Mustern und des Force Index mit dem Punktprodukt-Kernel
Vom Neuling zum Experten: Autogeometrisches Analysesystem
Handel mit dem MQL5 Wirtschaftskalender (Teil 10): Bewegliches Dashboard und interaktive Hover-Effekte für eine reibungslose Nachrichten-Navigation
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.