Lernen Sie, wie man ein Handelssystem nach Fibonacci entwickelt
448
0
Einführung
In diesem neuen Artikel aus unserer Serie über die Entwicklung eines Handelssystems auf der Grundlage der beliebtesten technischen Analysewerkzeuge und Indikatoren lernen wir, wie man ein Handelssystem auf der Grundlage des technischen Hilfsmittels dem Fibonacci-Retracement (Gegenentwicklung) erstellt, das eines der beliebtesten und am häufigsten verwendeten Handelsinstrumente ist. Danach können wir dieses Handelssystem auf unserem MetaTrader 5-Handelsterminal verwenden. Wir werden die MQL5 (MetaQuotes Language 5) verwenden, für die es eine integrierte IDE im MetaTrader 5 gibt. Wenn Sie lernen wollen, wie man den MetaTrader 5 und die MQL5 IDE herunterlädt und benutzt, können Sie dieses Thema Schreiben von MQL5-Code in MetaEditor aus einem früheren Artikel lesen.
Daher werden die Themen die gleichen sein wie die folgenden:
- Fibonacci: Definition
- Fibonacci: Strategie
- Fibonacci: Blaupause der Strategie
- Fibonacci: Handelssystem
- Schlussfolgerung
Es ist gut zu erwähnen, dass es besser ist, diese Fibonacci zusammen mit anderen technischen Werkzeugen wie Trendanalyse, Unterstützung, Widerstand,...etc. zu verwenden, da es bessere Einblicke und Ergebnisse geben wird. Sie müssen auch jede erlernte Strategie oder jedes Werkzeug aus diesem Artikel oder irgendwo anders testen, bevor Sie es in der realen Welt verwenden, um sicherzustellen, dass es nützlich und profitabel für Ihren Handel ist. Für Sie als Entwickler von Programmierkenntnissen ist es besser, das Gelesene selbst zu programmieren, da dieser Schritt für Sie sehr nützlich ist.
Fibonacci: Definition
In diesem Abschnitt werden wir das Fibonacci-Retracement-Tool identifizieren und lernen, wie wir es in unserem Chart verwenden können. Der Fibo ist ein technisches Hilfsmittel, mit dem sich Unterstützungs- und Widerstandsbereiche auf dem Chart ausfindig machen lassen, von denen wir eine Abprallen erwarten. Es basiert auf der Fibonacci-Folge, die eine mathematische Reihe von Zahlen ist. Jede Zahl dieser Reihe ist die Summe der beiden vorherigen Zahlen. wir können es auf einem Chart als horizontale Linien auf bestimmten Ebenen wie 23,6%, 38,2%, 50% und 61,8% gezeichnet finden und diese Ebenen sind die beliebtesten.
Wenn Sie sich fragen, wie Sie ihn auf dem Chart finden können, lautet die Antwort, dass Sie ihn einfach über die integrierten technischen Tools des MetaTrader 5 einfügen können:
Wenn Sie den MetaTrader 5 öffnen, navigieren Sie zur Registerkarte Einfügen --> Objekte --> Fibonacci Retracement
Danach, wenn wir ein Retracement nach dem Aufwärtstrend haben, zeichnen wir es vom Tief zum Hoch und umgekehrt, wenn wir ein Retracement nach dem Abwärtstrend haben, zeichnen wir vom Hoch zum Tief, genau wie in den folgenden Beispielen.
FIBO nach Aufwärtstrend:
FIBO nach Abwärtstrend:
Wie wir in den vorangegangenen Beispielen sehen können, haben wir eine Trendlinie zwischen zwei Punkten, den höchsten und den niedrigsten Werten, sowie horizontale Linien mit den spezifischen Niveaus 23,6, 38,2, 50 und 61,8 gezogen, und diese Niveaus sind die beliebtesten. Um diese Niveaus herum und nach einem Auf- oder Abwärtstrend kommt es zu Korrekturen oder Rücksetzern, und nach der Korrektur ist mit einem Wiederanstieg von diesen Niveaus zu rechnen. Die FIBO-Werte können also als Unterstützungs- oder Widerstandsniveaus dienen.
Wir können diese Niveaus auch über das Fenster dieses Werkzeugs kontrollieren, indem wir mit der rechten Maustaste auf das Zeichenwerkzeug klicken oder mit der rechten Maustaste auf das Chart klicken und dann die Objektliste aus dem Menü auswählen und dann das Fibo-Objekt auswählen:
Wir können den Namen des Objekts und seinen Stil, wie Farbe, Linientyp und Dicke, über den vorherigen gemeinsamen Tippen steuern.
Wie wir in der vorherigen Abbildung sehen können, können wir die gewünschten Einstellungen und den Stil kontrollieren und festlegen.
Wie wir in dem Parameter-Fenster sehen können, können wir das Datum, die Zeit und den Wert bestimmen, mit dem wir beginnen wollen, sowie das Datum, die Zeit und den Wert, mit dem das Fibonacci-Objekt enden soll.
Fibonacci: Strategie
In diesem Teil werden wir lernen, wie man das Fibonacci-Retracement durch einfache Strategien, die auf zwei verschiedenen Ansätzen basieren, nutzen kann. Eine davon besteht darin, die FIBO-Levels auf der Grundlage des letzten Tagesbalkens zu bestimmen, und die zweite besteht darin, die Anzahl der Balken in einem beliebigen Zeitrahmen zu bestimmen und die FIBO-Levels auf der Grundlage dieses Balkens zu ermitteln. Dann werden wir eine andere Strategie verwenden, um ein spezifisches Kauf- oder Verkaufssignal zu erhalten, das auf einem bestimmten, vorher festgelegten FIBO-Level für jeden Ansatz basiert, und im Folgenden finden Sie weitere Einzelheiten zu diesen Strategien.
Der erste Ansatz: Verwendung von Tagesdaten:
Einfaches FIBO-System:
Wenn der letzte Tagesbalken aufwärts ist, müssen wir einen Aufwärts-FIBO vom Tief bis zum Hoch des Balkens und die Preisniveaus jedes Niveaus ermitteln. Wenn der letzte Tagesbalken abwärts ist, müssen wir einen roten Abwärts-FIBO vom Hoch bis zum Tief dieses Balkens und die Preisniveaus dieses FIBO ermitteln.
Einfach:
Schlusskurs des letzten Tages > Eröffnung ==> Aufwärtsbalken
Abrufen der grünen FIBO-Werte und Preise für diese Werte.
Schlusskurs des letzten Tages < Eröffnung ==> Abwärtsbalken
Abrufen der roten FIBO-Werte und Preise für diese Werte.
FIBO-Signale:
Auf der Grundlage dieser Strategie müssen wir Kauf- und Verkaufseinstiege auf der Basis der von uns als aufwärts oder abwärts eingestuften FIBO-Werte vornehmen. Wenn wir ein Niveau von 38,2 des Aufwärts-FIBO ermittelt haben, müssen wir das Preisniveau dieses Niveaus als Kaufeinstieg nehmen und wenn wir das gleiche Niveau des Abwärts-FIBO ermitteln, müssen wir den Preis dieses Niveaus als Verkaufseinstieg nehmen.
Der zweite Ansatz: Verwendung einer Reihe bestimmter Balken:
Einfaches FIBO-System 2:
Basierend auf dieser Strategie müssen wir FIBO-Kursniveaus basierend auf einer Reihe von Balken erhalten. Wenn wir ein Aufwärts-FIBO basierend auf der Richtung der Reihe haben, müssen wir FIBO-Kursniveaus erhalten, und wenn wir ein Abwärts-FIBO basierend auf der Richtung der Reihe haben, müssen wir seine Preis-FIBO-Niveaus erhalten.
Einfach:
Wenn die Eröffnung des ersten Balkens im Array < der Schluss des letzten Balkens desselben Arrays ==> Aufwärts-FIBO ist, müssen wir die Kursniveaus dieses Aufwärts-FIBO ermitteln.
Wenn der Eröffnungskurs des ersten Balkens im Array > der Schlusskurs des letzten Balkens desselben Arrays ==> Abwärts-FIBO ist, müssen wir die Kursniveaus dieses Abwärts-FIBO ermitteln.
FIBO-Signale 2:
Auf der Grundlage dieser Strategie müssen wir die Kauf- oder Verkaufseinträge auf der Grundlage der Nutzereingabe des gewünschten FIBO-Levels als Einstiegsniveau ermitteln. Wenn wir einen Aufwärts-FIBO haben, der auf dem zuvor beschriebenen Ansatz basiert, müssen wir einen Kaufeinstieg auf einem bestimmten FIBO-Niveau finden. Wenn wir ein Abwärts-FIBO haben, müssen wir ein Verkaufs-Einstiegsniveau von einem bestimmten FIBO-Niveau erhalten.
Fibonacci: Blaupause der Strategie
In diesem Teil werden wir Blaupausen für jede der beiden genannten Strategien sehen, um zu verstehen, was wir mit einer visuellen Methode tun müssen.
Der erste Ansatz: Verwendung von Tagesdaten:
Wie bereits erwähnt, werden wir den letzten Tagesbalken verwenden und deren Eröffnungs-, Schluss-, Höchst- und Tiefstkurs bestimmen. Durch den Vergleich des Eröffnungs- und des Schlusskurses können wir feststellen, ob es sich um eine Aufwärts- oder Abwärtsbalken handelt. Basierend auf dem Bewegungstyp dieses letzten Tagesbalkens werden wir das Fibonacci Objekt zeichnen und die gewünschten Signale erhalten.
Einfaches FIBO-System:
FIBO-Signale:
Der zweite Ansatz: Array mit bestimmten Balken verwenden:
Wie bereits erwähnt, werden wir eine bestimmte Anzahl von Balken in einem Array verwenden und den Eröffnungskurs des ersten Balkens, den Schlusskurs des letzten Balkens, den höchsten Wert und den niedrigsten Wert ermitteln. Durch den Vergleich des Eröffnungs- und des Schlusskurses können wir feststellen, ob es sich um eine Aufwärts- oder Abwärtsbalken handelt. Basierend auf dem Bewegungstyp dieses Arrays werden wir das Fibonacci Objekt zeichnen und die gewünschten Signale erhalten.
Einfaches FIBO-System 2:
FIBO-Signale 2:
Fibonacci: Handelssystem
In diesem Teil werden wir lernen, wie man ein Handelssystem erstellt, das auf dem zuvor genannten basiert. Wir werden ein Programm erstellen, das Fibonacci-Levels auf dem Chart als Kommentar zurückgeben kann. Wir werden zwei Ansätze verwenden. Der erste besteht darin, die letzten Tagesdaten zu verwenden, um darauf basierend unsere Fibonacci-Levels zu zeichnen, und der andere Ansatz besteht darin, eine vorher festgelegte Anzahl von Balken zu verwenden, um sie als Array dafür zu nutzen. Wir werden auch lernen, wie wir diese beiden Ansätze nutzen können, um Kauf- und Verkaufssignale auf der Grundlage von Fibonacci zu erhalten, was wir uns im Detail ansehen werden.
Der erste Ansatz: Verwendung von Tagesdaten:
Einfaches FIBO-System:
Bei dieser Strategie werden wir tägliche Daten verwenden, die für das Fibonacci-System genutzt werden:
Definition des benötigten Objektnamens durch Verwendung der Makro-Substitution (#define) zur Vorverarbeitung des Quellcodes vor dem Kompilieren.
#define FIB_OBJ "Fibonacci Retracement"
Erstellen einer Integer-Variable für barsTotal.
int barsTotal; Danach wird in onTick eine Integer-Variable für die Balken (bars) mit der Zuweisung der Funktion iBar erstellt, um die Anzahl der verfügbaren historischen Balken des Symbols zurückzugeben. Die Parameter sind:
- symbol: Um das gewünschte Symbol zu bestimmen, verwenden wir _Symbol für das aktuelle Symbol.
- timeframe: Um den Zeitraum zu bestimmen, verwenden wir D1 für das TagesChart.
int bars = iBars(_Symbol, PERIOD_D1);
Wir stellen eine Bedingung auf, um den Tagesbalken zu erkennen, die wir für unsere Fibonacci verwenden müssen, da wir benötigen, dass barsTotal nicht gleich bars ist, indem wir den (!=)-Operator verwenden, und gleichzeitig benötigen wir, dass die aktuelle Zeit größer als die Endzeit dieses Tagesbalkens ist. Daher werden wir die TimeCurrent-Funktion und die StringToTime-Funktion verwenden, um einen String, der die Zeit enthält, in eine Zahl vom Typ Datum umzuwandeln.
if(barsTotal != bars && TimeCurrent() > StringToTime("00:05"))
Sobald diese Bedingung erfüllt ist, muss das Programm Folgendes tun:
Zuweisen von bars an barsTotal.
barsTotal=bars;
Löschen eines beliebigen FIB_OBJ im Chart mit der Funktion ObjectDelete, deren Parameter sind:
- chart_id: Um die Kennung des Charts zu bestimmen, verwenden wir (0), d.h. das aktuelle Chart.
- name: zur Bestimmung des Objektnamens, der (FIB_OBJ) lautet.
ObjectDelete(0,FIB_OBJ);
Erstellen der vier Preisvariablen (open, close, high und low), indem wir die Funktionen iOpen, iClose, iHigh und iLow verwenden, um den Preis des Tagesbalkens zu ermitteln. Die Parameter sind:
- symbol: Um das gewünschte Symbol zu bestimmen, verwenden wir _Symbol, das für das aktuelle Symbol verwendet wird.
- timeframe: Um den gewünschten Zeitrahmen zu bestimmen, wird (PERIOD_D1) für den täglichen Zeitrahmen verwendet.
- shift: um den Index des empfangenen Wertes aus der Zeitreihe zu bestimmen, wird er hier nicht verwendet.
double open = iOpen(_Symbol,PERIOD_D1,1); double close = iClose(_Symbol,PERIOD_D1,1); double high = iHigh(_Symbol,PERIOD_D1,1); double low = iLow(_Symbol,PERIOD_D1,1);
Bestimmen der Startzeit und die Endzeit, die später zum Zeichnen unseres Fibonacci-Objekts verwendet werden sollen. Wir werden die Funktion iTime verwenden, die die Öffnungszeit des Balken zurückgibt. Die Parameter sind:
- symbol: Um das gewünschte Symbol zu bestimmen, verwenden wir _Symbol, das für das aktuelle Symbol verwendet wird.
- timeframe: Um den gewünschten Zeitrahmen zu bestimmen, wird (PERIOD_D1) für den täglichen Zeitrahmen verwendet.
- shift: um den Index des empfangenen Wertes aus der Zeitreihe zu bestimmen, verwenden wir 1 für die Startzeit und 0 für die Endzeit.
Für die Endzeit subtrahieren wir 1 vom Rückgabewert, da es sich um den neuen Tag handelt, der zum Zeitpunkt dieser Berechnung der aktuelle Tagesbalken ist, so dass wir dies tun, um die vorherige Bedeutung des Balkens zu erkennen.
datetime startingTime = iTime(_Symbol,PERIOD_D1,1); datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1;
Danach werden wir zwei Bedingungen festlegen, indem wir den if-else-Bedingungsoperator verwenden, um das Fibonacci-Objekt zu zeichnen:
Ist der Schlusskurs größer als der Eröffnungskurs, so handelt es sich um eine Aufwärtsbalken, und die folgenden Ereignisse werden eintreten.
Erstellen Sie das Objekt mit Hilfe der Funktion ObjectCreate, um das Objekt mit den angegebenen Zeichen zu zeichnen. Die Parameter sind:
- chart_id: Um das Chart zu bestimmen, wird 0 für das aktuelle Chart verwendet.
- name: Um den Namen des gewünschten Objekts zu bestimmen, verwenden wir FIB_OBJ.
- type: Um den Objekttyp zu bestimmen, verwenden wir OBJ_FIBO für das Fibonacci-Retracement.
- nwin: um den Fensterindex zu bestimmen, wird 0 für das Hauptfenster verwendet
- time1: Um den Zeitpunkt des ersten Punktes zu bestimmen, wird die Startzeit verwendet.
- price1: Um den Preis des ersten Punktes zu bestimmen, wird der Tiefstwert verwendet.
- timeN=0: Um den Zeitpunkt des letzten Punktes zu bestimmen, wird die Endzeit verwendet.
- priceN=0: Um den Preis des letzten Punktes zu bestimmen, wird der Höchststand verwendet.
Aktualisierung der Farbe des Objekts zur Anpassung an die Richtung des Balkens mit Hilfe von ObjectSetInteger und der for-Schleife. Parameter von ObjectSetInteger sind:
- chart_id: Um das Chart zu bestimmen, wird 0 für das aktuelle Chart verwendet.
- name: Um den Namen des Objekts zu bestimmen, wird FIB_OBJ verwendet.
- prop_id: Um die Eigenschafts-ID (Farbe) zu bestimmen, verwenden wir OBJPROP_COLOR.
- prop_value: Um den Eigenschaftswert zu bestimmen, wird clrGreen verwendet.
- Verwendung der for-Schleife zur kontinuierlichen Aktualisierung der Objektfarbe.
if(close>open) { ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen); } double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits); double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits); double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits); double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits); double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits); Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Fib lvl 0% = ",high,"\n", "Fib lvl 23.6% = ",fibRetracLvl1,"\n", "Fib lvl 38.2% = ",fibRetracLvl2,"\n", "Fib lvl 50% = ",fibRetracLvl3,"\n", "Fib lvl 61.8% = ",fibRetracLvl4,"\n", "Fib lvl 100% = ",fibRetracLvl5); }
Im Falle eines Tages mit einer Abwärtsbewegung wird das Gleiche passieren, aber der Unterschied wird derselbe sein wie folgt:
- Erstellen des Objekts mit Begin von oben nach unten.
- Die Farbe des Objekts soll rot sein.
else { ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed); } double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits); double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits); double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits); double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits); double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits); Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Fib lvl 0% = ",low,"\n", "Fib lvl 23.6% = ",fibRetracLvl1,"\n", "Fib lvl 38.2% = ",fibRetracLvl2,"\n", "Fib lvl 50% = ",fibRetracLvl3,"\n", "Fib lvl 61.8% = ",fibRetracLvl4,"\n", "Fib lvl 100% = ",fibRetracLvl5); }
Das Folgende ist der vollständige Code dieser Strategie:
//+------------------------------------------------------------------+ //| Simple Fibo System#2.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" #define FIB_OBJ "Fibonacci Retracement" #property script_show_inputs input double fibRetracLvl = 38.2; int barsTotal; //+------------------------------------------------------------------+ void OnTick() { int bars = iBars(_Symbol, PERIOD_D1); if(barsTotal != bars && TimeCurrent() > StringToTime("00:05")) { barsTotal=bars; ObjectDelete(0,FIB_OBJ); double open = iOpen(_Symbol,PERIOD_D1,1); double close = iClose(_Symbol,PERIOD_D1,1); double closeCandle = iClose(_Symbol,_Period,1); double high = iHigh(_Symbol,PERIOD_D1,1); double low = iLow(_Symbol,PERIOD_D1,1); datetime startingTime = iTime(_Symbol,PERIOD_D1,1); datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1; if(close>open) { ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen); } double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits); double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits); double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits); double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits); double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits); double entryLvl = NormalizeDouble(high - (high-low) * fibRetracLvl /100,_Digits); Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Buy Entry Price: ",entryLvl,"\n", "Close: ",closeCandle,"\n"); } else { ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed); } double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits); double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits); double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits); double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits); double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits); double entryLvl = NormalizeDouble(low + (high-low) * fibRetracLvl /100,_Digits); { Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Sell Entry Price: ",entryLvl,"\n", "Close: ",closeCandle); } } } } //+------------------------------------------------------------------+
Nachfolgend der vollständige Code dieses Handelssystems:
//+------------------------------------------------------------------+ //| Simple Fibo System#1.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" #define FIB_OBJ "Fibonacci Retracement" int barsTotal; //+------------------------------------------------------------------+ void OnTick() { int bars = iBars(_Symbol, PERIOD_D1); if(barsTotal != bars && TimeCurrent() > StringToTime("00:05")) { barsTotal=bars; ObjectDelete(0,FIB_OBJ); double open = iOpen(_Symbol,PERIOD_D1,1); double close = iClose(_Symbol,PERIOD_D1,1); double high = iHigh(_Symbol,PERIOD_D1,1); double low = iLow(_Symbol,PERIOD_D1,1); datetime startingTime = iTime(_Symbol,PERIOD_D1,1); datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1; if(close>open) { ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen); } double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits); double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits); double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits); double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits); double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits); Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Fib lvl 0% = ",high,"\n", "Fib lvl 23.6% = ",fibRetracLvl1,"\n", "Fib lvl 38.2% = ",fibRetracLvl2,"\n", "Fib lvl 50% = ",fibRetracLvl3,"\n", "Fib lvl 61.8% = ",fibRetracLvl4,"\n", "Fib lvl 100% = ",fibRetracLvl5); } else { ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed); } double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits); double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits); double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits); double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits); double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits); Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Fib lvl 0% = ",low,"\n", "Fib lvl 23.6% = ",fibRetracLvl1,"\n", "Fib lvl 38.2% = ",fibRetracLvl2,"\n", "Fib lvl 50% = ",fibRetracLvl3,"\n", "Fib lvl 61.8% = ",fibRetracLvl4,"\n", "Fib lvl 100% = ",fibRetracLvl5); } } } //+------------------------------------------------------------------+
Nach dem fehlerfreien Kompilieren und Ausführen dieses Codes finden wir die gleichen Signale wie in den folgenden Beispielen aus den Tests für Auf- und Abwärtsfälle.
Der Tagesbalken ist aufwärts:
Also, wir sollen FIBO von unten nach oben zeichnen, die Farbe ist grün, und die FIBO-Ebenen und Eröffnungs- und Schlusskurs des Tages sind die gleichen wie die des Charts. Dazu dient das folgende Bild.
Wie wir im vorhergehenden Bild sehen können, wird der FIBO gemäß des Aufwärts-Tagesbalkens von einem Tief zu einem Hoch gezogen und seine Farbe ist grün:
- Eröffnungskurs des letzten Tages ==> ist derselbe wie im Datenfenster des Tagescharts.
- Schlusskurs des letzten Tages ==> ist derselbe wie im Tageschart.
- Fünf Fibonacci-Retracement-Kursebenen.
Der Tagesbalken ist abwärts:
Die FIBO wird daher oben nach unten gezeichnet, die Farbe ist rot, und FIBO Ebenen und die Eröffnungs- und Schlusskurse sind die des Datenfensters. Dazu dient das folgende Bild.
Wie wir im vorhergehenden Bild sehen können, ist der FIBO entsprechend des Abwärts-Tagesbalken vom Hoch zum Tief gezeichnet und seine Farbe ist rot. Außerdem gibt wir einen Kommentar auf dem Chart mit den folgenden Werten:
- Der Eröffnungskurs des letzten Tages ==> ist derselbe wie im Datenfenster des Tagescharts.
- Der Schlusskurs des letzten Tages ==> ist derselbe wie im Tageschart.
- Fünf Fibonacci-Retracement-Kursebenen.
FIBO-Signale:
Nach diesem Ansatz müssen wir ein Handelssystem entwickeln, das Kauf- und Verkaufssignale auf der Grundlage der Nutzereingabe des Einstiegsniveaus auf der Basis der FIBO-Niveaus liefert. Im Folgenden finden Sie den vollständigen Code dazu:
//+------------------------------------------------------------------+ //| Simple Fibo System#2.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" #define FIB_OBJ "Fibonacci Retracement" #property script_show_inputs input double fibRetracLvl = 38.2; int barsTotal; //+------------------------------------------------------------------+ void OnTick() { int bars = iBars(_Symbol, PERIOD_D1); if(barsTotal != bars && TimeCurrent() > StringToTime("00:05")) { barsTotal=bars; ObjectDelete(0,FIB_OBJ); double open = iOpen(_Symbol,PERIOD_D1,1); double close = iClose(_Symbol,PERIOD_D1,1); double closeCandle = iClose(_Symbol,_Period,1); double high = iHigh(_Symbol,PERIOD_D1,1); double low = iLow(_Symbol,PERIOD_D1,1); datetime startingTime = iTime(_Symbol,PERIOD_D1,1); datetime endingTime = iTime(_Symbol,PERIOD_D1,0)-1; if(close>open) { ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,low,endingTime,high); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen); } double fibRetracLvl1 = NormalizeDouble(high - (high-low) * 23.6 / 100,_Digits); double fibRetracLvl2 = NormalizeDouble(high - (high-low) * 38.2 / 100,_Digits); double fibRetracLvl3 = NormalizeDouble(high - (high-low) * 50 / 100,_Digits); double fibRetracLvl4 = NormalizeDouble(high - (high-low) * 61.8 / 100,_Digits); double fibRetracLvl5 = NormalizeDouble(high - (high-low) * 100 / 100,_Digits); double entryLvl = NormalizeDouble(high - (high-low) * fibRetracLvl /100,_Digits); Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Buy Entry Price: ",entryLvl); } else { ObjectCreate(0,FIB_OBJ,OBJ_FIBO,0,startingTime,high,endingTime,low); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed); } double fibRetracLvl1 = NormalizeDouble(low + (high-low) * 23.6 / 100,_Digits); double fibRetracLvl2 = NormalizeDouble(low + (high-low) * 38.2 / 100,_Digits); double fibRetracLvl3 = NormalizeDouble(low + (high-low) * 50 / 100,_Digits); double fibRetracLvl4 = NormalizeDouble(low + (high-low) * 61.8 / 100,_Digits); double fibRetracLvl5 = NormalizeDouble(low + (high-low) * 100 / 100,_Digits); double entryLvl = NormalizeDouble(low + (high-low) * fibRetracLvl /100,_Digits); { Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Sell Entry Price: ",entryLvl); } } } } //+------------------------------------------------------------------+
Unterschiede in diesem Code:
Hinzufügen einer Eigenschaft zum Anzeigen des Nutzereingabefensters durch Verwendung von #property script_show_inputs, das ein Fenster mit den Eigenschaften anzeigt.
#property script_show_inputs
Mit Hilfe der Eingangsvariablen wird ein Double-Datentyp für fibRetracLvl mit einem Standardwert von 38,2 erstellt.
input double fibRetracLvl = 38.2;
Festlegung des Einstiegsniveaus auf der Grundlage der Nutzereingabe im Falle von aufwärts.
double entryLvl = NormalizeDouble(high - (high-low) * fibRetracLvl /100,_Digits);
Festlegung des Einstiegsniveaus auf der Grundlage der Nutzereingaben im Falle von abwärts.
double entryLvl = NormalizeDouble(low + (high-low) * fibRetracLvl /100,_Digits);
Kommentar auf dem Chart im Falle von Aufwärtsbalken.
Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Buy Entry Price: ",entryLvl,"\n", "Close: ",closeCandle,"\n");
Kommentar auf dem Chart im Falle eines Abwärtsbalkens.
Comment("Last Day Open = ",open,"\n", "Last Day Close = ",close,"\n", "Sell Entry Price: ",entryLvl,"\n", "Close: ",closeCandle);
Nach dem Kompilieren und Ausführen dieses Codes sind wir bereit, Signale zu empfangen, und wir werden Beispiele aus dem Test für den Auf- und den Abwärts-Fall sehen.
Der Tagesbalken ist aufwärts:
Wir sollen also das gezeichnete grüne FIBO vom Tief bis zum Hoch in 15 Minuten sehen, die Eröffnungs- und Schlusskurse des letzten Tages sind dieselben wie im Tageschart, und das Einstiegsniveau ist dasselbe Kursniveau neben der 38,2. Das Folgende für den 15-Minuten-Chart:
Wie wir im vorhergehenden 15-Minuten-Chart sehen können, haben wir die folgenden Werte ermittelt:
- Der Eröffnungskurs des letzten Tages ==> ist derselbe wie im Tageschart.
- Der Schlusskurs des letzten Tages ==> ist auch derselbe.
- Der Eröffnungspreis eines Kaufes ==> ist das gleiche Kursniveau neben dem 38,2 FIBO-Niveau.
Der Tagesbalken ist abwärts:
Nun werden wir uns den 15-Minuten-Chart ansehen, um unser Signal auf der Grundlage der Handelsstrategie zu erhalten. Es soll ein Verkaufs-Einstiegsniveau auf der Grundlage des FIBO-Niveaus 38,2 anzeigen. Überprüfen wir dies anhand des folgenden Bildes:
Wie wir sehen können, haben wir die folgenden Werte als Signal auf dem 15-Minuten-Chart:
- Der Eröffnungskurs des letzten Tages ==> ist derselbe wie im Tageschart.
- Der Schlusskurs des letzten Tages ==> ist auch derselbe.
- Einstiegskurs bei einem Verkauf ==> ist das gleiche Niveau nahe dem 38,2 FIBO-Niveau.
Der zweite Ansatz: Verwendung einer Reihe bestimmter Balken:
Einfaches FIBO-System 2:
Nach diesem Ansatz werden wir eine vorher festgelegte Anzahl von Balken für die Fibonacci-Erstellung verwenden:
Definition des FIB_OBJ durch die Verwendung von #define.
#define FIB_OBJ "Fibonacci Retracement"
Erstellung von zwei ganzzahligen Variablen für den höchsten und den niedrigsten Balken.
int highestCandle, lowestCandle; Erstellen von zwei Arrays für High und Low.
double high[],low[]; Festlegen der Zugriffsrichtung der Daten der Arrays high und low mit Hilfe der Funktion "ArraySetAsSeries". Die Parameter:
- array[]: um die erstellten Arrays high und low zu bestimmen.
- Flags: Array-Indizierungsrichtung, die wahr (true) sein wird.
ArraySetAsSeries(high,true); ArraySetAsSeries(low,true);
Abrufen der historischen Daten des höchsten und des niedrigsten Wertes mit Hilfe von CopyHigh und CopyLow. CopyHigh-Parameter sind:
- symbol_name: wir werden (_Symbol) für das aktuelle Symbol.
- timeframe: Wir verwenden (_Period) für den aktuellen Zeitrahmen.
- start_pos: um die Startposition zu bestimmen, wird 0 für den aktuellen Balken verwendet.
- count: Um die Anzahl der zu kopierenden Daten zu bestimmen, werden wir 100 verwenden.
- high_array[]: Um das Ziel-Array zu bestimmen, verwenden wir das erstellte High-Array.
Bei CopyLow sind die Parameter die gleichen, aber das Ziel-Array wird als Low-Array erstellt.
CopyHigh(_Symbol,_Period,0,100,high); CopyLow(_Symbol,_Period,0,100,low);
Festlegung des Eröffnungskurses den ersten Balken im Array und des Schlusskurses des letzten Balkens im Array mit Hilfe der Funktionen iOpen und iClose.
double openCandle = iOpen(_Symbol,_Period,100); double closeCandle = iClose(_Symbol,_Period,1);
Festlegung des höchsten und niedrigsten Wertes in den erstellten High und Low Arrays durch die Verwendung von ArrayMaximum und ArrayMinimum der Balken. Die Parameter sind:
- array[]: Wir verwenden high für den Höchstwert und low für den Mindestwert.
- start=0: um den Index zu bestimmen, mit dem die Prüfung beginnen soll, wird 0 verwendet.
- count: um die Anzahl der zu prüfenden Elemente zu bestimmen, verwenden wir 100 oder wir können auch WHOLE_ARRAY verwenden.
highestCandle=ArrayMaximum(high,0,100); lowestCandle=ArrayMinimum(low,0,100);
Erstellen eines Arrays für den Preis mit Hilfe der Funktion MqlRates, um Informationen über Preise zu speichern, und Sortieren der Daten in diesem Array mit Hilfe der Funktion ArraySetAsSeries.
MqlRates pArray[]; ArraySetAsSeries(pArray,true);
Abrufen von historischen Daten aus MqlRates durch die Funktion CopyRates und ihre Parameter sind:
- symbol_name: Um den Symbolnamen zu bestimmen, verwenden wir (_Symbol), das für das aktuelle Symbol angewendet wird.
- timeframe: Zur Bestimmung des Zeitrahmens des Charts wird „_Period“ verwendet, der für den aktuellen Zeitrahmen gilt.
- start_pos: Um den Startpunkt oder die Position zu bestimmen, verwenden wir 0, um von der aktuellen Position auszugehen.
- count: Um die zu kopierende Anzahl zu bestimmen, wir verwenden (Balken).
- rates_array[]: Wir verwenden pArray als Zielarray für die Daten.
int pData=CopyRates(_Symbol,_Period,0,Bars(_Symbol,_Period),pArray);
Definieren von dateTime und des Preises der Nulllinie und der 100er-Linie mit Hilfe von ObjectGetInteger und ObjectGetDouble
datetime dTlvl0 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,0); double PriceFibLvl00 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,0); datetime dTlvl1 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,1); double PriceFibLvl0 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,1);
Feststellen der Bewegung von auf- oder abwärts mit Hilfe des if-else-Operators.
Im Falle einer Aufwärtsbewegung (CloseCandle ist größer als openCandle) müssen die folgenden Schritte durchgeführt werden:
- Löschen des zuvor gezeichneten FIBO-Objekts mit ObjectDelete.
- Erstellen eines neuen FIBO-Objekts, beginnend mit dem niedrigsten bis zum höchsten Wert des Arrays, mit ObjectCreate.
- Aktualisierung der Farbe des FIBO-Objekts zu grüner Farbe durch Verwendung von ObjectSetInteger und for-Schleife für die Fortsetzung der Aktualisierung je nach Fall.
- Festlegung der Preisspanne durch Ermittlung der Differenz zwischen Höchst- und Tiefstpreis.
- Definition der FIBO-Werte: 23,6 - 38,2 - 50 - 61,8.
- Kommentare auf dem Chart mit Array Open, Array Close und FIBO-Levels.
if(closeCandle>openCandle) { ObjectDelete(_Symbol, "Fibonacci Retracement"); ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time, pArray[lowestCandle].low,pArray[0].time,pArray[highestCandle].high); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen); } double pRange = PriceFibLvl0 - PriceFibLvl00; double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 - pRange * 23.6/100,_Digits); double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 - pRange * 38.2/100,_Digits); double PriceFibLvl3 = NormalizeDouble (PriceFibLvl0 - pRange * 50/100,_Digits); double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 - pRange * 61.8/100,_Digits); Comment("Array Open: ",openCandle,"\n", "Array Close: ",closeCandle,"\n", "Fib lvl 0% = ",PriceFibLvl0,"\n", "Fib lvl 23.6% = ",PriceFibLvl1,"\n", "Fib lvl 38.2% = ",PriceFibLvl2,"\n", "Fib lvl 50% = ",PriceFibLvl3,"\n", "Fib lvl 61.8% = ",PriceFibLvl4,"\n", "Fib lvl 100% = ",PriceFibLvl00); }
Im Falle einer Abwärtsbewegung (CloseCandle ist niedriger als openCandle), müssen wir die folgenden Schritte durchführen:
- Löschen des zuvor gezeichneten FIBO-Objekts mit ObjectDelete.
- Erstellen eines neuen FIBO-Objekts, beginnend mit dem höchsten bis zum niedrigsten Wert des Arrays, mit ObjectCreate.
- Aktualisierung der Farbe des FIBO-Objekts auf Rot durch Verwendung von ObjectSetInteger und for-Schleife zur weiteren Aktualisierung je nach Fall.
- Festlegung der Preisspanne durch Ermittlung der Differenz zwischen dem niedrigsten und dem höchsten Preis.
- Definition der FIBO-Werte: 23,6 - 38,2 - 50 - 61,8.
- Kommentare auf dem Chart mit Array Open, Array Close und FIBO-Levels.
else { ObjectDelete(_Symbol, "Fibonacci Retracement"); ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time, pArray[highestCandle].high,pArray[0].time,pArray[lowestCandle].low); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed); } double pRange = PriceFibLvl00 - PriceFibLvl0; double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 + pRange * 23.6/100,_Digits); double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 + pRange * 38.2/100,_Digits); double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 + pRange * 50/100,_Digits); double PriceFibLvl4 = NormalizeDouble (PriceFibLvl0 + pRange * 61.8/100,_Digits); Comment("Array Open: ",openCandle,"\n", "Array Close: ",closeCandle,"\n", "Fib lvl 0% = ",PriceFibLvl0,"\n", "Fib lvl 23.6% = ",PriceFibLvl1,"\n", "Fib lvl 38.2% = ",PriceFibLvl2,"\n", "Fib lvl 50% = ",PriceFibLvl3,"\n", "Fib lvl 61.8% = ",PriceFibLvl4,"\n", "Fib lvl 100% = ",PriceFibLvl00); }
Im Folgenden finden Sie den vollständigen Code:
//+------------------------------------------------------------------+ //| Simple Fibo System 2.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" #define FIB_OBJ "Fibonacci Retracement" //+------------------------------------------------------------------+ void OnTick() { int highestCandle, lowestCandle; double high[],low[]; ArraySetAsSeries(high,true); ArraySetAsSeries(low,true); CopyHigh(_Symbol,_Period,0,100,high); CopyLow(_Symbol,_Period,0,100,low); double openCandle = iOpen(_Symbol,_Period,100); double closeCandle = iClose(_Symbol,_Period,1); highestCandle=ArrayMaximum(high,0,100); lowestCandle=ArrayMinimum(low,0,100); MqlRates pArray[]; ArraySetAsSeries(pArray,true); int pData=CopyRates(_Symbol,_Period,0,Bars(_Symbol,_Period),pArray); datetime dTlvl0 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,0); double PriceFibLvl00 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,0); datetime dTlvl1 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,1); double PriceFibLvl0 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,1); if(closeCandle>openCandle) { ObjectDelete(_Symbol, "Fibonacci Retracement"); ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time, pArray[lowestCandle].low,pArray[0].time,pArray[highestCandle].high); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen); } double pRange = PriceFibLvl0 - PriceFibLvl00; double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 - pRange * 23.6/100,_Digits); double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 - pRange * 38.2/100,_Digits); double PriceFibLvl3 = NormalizeDouble (PriceFibLvl0 - pRange * 50/100,_Digits); double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 - pRange * 61.8/100,_Digits); Comment("Array Open: ",openCandle,"\n", "Array Close: ",closeCandle,"\n", "Fib lvl 0% = ",PriceFibLvl0,"\n", "Fib lvl 23.6% = ",PriceFibLvl1,"\n", "Fib lvl 38.2% = ",PriceFibLvl2,"\n", "Fib lvl 50% = ",PriceFibLvl3,"\n", "Fib lvl 61.8% = ",PriceFibLvl4,"\n", "Fib lvl 100% = ",PriceFibLvl00); } else { ObjectDelete(_Symbol, "Fibonacci Retracement"); ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time, pArray[highestCandle].high,pArray[0].time,pArray[lowestCandle].low); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed); } double pRange = PriceFibLvl00 - PriceFibLvl0; double PriceFibLvl1 = NormalizeDouble (PriceFibLvl0 + pRange * 23.6/100,_Digits); double PriceFibLvl2 = NormalizeDouble (PriceFibLvl0 + pRange * 38.2/100,_Digits); double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 + pRange * 50/100,_Digits); double PriceFibLvl4 = NormalizeDouble (PriceFibLvl0 + pRange * 61.8/100,_Digits); Comment("Array Open: ",openCandle,"\n", "Array Close: ",closeCandle,"\n", "Fib lvl 0% = ",PriceFibLvl0,"\n", "Fib lvl 23.6% = ",PriceFibLvl1,"\n", "Fib lvl 38.2% = ",PriceFibLvl2,"\n", "Fib lvl 50% = ",PriceFibLvl3,"\n", "Fib lvl 61.8% = ",PriceFibLvl4,"\n", "Fib lvl 100% = ",PriceFibLvl00); } } //+------------------------------------------------------------------+
Nach dem Kompilieren und Ausführen dieses Codes können wir die folgenden Signale für einen EA finden. Nachfolgend finden Sie Beispiele für Signale aus Tests.
Im Falle eines Aufwärts-Arrays:
Wie wir sehen können, haben wir ein grünes FIBO-Objekt im Chart und einen Kommentar oben links im Chart mit den folgenden Werten gemäß diesem EA:
- Array open ==> für den Eröffnungskurs des ersten Balkens des Arrays.
- Array close ==> für den Schlusskurs des letzten Balkens des Arrays.
- FIBO-Werte 0, 23,6, 38,2, 50, 61,8, 100.
Im Falle eines Abwärts-Arrays:
Wie wir sehen können, haben wir ein rotes FIBO-Objekt auf dem Chart und einen Kommentar oben links auf dem Chart mit den folgenden Werten gemäß diesem EA:
- Array open ==> für den Eröffnungskurs des ersten Balkens des Arrays.
- Array close ==> für den Schlusskurs des letzten Balkens des Arrays.
- FIBO-Werte 0, 23,6, 38,2, 50, 61,8, 100.
FIBO-Signale 2:
Nun werden wir auf der Grundlage des zweiten Ansatzes ein Handelssystem erstellen, das Kauf- und Verkaufssignale auf der Grundlage des vom Nutzer eingegebenen FIBO-Levels liefert. Nachfolgend der vollständige Code zur Erstellung dieses einfachen Handelssystems.
//+------------------------------------------------------------------+ //| Fibo Signals 2.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" #define FIB_OBJ "Fibonacci Retracement" #property script_show_inputs input double fibRetracLvl = 38.2; //+------------------------------------------------------------------+ void OnTick() { int highestCandle, lowestCandle; double high[],low[]; ArraySetAsSeries(high,true); ArraySetAsSeries(low,true); CopyHigh(_Symbol,_Period,0,100,high); CopyLow(_Symbol,_Period,0,100,low); double openCandle = iOpen(_Symbol,_Period,100); double closeCandle = iClose(_Symbol,_Period,1); highestCandle=ArrayMaximum(high,0,100); lowestCandle=ArrayMinimum(low,0,100); MqlRates pArray[]; ArraySetAsSeries(pArray,true); int pData=CopyRates(_Symbol,_Period,0,Bars(_Symbol,_Period),pArray); datetime dTlvl0 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,0); double PriceFibLvl00 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,0); datetime dTlvl1 = ObjectGetInteger(0,"Fibonacci Retracement",OBJPROP_TIME,1); double PriceFibLvl0 = ObjectGetDouble(0,"Fibonacci Retracement",OBJPROP_PRICE,1); if (closeCandle>openCandle) { ObjectDelete(_Symbol, "Fibonacci Retracement"); ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time, pArray[lowestCandle].low,pArray[0].time,pArray[highestCandle].high); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrGreen); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrGreen); } double pRange = PriceFibLvl0 - PriceFibLvl00; double PriceFibLvl1 = NormalizeDouble(PriceFibLvl0 - pRange * 23.6/100,_Digits); double PriceFibLvl2 = NormalizeDouble(PriceFibLvl0 - pRange * 38.2/100,_Digits); double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 - pRange * 50/100,_Digits); double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 - pRange * 61.8/100,_Digits); double entryLvl = NormalizeDouble(PriceFibLvl0 - pRange * fibRetracLvl/100,_Digits); Comment("Array Open: ",openCandle,"\n", "Array Close: ",closeCandle,"\n", "Buy Entry Price: ",entryLvl); } else { ObjectDelete(_Symbol, "Fibonacci Retracement"); ObjectCreate(_Symbol, "Fibonacci Retracement",OBJ_FIBO,0,pArray[100].time, pArray[highestCandle].high,pArray[0].time,pArray[lowestCandle].low); ObjectSetInteger(0,FIB_OBJ,OBJPROP_COLOR,clrRed); for(int i = 0; i < ObjectGetInteger(0,FIB_OBJ,OBJPROP_LEVELS); i++) { ObjectSetInteger(0,FIB_OBJ,OBJPROP_LEVELCOLOR,i,clrRed); } double pRange = PriceFibLvl00 - PriceFibLvl0; double PriceFibLvl1 = NormalizeDouble(PriceFibLvl0 + pRange * 23.6/100,_Digits); double PriceFibLvl2 = NormalizeDouble(PriceFibLvl0 + pRange * 38.2/100,_Digits); double PriceFibLvl3 = NormalizeDouble(PriceFibLvl0 + pRange * 50/100,_Digits); double PriceFibLvl4 = NormalizeDouble(PriceFibLvl0 + pRange * 61.8/100,_Digits); double entryLvl = NormalizeDouble(PriceFibLvl0 + pRange * fibRetracLvl/100,_Digits); Comment("Array Open: ",openCandle,"\n", "Array Close: ",closeCandle,"\n", "Sell Entry Price: ",entryLvl); } } //+------------------------------------------------------------------+
Unterschiede in diesem Code:
Hinzufügen einer Eigenschaft mit #property script_show_inputs, die ein Fenster mit den Eigenschaften anzeigt und eine Eingabevariable verwendet, um einen doppelten Datentyp für fibRetracLvl mit einem Standardwert von beispielsweise 38,2 zu erstellen.
#property script_show_inputs input double fibRetracLvl = 38.2;
Festlegung des Einstiegsniveaus auf der Grundlage der Nutzereingabe beim Aufwärtssignal.
double entryLvl = NormalizeDouble(PriceFibLvl0 - pRange * fibRetracLvl/100,_Digits);
Festlegung des Einstiegsniveaus auf der Grundlage der Nutzereingaben im Abwärtssignal.
double entryLvl = NormalizeDouble(PriceFibLvl0 + pRange * fibRetracLvl/100,_Digits);
Kommentar auf der Grundlage des Aufwärtssignals.
Comment("Array Open: ",openCandle,"\n", "Array Close: ",closeCandle,"\n", "Buy Entry Price: ",entryLvl);
Kommentar auf der Grundlage des Abwärtssignals.
Comment("Array Open: ",openCandle,"\n", "Array Close: ",closeCandle,"\n", "Sell Entry Price: ",entryLvl);
Nach dem Kompilieren und Ausführen dieses Codes erhalten wir die gleichen Signale wie in den folgenden Beispielen für aufwärts und abwärts Arrays aus dem Test.
Es ist ein Aufwärts-Array:
Wie wir sehen können, haben wir ein grünes FIBO-Objekt, das vom niedrigsten Wert bis zum höchsten Wert des Arrays gezeichnet wird, und die folgenden Werte als Kommentar im Chart:
- Array open ==> ist der gleiche Wert wie der Eröffnungskurs des ersten Balkens des Arrays.
- Array close ==> ist der gleiche Wert wie der Schlusskurs des letzten Balkens im Array.
- Der Einstiegskurs ==> ist derselbe Wert wie die 38,2 FIBO-Marke.
Es ist ein Abwärts-Array:
Wie wir sehen können, haben wir ein rotes FIBO-Objekt, das vom höchsten Wert bis zum niedrigsten Wert des Arrays gezeichnet ist, und die folgenden Werte als Kommentar im Chart:
- Array open ==> ist der gleiche Wert wie der Eröffnungskurs des ersten Balkens des Arrays.
- Array close ==> ist der gleiche Wert wie der Schlusskurs des letzten Balkens im Array.
- Der Einstiegspreis für den Verkauf ==> ist der gleiche Wert wie die 38,2 FIBO-Marke.
Schlussfolgerung
Nun, es ist davon auszugehen, dass Sie gelernt haben, wie man ein einfaches Fibonacci-Handelssystem mit MQL5 erstellt, um es für den MetaTrader 5 zu verwenden, nachdem Sie das technische Fibonacci-Tool im Detail durch das Thema der Fibonacci-Definition kennengelernt haben und Sie gelernt haben, wie wir es nach dem Einfügen in den MetaTrader 5 verwenden können.
Außerdem haben wir hier zwei Ansätze zur Erstellung der Fibonacci-Levels vorgestellt, von denen einer die Tagesdaten und der andere ein Array spezifischer Balken in einem beliebigen Zeitrahmen verwendet, um die Fibonacci-Levels zu ermitteln und auf der Grundlage dieser Levels Einstiegslevels zum Kauf oder Verkauf zu erhalten. Ich bekräftige noch einmal, dieses Tool mit anderen technischen Tools zu kombinieren, um bessere Ergebnisse zu erzielen, und Sie müssen die erwähnten Strategien oder Konzepte testen, bevor Sie sie auf Ihrem realen Konto verwenden, um sicherzustellen, dass sie für Ihren Handel profitabel sind, und es gibt nichts, was für jeden geeignet ist, außerdem ist das Hauptziel hier nur lehrreich und Sie können einige Verfeinerungen oder Optimierungen für die erwähnten Strategien finden.
Ich hoffe, dass dieser Artikel für Sie nützlich und aufschlussreich ist, weil Sie etwas Neues lernen oder Ihre Augen für neue Ideen öffnen, die Ihre Handelsergebnisse verbessern können. Wenn Sie mehr ähnliche Artikel über die Entwicklung von Handelssystemen auf der Grundlage der beliebtesten technischen Indikatoren und Tools lesen möchten, können Sie meine anderen Artikel in dieser Serie lesen, da wir die meisten der beliebten Indikatoren wie gleitende Durchschnitte, MACD, Bollinger Bands, Stochastik usw. teilen, und ich hoffe, dass Sie sie auch nützlich finden werden.
Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/12301
Datenwissenschaft und maschinelles Lernen (Teil 12): Können selbstlernende neuronale Netze Ihnen helfen, den Aktienmarkt zu überlisten?
Algorithmen zur Optimierung mit Populationen: Saplings Sowing and Growing up (SSG)
Datenwissenschaft und maschinelles Lernen (Teil 13): Verbessern Sie Ihre Finanzmarktanalyse mit der Principal Component Analysis (PCA)
Indikatoren mit Hintergrund: Kanäle mit Transparenz
- 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.