Programmier-Tutorial - Seite 6
Sie verpassen Handelsmöglichkeiten:
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Registrierung
Einloggen
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.
Wenn Sie kein Benutzerkonto haben, registrieren Sie sich
Atemberaubender High/Low-Breakout-Trading-Bot in MQL5! | Teil 1
Atemberaubender High/Low-Breakout-Trading-Bot in MQL5! | Teil 1
Toby, in diesem Video möchte ich ein neues Projekt vorstellen, bei dem es darum geht, Höhen und Tiefen zu nutzen, um eine profitable Breakout-Strategie zu entwickeln. Die Hauptidee besteht darin, die höchsten und niedrigsten Preise des aktuellen Symbols zu identifizieren und diese Niveaus zur Bestimmung potenzieller Ausbruchspunkte zu verwenden. Werfen wir einen Blick auf die Tabelle, um zu verstehen, wie das funktioniert.
Zunächst beobachten wir die letzten n Balken und ermitteln den höchsten und den niedrigsten Preis. Wenn der Preis das hohe Niveau überschreitet, gehen wir eine Kaufposition ein. Wenn der Preis hingegen unter das Tief fällt, gehen wir eine Verkaufsposition ein. Es ist ein einfaches Konzept, aber wir werden es durch das Hinzufügen von Stop-Loss- und Take-Profit-Levels in Punkten verbessern. Darüber hinaus implementieren wir Filter, um die Strategie zu verfeinern und den Handel bei jedem Hoch und Tief zu vermeiden.
Warten wir auf eine Handelsmöglichkeit, um das Konzept zu demonstrieren. Hier haben wir eine Verkaufsposition, da der Preis unter das Tief fiel und wir den Handel mit einem Gewinn abgeschlossen haben. Dies stellt die Grundlage für unsere Strategie dar und wir können sie durch die Einbeziehung zusätzlicher Komponenten weiter verbessern.
Wechseln wir nun zum Meta-Editor und beginnen mit dem Codieren. Wir erstellen eine neue Datei im YouTube-Ordner und nennen sie „Toby's Breakout EA“. In der Datei definieren wir die notwendigen Eingaben für unseren EA. Dazu gehören die magische Zahl, die Losgröße, die Anzahl der zu berücksichtigenden Balken, Stop-Loss und Take-Profit. Wir legen entsprechende Standardwerte fest und geben Kommentare ab, um jede Eingabe zu erläutern.
Als nächstes gehen wir zur onInit-Funktion über, wo wir die Benutzereingaben überprüfen, um sicherzustellen, dass sie gültig sind. Wir erstellen eine separate Funktion namens checkInputs, um diese Validierung durchzuführen. Wenn eine der Eingaben falsch ist, zeigen wir eine Fehlermeldung an und verhindern den Start des EA.
Innerhalb der onInit-Funktion legen wir mithilfe der bereitgestellten Eingabe auch die magische Zahl unseres Handelsobjekts fest. Dadurch können wir später von unserem EA eröffnete Positionen filtern und verwalten.
Schauen wir uns nun die Funktion onTick an. Wir beginnen mit dem Speichern des aktuellen Ticks und der vorherigen Tick-Werte. Dies wird uns helfen, Preisbewegungen zu verfolgen und festzustellen, ob wir wichtige Niveaus überschreiten. Wir verwenden die SymbolInfoTick-Funktion, um den aktuellen Tick abzurufen. Wenn ein Fehler auftritt, zeigen wir eine Fehlermeldung an und stoppen den EA.
Anschließend fügen wir drei benutzerdefinierte Funktionen hinzu: countOpenPositions, normalizePrice und closePositions. Diese Funktionen helfen uns, unsere Positionen zu verwalten, die Anzahl der offenen Positionen zu zählen, Preise zu normalisieren und Positionen bei Bedarf zu schließen.
Zurück zur onTick-Funktion: Wir beginnen mit der Zählung der offenen Positionen für Kauf und Verkauf. Wenn während dieses Vorgangs ein Fehler auftritt, stoppen wir den EA, ohne eine Fehlermeldung anzuzeigen, da er bereits in der benutzerdefinierten Funktion behandelt wird. Wir prüfen dann, ob offene Kaufpositionen vorhanden sind und ob der Höchststand nicht Null ist. Dadurch wird sichergestellt, dass wir das hohe Niveau festgelegt haben und keine Kaufpositionen bestehen.
Von hier aus können wir mit der Codierung der Logik der Breakout-Strategie fortfahren. Wir werden ähnliche Prüfungen für die Verkaufspositionen und den Tiefststand durchführen. Mithilfe dieser if-Anweisungen können wir anhand des Ausbruchs der jeweiligen Niveaus entscheiden, ob wir eine Kauf- oder Verkaufsposition einnehmen sollen.
Sobald wir eine Grundstruktur haben, können wir die Strategie durch das Hinzufügen weiterer Komponenten und Filter weiter verbessern. Dies kann zusätzliche Eingabeparameter und Bedingungen umfassen, um die Handelssignale zu verfeinern und die Gesamtleistung zu verbessern.
Dies deckt den anfänglichen Codierungsprozess ab. Indem wir diese Schritte befolgen, können wir einen Breakout-EA basierend auf Höhen und Tiefen erstellen, der als Ausgangspunkt für die weitere Entwicklung und Optimierung dienen kann.
Der Algorithmus:
Der Algorithmus prüft kontinuierlich, ob potenzielle Ein- und Ausstiegspunkte auf der Grundlage der Geld- und Briefkurse im Verhältnis zu den vordefinierten Höchst- und Tiefstständen vorliegen. Es eröffnet Positionen, wenn die Bedingungen erfüllt sind, und schließt Positionen, wenn sich die Preise in die entgegengesetzte Richtung bewegen.
High/Low-Breakout-Trading-Bot mql5 | Teil 2
High/Low-Breakout-Trading-Bot mql5 | Teil 2
In diesem Video arbeiten wir weiter an unserem schwarzen Audi mit High-Low-Beschichtung. Im Anschluss an unsere vorherige Sitzung werden wir nun die Handelslogik integrieren und einige zusätzliche Komponenten vorstellen. Zunächst berechnen wir den Stop-Loss für unsere Positionen. Wenn die Stop-Loss-Eingabe Null ist, setzen wir die Variable „SL“ auf Null, um anzuzeigen, dass kein Stop-Loss vorliegt. Andernfalls setzen wir ihn auf den aktuellen Geldkurs abzüglich des eingegebenen Stop-Loss multipliziert mit dem Punktewert.
Als nächstes berechnen wir den Take Profit. Wenn die Take-Profit-Eingabe Null ist, setzen wir die Variable „TP“ auf Null. Andernfalls setzen wir ihn auf den aktuellen Briefkurs plus den eingegebenen Take-Profit multipliziert mit dem Punktewert. Um konsistente Preiswerte zu gewährleisten, normalisieren wir den Stop-Loss und die Gewinnmitnahmen mithilfe der Funktion „Normalisierter Preis“.
Nachdem die Handelslogik eingerichtet ist, verwenden wir das Handelsobjekt, das zuvor mithilfe der cTrade-Klasse deklariert wurde, um Positionen zu eröffnen. Für eine Kaufposition verwenden wir das aktuelle Symbol, geben Lots für die Lotgröße, den aktuellen Geldkurs für den Preis, die Stop-Loss-Variable für den Stop-Loss und die Take-Profit-Variable für den Take-Profit ein. Ebenso verwenden wir für eine Verkaufsposition den aktuellen Briefkurs als Preis. Um diese Position von anderen zu unterscheiden, fügen wir einen Kommentar hinzu, der darauf hinweist, dass sie zu unserem Expertenberater „High-Low Record EA“ gehört.
Nach dem Kompilieren des Codes wechseln wir zum Testen zu MetaTrader. Wir richten einen Sichttest ein und legen den Zeitrahmen und Zeitraum fest. Mit den Standardeingaben führen wir den Test durch und beobachten die hohen und niedrigen Werte. Durch die Verwendung des Modus „Nur Eröffnungspreis“ können wir sehen, welche Positionen geöffnet werden, wenn das Hoch- oder Tiefniveau überschritten wird. Im nächsten Schritt ändern wir den Tick-Modus des EA, um nur bei offenen Ticks Maßnahmen zu ergreifen. Dies bietet eine zuverlässigere und schnellere Testumgebung für die Erstellung stabiler Systeme.
In Zukunft implementieren wir einen Indexfilter, um den Handel an extremen Punkten ganz am Anfang oder am Ende des Lookback-Zeitraums zu verhindern. Wir führen eine Eingabe namens „Indexfilter“ ein, die den Prozentsatz der Balken innerhalb des Lookback-Zeitraums darstellt, die gefiltert werden sollen. Wenn der Lookback-Zeitraum beispielsweise 50 Balken beträgt und der Indexfilter auf 10 eingestellt ist, werden Extrempunkte innerhalb der ersten fünf oder letzten fünf Balken herausgefiltert. Um diesen Bereich zu visualisieren, zeichnen wir ein Rechteck auf dem Diagramm. Wir fügen die erforderlichen globalen Variablen hinzu, legen ihre Anfangswerte fest und nehmen Änderungen in der Funktion „OnTick“ vor, um die hohen und niedrigen Indizes mithilfe der Funktionen „I Highest“ und „I Lowest“ zu berechnen.
Darüber hinaus aktualisieren wir die Funktion „CheckInputs“, um die Eingabe „Indexfilter“ einzuschließen und ihren Wert zu validieren. Wir erstellen außerdem eine neue Funktion namens „CheckIndexFilter“, die prüft, ob ein Extrempunkt basierend auf dem Index und den Filtereinstellungen gefiltert werden soll. Um die Implementierung abzuschließen, kompilieren wir den Code und führen einen visuellen Test durch. Wir überprüfen, ob die Positionen nur geöffnet werden, wenn die Extrempunkte gemäß dem Indexfilter innerhalb des definierten Bereichs liegen. Im folgenden Abschnitt planen wir, den Tick-Modus des EA zu ändern, um ihn besser an unsere Anforderungen anzupassen. Wir werden in den Open-Tick-Modus wechseln, sodass der EA ausschließlich mit offenen Ticks arbeiten kann, wodurch die Systemzuverlässigkeit und -effizienz verbessert wird.
Nachdem wir den Tick-Modus in den offenen Tick-Modus geändert haben, fahren wir mit weiteren Verbesserungen an unserem EA fort. Eine der Verbesserungen, die wir vornehmen werden, ist die Hinzufügung eines Zeitfilters. Um den Zeitfilter zu implementieren, führen wir zwei neue Eingaben ein: „Startstunde“ und „Endstunde“. Mithilfe dieser Eingaben können wir den Zeitraum festlegen, in dem der Handel zulässig sein soll. Wenn wir beispielsweise die Startstunde auf 8 Uhr und die Endstunde auf 18 Uhr einstellen, öffnet der EA nur Positionen zwischen 8 und 18 Uhr. Um den Zeitfilter zu integrieren, aktualisieren wir die Funktion „CheckInputs“, um die neuen Eingaben zu validieren und sicherzustellen, dass die Startstunde kleiner als die Endstunde ist. Wir modifizieren auch die Funktion „OnTick“, um die aktuelle Zeit mit dem angegebenen Bereich zu vergleichen, bevor wir Positionen eröffnen.
Wenn der Zeitfilter aktiviert ist, kompilieren wir den Code und führen einen visuellen Test durch, um sicherzustellen, dass Positionen nur innerhalb des angegebenen Zeitbereichs geöffnet werden. Als nächstes gehen wir zu einer weiteren Verbesserung über: dem Hinzufügen eines Spread-Filters. Mit dem Spread-Filter können wir einen maximal zulässigen Spread definieren, ab dem der EA keine Positionen eröffnet. Um den Spread-Filter zu implementieren, führen wir eine neue Eingabe namens „Max Spread“ ein. In die Funktion „OnTick“ integrieren wir eine Prüfung, um sicherzustellen, dass der aktuelle Spread innerhalb des zulässigen Bereichs liegt, bevor Positionen eröffnet werden.
Wir aktualisieren außerdem die Funktion „CheckInputs“, um die Eingabe „Max Spread“ zu validieren und sicherzustellen, dass es sich um einen positiven Wert handelt. Sobald der Spread-Filter implementiert ist, kompilieren wir den Code und führen einen visuellen Test durch, um zu bestätigen, dass Positionen nur geöffnet werden, wenn der Spread unter dem angegebenen Maximum liegt. Zuletzt führen wir eine Funktion ein, um die Anzahl der offenen Positionen im Chart zu verfolgen und anzuzeigen. Wir erstellen eine neue globale Variable namens „Position Count“ und initialisieren sie auf Null. In der Funktion „OnTick“ erhöhen wir den Positionszähler jedes Mal, wenn eine Position eröffnet wird.
Um die Positionsanzahl im Diagramm anzuzeigen, verwenden wir die Funktion „ObjectSetText“, um ein Textobjekt zu erstellen, das die aktuelle Anzahl anzeigt. Wir aktualisieren das Textobjekt bei jedem Tick mit dem neuesten Zählwert. Sobald der Code kompiliert ist, führen wir einen visuellen Test durch, um die im Diagramm angezeigte Positionsanzahl zu beobachten und sicherzustellen, dass sie die Anzahl der geöffneten Positionen genau widerspiegelt.
Durch die Implementierung dieser Verbesserungen haben wir die Funktionalität und Leistung unseres EA erheblich verbessert. Der Zeitfilter, der Spread-Filter und die Anzeige der Positionsanzahl bieten eine bessere Kontrolle und Transparenz über den Handelsprozess.
Im nächsten Video werden wir zusätzliche Optimierungen und Feinabstimmungstechniken untersuchen, um die Leistung unseres EA weiter zu verbessern.
Erstaunlicher High/Low-Breakout-Trading-Bot mql5 | Teil 3
Erstaunlicher High/Low-Breakout-Trading-Bot mql5 | Teil 3
Im heutigen Video setzt Toby die Entwicklung des High-Low-Breakout-EA für MK5 fort. Er führt zwei neue Komponenten in die Strategie ein und führt am Ende auch mehrere Backtests durch.
Toby beginnt damit, den EA zu kompilieren, um sicherzustellen, dass er funktionsfähig ist. Anschließend fügt er einen Input für einen Trailing-Stop-Loss hinzu, um die Wirksamkeit der Strategie als Breakout- und Trendfolgesystem zu verbessern. Der Eingang ist eine boolesche Variable, die aktiviert oder deaktiviert werden kann. Toby erstellt außerdem eine Funktion namens „updateStopLoss“, um die Stop-Loss-Werte für jede Position zu berechnen und zu aktualisieren.
Um den Trailing Stop Loss zu implementieren, kopiert Toby die Funktion „updatePosition“ von einem anderen EA und modifiziert sie entsprechend. Er fügt einen Parameter für die Stop-Loss-Distanz hinzu und passt die Berechnung des neuen Stop-Loss-Werts basierend auf dieser Eingabe an. Er integriert außerdem eine Funktion namens „normalizedPrice“, um sicherzustellen, dass der Stop-Loss-Wert normalisiert wird. Nachdem er diese Änderungen vorgenommen hat, kompiliert Toby den Code erneut, um sicherzustellen, dass keine Fehler vorliegen.
Als nächstes wechselt Toby zur Funktion „OnTick“, wo er die Funktion „updateStopLoss“ integriert. Er fügt eine if-Anweisung hinzu, um zu prüfen, ob der Trailing-Stop-Loss aktiv ist, und ruft in diesem Fall die Funktion „updateStopLoss“ auf, um die Stop-Loss-Werte nachzuverfolgen. Er stellt außerdem sicher, dass die Funktion sowohl auf Kauf- als auch auf Verkaufspositionen angewendet wird.
Nachdem er den Code kompiliert hat, fügt Toby der Strategie die nächste Komponente hinzu, einen Größenfilter. Der Größenfilter ermöglicht das Herausfiltern von Kanälen, bei denen die hohen und niedrigen Werte zu weit auseinander liegen, was auf einen größeren Bereich hinweist. Toby fügt eine Eingabe für den Größenfilter in Punkten hinzu und passt den Code entsprechend an, um zu prüfen, ob die Kanalgröße den angegebenen Grenzwert überschreitet. Er integriert den Größenfilter auch in die Visualisierung der Hoch- und Tieflinien.
Anschließend führt Toby mit dem Strategietester einen visuellen Test durch, um zu bestätigen, dass sowohl der Trailing-Stop-Loss als auch der Größenfilter ordnungsgemäß funktionieren. Er beobachtet das Verhalten des Stop-Loss und die Farbveränderungen in den Linien basierend auf der Größenfilterbedingung.
Im letzten Teil des Videos führt Toby Backtests durch, um die Leistung des EA in den letzten 10 Jahren zu bewerten. Er legt die Optimierungskriterien als Erholungsfaktor fest und verwendet ein bestimmtes Symbol und einen bestimmten Zeitrahmen. Toby plant, die verbleibenden Jahre als Out-of-Sample-Test zu nutzen.
Toby nimmt mehrere Verbesserungen am High-Low-Breakout-EA vor, darunter die Hinzufügung eines Trailing-Stop-Loss und eines Größenfilters. Er zeigt auch, wie man Backtests durchführt, um die Leistung des EA zu bewerten.
Lassen Sie uns den ultimativen Kerzenmuster-EA in mql5 programmieren! | Teil 1
Lassen Sie uns den ultimativen Kerzenmuster-EA in mql5 programmieren! | Teil 1
Hey, das ist Toby und in diesem Video starte ich ein neues EA-Codierungsprojekt auf meinem Kanal. Wir werden uns auf Candlestick-Muster konzentrieren und einen EA erstellen, der verschiedene Muster wie Doji, Morning Star, Rising Star und viele andere handeln kann. Der EA wird auch über ein Panel verfügen, um verschiedene Bedingungen anzuzeigen. Ich habe bereits einige vorläufige Tests mit dem EA durchgeführt und die Ergebnisse waren recht interessant, insbesondere bei verschiedenen Symbolen. Ich glaube, dass dieser Ansatz zu einer äußerst effektiven Strategie führen kann. Lass uns eintauchen!
Bevor wir mit der Codierung des EA beginnen, besprechen wir die allgemeine Strategieidee. Es ist wichtig zu verstehen, was wir im Laufe unseres Fortschritts schaffen wollen. Um das Konzept zu veranschaulichen, habe ich ein einfaches Diagramm erstellt. Unser EA arbeitet ausschließlich mit dem offenen Preis jedes Barrens. Betrachten wir zum Beispiel den aktuellen Balken (Index 0) und den vorherigen Balken (Index 1). Wir möchten einen EA erstellen, der verschiedene Chartmuster oder Candlestick-Muster wie Doji, Morning Star, Evening Star, Rising Star und viele mehr handeln kann.
Um dies zu erreichen, definieren wir verschiedene Bedingungen. Beispielsweise können wir eine Bedingung festlegen, bei der der höchste Preis von Balken 2 höher sein muss als der höchste Preis von Balken 1. Eine weitere Bedingung könnte sein, dass der Eröffnungspreis von Balken 3 niedriger sein muss als der Schlusskurs von Balken 3, was auf a hinweist bullische Kerze. Durch die Kombination dieser Bedingungen können wir bei der Eröffnung des nächsten Balkens einen Kaufhandel auslösen. Wir können ähnliche Bedingungen auch umgekehrt für Verkaufssignale anwenden.
Darüber hinaus möchte ich nicht nur die Eröffnungs-, Höchst-, Tiefst- und Schlusskurse jeder Kerze berücksichtigen, sondern auch andere Faktoren wie die Bereichsgröße oder die Körpergröße. Beispielsweise können wir die Körpergröße berechnen, indem wir sie durch die Gesamtreichweite des Candlesticks dividieren. Diese Berechnung kann uns helfen, Doji-Bars zu identifizieren. Wir können sogar bestimmte Werte festlegen, z. B. eine Körpergröße von mehr als 50 Punkten. Mit diesen Optionen können wir mit einem einzigen EA verschiedene Muster erstellen und testen. Es verspricht eine spannende Reise zu werden!
Kommen wir nun zum MetaEditor und beginnen mit dem Codieren. Aber bevor wir beginnen, würde ich mich über Ihr Feedback freuen. Wenn Sie diese Videos hilfreich finden und heute Nacht gut schlafen möchten, hinterlassen Sie bitte ein Like. Außerdem denke ich darüber nach, zwischen dem dunklen Modus und dem standardmäßigen weißen Hintergrund zu wechseln. Ich erstelle eine Umfrage, damit Sie über Ihre Präferenz abstimmen können. Lassen Sie mich in den Kommentaren wissen, ob Sie im Dunkelmodus alles richtig lesen können.
Okay, fangen wir mit dem Codieren an! Im MetaEditor erstelle ich einen neuen EA unter meinem YouTube-Ordner. Ich werde es „Candle Pattern EA“ nennen. Wir beginnen mit einer sauberen Vorlage, entfernen unnötige Kommentare und organisieren die Codestruktur. Nachdem wir die Kompilierung durchgeführt und sichergestellt haben, dass keine Fehler vorliegen, fahren wir mit den nächsten Schritten fort.
Wir definieren einige Schlüsselparameter im Eingabeabschnitt, wie zum Beispiel die magische Zahl, die eine eindeutige Kennung für diesen EA sein sollte, um Konflikte mit anderen EAs zu vermeiden, die auf derselben MetaTrader-Instanz laufen. Weisen wir ihm eine Zufallszahl zu.
Dies umfasst die anfängliche Einrichtung und die Eingabeparameter. Jetzt können wir mit dem nächsten Teil fortfahren. Bleiben Sie dran!
Candlestick-Muster EA in mql5! | Teil 2
Candlestick-Muster EA in mql5! | Teil 2
Im heutigen Video bin ich Toby und wir werden mit der Codierung unseres einfachen Expert Advisors (EA) für Candlestick-Muster in MetaTrader 5 fortfahren. Wir sind jetzt im zweiten Teil dieser Codierungsserie. Falls Sie also den ersten Teil verpasst haben, in dem ich … Wenn Sie die Strategieidee ausführlicher erklärt haben, finden Sie den Link zu diesem Video hier. Bevor wir mit dem Codieren beginnen, möchte ich die Ergebnisse einer kürzlich auf YouTube durchgeführten Umfrage zum bevorzugten Farbthema für die Videoaufnahme mit Ihnen teilen. Von 140 Stimmen bevorzugte die Mehrheit (90) den dunklen Hintergrund, während 50 Personen den weißen Hintergrund bevorzugten. Ich persönlich finde den dunklen Hintergrund angenehmer für die Augen und verwende ihn auch für die Aufnahme meiner eigenen EAs.
Eine weitere Sache, die ich erwähnen wollte, ist, dass ich kürzlich Visual Studio Code für MQL5 eingerichtet habe. Wenn Sie daran interessiert sind, Visual Studio Code für Ihre Codierungsprojekte zu verwenden, lassen Sie es mich in den Kommentaren wissen und ich werde ein Video darüber erstellen.
Kommen wir nun zurück zur Codierung unseres EA. Im vorherigen Video haben wir bei den Eingaben für Bedingung eins aufgehört. Wir erstellen nun eine weitere Bedingung und fügen eine Eingabe für Bedingung zwei hinzu. Wir kopieren den Abschnitt für Bedingung eins und benennen ihn in Bedingung zwei um, wobei wir die erforderlichen Änderungen an den Eingabevariablen vornehmen. Im Moment halten wir es mit nur zwei Bedingungen einfach, aber wir können in Zukunft weitere hinzufügen. Nachdem wir diese Änderungen vorgenommen haben, kompilieren wir den Code, um sicherzustellen, dass keine Fehler oder Warnungen vorliegen.
Einige Zuschauer wünschten eine Vergrößerung der Schriftgröße zur besseren Lesbarkeit. Obwohl ich lieber mehr Code auf dem Bildschirm sehe, verstehe ich die Notwendigkeit größerer Schriftgrößen. Wir bleiben jedoch vorerst bei der aktuellen Schriftgröße. Bei Bedarf kann ich in Zukunft Anpassungen vornehmen.
Als Nächstes verknüpfen wir die Eingaben mit unserem Bedingungsarray, das wir im Abschnitt „Globale Variablen“ erstellt haben. Um dies zu erreichen, erstellen wir eine benutzerdefinierte Funktion namens „setInputs“. Diese Funktion wird vor der Überprüfung der Eingaben aufgerufen. Nachdem wir den Code für die setInputs-Funktion geschrieben haben, kompilieren wir den Code erneut, um seine Richtigkeit zu überprüfen.
Anschließend prüfen wir die Eingaben, um sicherzustellen, dass sie den erforderlichen Kriterien entsprechen. Wir verwenden für jede Eingabe eine if-Anweisung, um die erforderlichen Prüfungen durchzuführen. Wenn sich herausstellt, dass eine Eingabe ungültig ist, zeigen wir dem Benutzer eine Warnung an und geben von der checkInputs-Funktion „false“ zurück. Wir beginnen mit der Überprüfung der magischen Zahl und stellen sicher, dass sie nicht kleiner oder gleich Null ist. Anschließend prüfen wir die Losgröße, den Stop-Loss und die Gewinnmitnahmen. Darüber hinaus müssen wir eine Prüfung für das Bedingungsarray hinzufügen, auf die wir später eingehen.
Um den Code modularer zu gestalten, verwenden wir eine setInputs-Funktion, um die magische Zahl für unser Handelsobjekt festzulegen. Dies ist bei der Suche nach Positionen oder der Abwicklung handelsbezogener Vorgänge von Vorteil. Nachdem wir diese Änderung vorgenommen haben, kompilieren wir den Code erneut, um seine Richtigkeit zu bestätigen.
Kommen wir nun zur onTick-Funktion, in der die Hauptoperationen des EA stattfinden. Zunächst prüfen wir mit unserer Funktion isNewBar, ob der aktuelle Tick ein Bar-Open-Tick ist. Wenn es „false“ zurückgibt, was darauf hinweist, dass es sich nicht um einen Bar-Open-Tick handelt, kehren wir einfach zurück und warten auf den nächsten Tick.
Als nächstes erhalten wir den Tick des aktuellen Symbols. Dadurch erhalten Sie Zugriff auf Bid-, Ask- und andere Tick-bezogene Informationen. Wir verwenden die Funktion SymbolInfoTick und speichern das Ergebnis in einer Variablen. Wenn dieser Vorgang fehlschlägt, zeigen wir eine Meldung an, die auf den Fehler hinweist, und kehren von der onTick-Funktion zurück.
Anschließend zählen wir die offenen Positionen mit unserer Funktion countOpenPositions. Dadurch erhalten wir die Anzahl der zum aktuellen Zeitpunkt offenen Kauf- und Verkaufspositionen. Wenn dieser Vorgang fehlschlägt, zeigen wir eine Fehlermeldung an, die auf den Fehler hinweist, und kehren von der onTick-Funktion zurück.
Nachdem wir die Anzahl der offenen Positionen erhalten haben, prüfen wir, ob es offene Positionen gibt. Wenn dies der Fall ist, zeigen wir eine Meldung mit der Anzahl der offenen Stellen an. Andernfalls fahren wir mit dem nächsten Schritt fort.
Jetzt durchlaufen wir jede offene Position mithilfe einer for-Schleife. Innerhalb der Schleife rufen wir die Positionsinformationen mithilfe der PositionGetTicket-Funktion ab. Wir speichern die Ticketnummer in einer Variablen und zeigen zu Debugging-Zwecken eine Meldung mit der Ticketnummer an.
Als Nächstes überprüfen wir den Typ der Position (Kauf oder Verkauf) mithilfe der Funktion PositionGetInteger und der Eigenschaft POSITION_TYPE. Wenn es sich bei der Position um eine Kaufposition handelt, führen wir den erforderlichen Code für Kaufpositionen aus. Wenn es sich bei der Position um eine Verkaufsposition handelt, führen wir entsprechend den Code für Verkaufspositionen aus.
Bei Kaufpositionen prüfen wir, ob der aktuelle Geldkurs unter dem Stop-Loss-Level der Position liegt. Wenn dies der Fall ist, zeigen wir eine Meldung an, dass das Stop-Loss-Niveau erreicht wurde, und schließen die Position mithilfe der PositionClose-Funktion.
Ebenso prüfen wir bei Verkaufspositionen, ob der aktuelle Briefkurs höher ist als das Stop-Loss-Niveau der Position. Wenn dies der Fall ist, zeigen wir eine Meldung an, dass das Stop-Loss-Level erreicht wurde, und schließen die Position.
Nachdem wir alle erforderlichen Positionen geschlossen haben, fahren wir mit dem nächsten Schritt fort, bei dem wir unsere Bedingungen überprüfen, um festzustellen, ob wir eine neue Position eröffnen sollten. Zu diesem Zweck verwenden wir die Funktion checkConditions. Wenn die checkConditions-Funktion „true“ zurückgibt, was bedeutet, dass alle Bedingungen erfüllt sind, führen wir den notwendigen Code aus, um eine neue Position zu eröffnen. Andernfalls fahren wir mit dem nächsten Tick fort.
Im Code zum Eröffnen einer neuen Position legen wir das Volumen, den Stop-Loss, die Gewinnmitnahme und andere notwendige Parameter fest. Wir verwenden die OrderSend-Funktion, um die Handelsanfrage zu senden und die Position zu eröffnen. Wenn die Handelsanfrage erfolgreich ist, zeigen wir eine Meldung an, die über die erfolgreiche Eröffnung der Position informiert. Andernfalls zeigen wir eine Fehlermeldung an.
Abschließend kompilieren wir den Code, um sicherzustellen, dass keine Fehler oder Warnungen vorliegen. Wenn alles erfolgreich verläuft, können wir unseren EA auf einem Demo- oder Live-Konto testen.
Damit ist dieses Video abgeschlossen. Im nächsten Teil werden wir unseren EA weiter ausbauen, indem wir zusätzliche Funktionen hinzufügen und unsere Strategie verfeinern. Wenn Sie Fragen oder Anregungen haben, hinterlassen Sie diese bitte in den Kommentaren unten. Vielen Dank fürs Zuschauen, wir sehen uns im nächsten Video!
Toller Candlestick-Muster-EA in MQL5! | Teil 3
Toller Candlestick-Muster-EA in MQL5! | Teil 3
In diesem Video stellt sich Toby vor und kündigt an, dass der Fokus auf der Weiterentwicklung des Candlestick Pattern Expert Advisor (EA) im MetaTrader5 liegen wird. Ziel ist es, die Kernlogik zu schreiben, die für die Durchführung des ersten Backtests und die Erzielung eines Ergebnisses erforderlich ist. Toby ermutigt die Zuschauer, sich die vorherigen Teile der Serie anzusehen, falls sie dies noch nicht getan haben.
Toby öffnet den Meta-Editor und beginnt mit dem Codieren dort, wo er im vorherigen Video aufgehört hat. Er erklärt, dass sie den Code für die Eröffnung von Kauf- und Verkaufspositionen bereits implementiert haben, jetzt aber noch die Bedingungsprüfungen hinzufügen müssen. Zu diesem Zweck plant Toby die Erstellung einer benutzerdefinierten Funktion, die aufgerufen werden kann, um die Bedingungen für Kauf- und Verkaufsgeschäfte zu überprüfen.
Bevor er mit dem Codierungsprozess beginnt, möchte Toby sicherstellen, dass der vorhandene Code keine Fehler enthält. Er kompiliert den Code, um ihn auf Fehler oder Warnungen zu prüfen.
Als Nächstes schreibt Toby die Logik für die benutzerdefinierte Funktion namens „Bedingungen prüfen“. Diese Funktion durchläuft jede Bedingung mithilfe einer for-Schleife. Innerhalb der Schleife rufen sie eine weitere benutzerdefinierte Funktion namens „Eine Bedingung prüfen“ auf, um jede einzelne Bedingung auszuwerten.
Toby erstellt die Funktion „Eine Bedingung prüfen“, die Parameter für den Kauf-/Verkaufshandel und den Index der zu prüfenden Bedingung übernimmt. Innerhalb dieser Funktion werden verschiedene Prüfungen durchgeführt, beispielsweise die Feststellung, ob die Bedingung aktiv ist. Wenn eine Bedingung inaktiv ist, gibt die Funktion „true“ zurück und zeigt damit an, dass sie nicht relevant ist.
Um die Bedingungen zu überprüfen, muss Toby die Balkendaten abrufen. Er deklariert eine Variable vom Typ MQL-Raten, bei der es sich um eine vordefinierte Struktur handelt, die die Eröffnungs-, Höchst-, Tiefst- und Schlusskurse enthält. Sie legen das Raten-Array als Serie fest und verwenden die Kopierratenfunktion, um die erforderlichen Daten für die Bedingungen abzurufen.
Nachdem er die Balkendaten erfolgreich erhalten hat, legt Toby die Werte für die Variablen A und B fest, die zum Vergleich und zur Bewertung der Bedingungen verwendet werden. Die Werte werden basierend auf dem Modus der Bedingung bestimmt, z. B. offen, hoch, niedrig, geschlossen, Bereich, Körper, Verhältnis oder Wert. Die Werte werden entsprechend zugeordnet, wobei berücksichtigt wird, ob es sich um einen Kauf- oder Verkaufshandel handelt.
Sobald die Werte festgelegt sind, kompiliert Toby den Code, um ihn auf etwaige Fehler oder Irrtümer zu prüfen.
Toby wiederholt den Vorgang für die Modus-B-Bedingungen und nimmt die erforderlichen Anpassungen an Variablen und Fällen vor.
Abschließend schließt Toby das Video ab, indem er sicherstellt, dass der Code keine Fehler enthält, und betont, wie wichtig es ist, die Logik des Codes zu verstehen.
Überraschende Ergebnisse! Candlestick-Muster EA in mql5! | Teil 4
Überraschende Ergebnisse! Candlestick-Muster EA in mql5! | Teil 4
Hallo, ich bin Toby. Im heutigen Video werden wir mit der Codierung des Expert Advisors (EA) für Candlestick-Muster fortfahren. Wir haben einige konkrete Ziele für dieses Video. Zunächst fügen wir dem EA ein Panel hinzu, das verschiedene Bedingungen und die entsprechenden Kauf-/Verkaufssignale anzeigt. Darüber hinaus führen wir zusätzliche Eingabeprüfungen durch, um die Funktionsfähigkeit des EA sicherzustellen. Abschließend werden wir noch ein paar Backtests durchführen und einige interessante Ergebnisse mit Ihnen teilen. Also lasst uns anfangen.
Bevor wir fortfahren, empfehle ich Ihnen, sich die vorherigen Teile dieser Serie zur Candlestick-Muster-Codierung noch einmal anzusehen. Die Links finden Sie in der Beschreibung.
In diesem Video beginnen wir mit der Erstellung eines grafischen Panels für unseren EA. Das Panel enthält Linien, die unterschiedliche Bedingungen darstellen, mit Kreuzen, die Kauf- und Verkaufssignale anzeigen. Wenn die Bedingungen erfüllt sind, nimmt der EA Geschäfte in die angegebene Richtung entgegen. Darüber hinaus werden wir Eingabeprüfungen implementieren, um die Optimierung im Strategietester zu erleichtern.
Um mit dem Codieren des Panels zu beginnen, öffnen wir den MetaEditor und navigieren zum Include-Ordner. Im Include-Ordner erstellen wir einen neuen Ordner mit dem Namen YouTube. Im YouTube-Ordner erstellen wir die grafische Paneldatei. Wir löschen den Standardinhalt der Datei und fügen die erforderlichen Dateien für unser Panel hinzu.
Als nächstes definieren wir die notwendigen Beschriftungen für unser Panel. Jede Beschriftung stellt ein bestimmtes Element dar, z. B. Nummer, Zustand, Kauf, Verkauf usw. Wir erstellen außerdem Beschriftungsfelder, um für jede Bedingung mehrere Zeilen anzuzeigen.
Nachdem wir die Beschriftungen definiert haben, fahren wir mit dem Codieren der Panel-Klasse fort. Diese Klasse erbt von der CAppDialog-Klasse und gewährt uns Zugriff auf ihre Mitglieder. Wir erstellen einen privaten Abschnitt für die Beschriftungen des Panels und einige Methoden, darunter einen Konstruktor, einen Destruktor, onInit, update und bannerChartEvent.
Der Konstruktor initialisiert das Panel, während der Destruktor die Bereinigung übernimmt. Die onInit-Methode wird von der onInit-Funktion des EA aufgerufen und erstellt das Panel. Die Update-Methode wird bei jedem Tick aufgerufen, um den Inhalt des Panels zu aktualisieren. Schließlich verarbeitet die Methode „bannerChartEvent“ Ereignisse im Zusammenhang mit dem Panel.
Innerhalb der Methode „createPanel“ erstellen wir das eigentliche Panel mit den gewünschten Parametern wie Diagramm-ID, Name, Unterfenster und Koordinaten. Wir stellen sicher, dass das Panel erfolgreich erstellt wurde und geben „true“ zurück, wenn dies der Fall ist, andernfalls „false“.
Sobald die Panel-Klasse codiert ist, nehmen wir sie in unsere Expert Advisor-Datei auf. Wir erstellen eine Instanz des Panel-Objekts und rufen seine onInit-Methode auf, nachdem wir die magische Zahl festgelegt haben. Wenn die Panelerstellung fehlschlägt, geben wir eine entsprechende Fehlermeldung zurück.
Das war's mit diesem Teil unserer Candlestick-Muster-Codierungsserie. Im nächsten Video werden wir unserem EA weitere Funktionen hinzufügen und weitere Tests durchführen. Bleiben Sie dran für weitere interessante Ergebnisse.
Codieren Sie ein benutzerdefiniertes Kriterium in mql5
Codieren Sie ein benutzerdefiniertes Kriterium in mql5
Hallo, das ist Toby. In diesem Video zeige ich, wie Sie ein benutzerdefiniertes Kriterium für Ihre Expert Advisor-Optimierung in MQL5 programmieren. Als Beispiel verwenden wir den Hilo-Bracket-EA. Das Ziel besteht darin, ein benutzerdefiniertes Kriterium zu erstellen, das sowohl den Gewinnfaktor als auch die Anzahl der Trades beim Ranking der Optimierungsergebnisse berücksichtigt.
Öffnen Sie zunächst Ihren EA in der Codierungsumgebung (z. B. Visual Studio Code) und speichern Sie ihn unter einem neuen Namen. Als nächstes fügen Sie Ihrem EA eine vordefinierte Funktion namens „OnTester“ hinzu. Diese Funktion berechnet die benutzerdefinierten Kriterien und gibt ihren Wert zurück. Mit der Funktion „TestStatistics“ können Sie die Anzahl der Trades und den Gewinnfaktor ermitteln. Multiplizieren Sie diese beiden Werte, um die benutzerdefinierten Kriterien zu berechnen.
Kompilieren Sie den Code, um sicherzustellen, dass keine Fehler vorliegen. Wechseln Sie nun zum MetaTrader und führen Sie eine Optimierung durch. Wählen Sie Ihren EA aus und wählen Sie „Custom Max“ als optimales Suchkriterium, um Ihre benutzerdefinierten Kriterien zu verwenden. Starten Sie die Optimierung und warten Sie auf die Ergebnisse. Sie werden sehen, dass die benutzerdefinierten Kriterien auf der Grundlage der Anzahl der Trades multipliziert mit dem Gewinnfaktor berechnet werden.
Wenn Sie die Gewichtung des Gewinnfaktors anpassen möchten, können Sie die Funktion „MathPower“ in Ihrem Code verwenden. Sie können beispielsweise den Gewinnfaktor auf die Potenz 4 erhöhen, um ihm mehr Gewicht zu verleihen. Kompilieren Sie die Optimierung erneut und führen Sie sie erneut aus, um das aktualisierte Ranking anzuzeigen.
Darüber hinaus können Sie dem Code eine if-Anweisung hinzufügen, um Kombinationen mit weniger als 100 Trades auszuschließen. Wenn die Anzahl der Trades unter 100 liegt, können Sie einen Wert von Null zurückgeben. Dadurch wird sichergestellt, dass nur Kombinationen mit einer ausreichenden Anzahl an Trades berücksichtigt werden.
Indem Sie diese Schritte befolgen, können Sie Ihre eigenen benutzerdefinierten Kriterien erstellen, um die besten Optimierungsergebnisse für Ihren Expert Advisor zu bewerten und auszuwählen. Denken Sie daran, Ihren geänderten EA unter einem neuen Namen zu speichern, bevor Sie Änderungen vornehmen. Wenn Sie dieses Video hilfreich fanden, hinterlassen Sie bitte ein „Gefällt mir“ und teilen Sie Ihre Wünsche oder Ideen für zukünftige Videos gerne in den Kommentaren mit. Vielen Dank und bis zum nächsten Video!
Stochastischer Trading-Bot in MQL5! | Teil 1
Stochastischer Trading-Bot in MQL5! | Teil 1
In diesem Video werde ich zeigen, wie man einen einfachen stochastischen EA in MetaTrader 5 programmiert. Gegen Ende des Videos werden wir auch Backtesting durchführen, um die Leistung der Strategie in den letzten 10 Jahren zu bewerten.
Beginnen wir damit, die allgemeine Strategieidee zu verstehen. Wir werden den allgemein bekannten stochastischen Indikator verwenden. Der EA führt einen Kaufhandel aus, wenn die Stochastik die untere Ebene überschreitet, und einen Verkaufshandel, wenn sie die obere Ebene überschreitet. Beim Betrachten des Diagramms ist es wichtig, sich daran zu erinnern, dass unser Gehirn dazu neigt, sich auf die profitablen Trades zu konzentrieren. Daher ist es wichtig, die Strategie zu programmieren und einem Backtest zu unterziehen, um ihre Wirksamkeit zu bewerten.
Wechseln wir nun zu Visual Studio Code, um mit der Codierung des EA zu beginnen. Wir erstellen mit dem Standard-MetaEditor eine neue Datei im YouTube-Ordner und nennen sie „Stochastic EA“. Anschließend öffnen wir die Datei in Visual Studio Code und nehmen einige Formatierungsanpassungen vor, um die Lesbarkeit zu verbessern.
Wir gliedern den Code in Abschnitte und beginnen mit den Includes. Wir müssen nur eine Datei einbinden, „trades.mqh“, die die CTrade-Klasse enthält. Danach definieren wir die Eingaben für unseren EA. Wir werden einen allgemeinen Abschnitt für Eingaben wie magische Zahl und Losgröße haben, gefolgt von einem Handelsabschnitt für Stop-Loss, Take-Profit und das Schließen von Geschäften bei einem entgegengesetzten Signal. Dann haben wir einen Eingabeabschnitt speziell für den stochastischen Indikator, einschließlich der K-Periode und der oberen Ebene.
Sobald die Eingaben definiert sind, gehen wir zum Abschnitt mit den globalen Variablen über, wo wir Variablen für das Handle des stochastischen Indikators, den Puffer, den aktuellen Tick und das Handelsobjekt deklarieren. Nach den globalen Variablen implementieren wir die Funktion onInit. Wir beginnen mit der Überprüfung der Benutzereingaben mithilfe der checkInputs-Funktion, die sicherstellt, dass die Eingabewerte innerhalb des zulässigen Bereichs liegen. Wenn Eingaben falsch sind, geben wir „Init-Parameter falsch“ zurück.
Als Nächstes legen wir die magische Zahl für das Handelsobjekt fest, indem wir den vom Benutzer bereitgestellten Eingabewert verwenden. Anschließend erstellen wir das Indikator-Handle mithilfe der integrierten stochastischen Funktion und geben dabei das Symbol, die Periode, die K-Periode, die D-Periode (auf 1 gesetzt für keine Signallinie), den Verlangsamungswert, die MA-Methode (SMA) und das Preisfeld an (niedrig/hoch). Wir prüfen, ob die Erstellung des Indikator-Handles erfolgreich war. Wenn ein ungültiges Handle zurückgegeben wird, zeigen wir eine Warnmeldung an und geben „Init failed“ zurück. Abschließend legen wir den Puffer mit der Funktion arraySetAsSeries fest, um anzugeben, dass es sich um eine Zeitreihe handelt.
Als Nächstes definieren wir die Funktion checkInputs, die die Gültigkeit jeder Eingabe überprüft. Wir prüfen, ob die magische Zahl und die Losgröße innerhalb des zulässigen Bereichs liegen, und geben „false“ zurück, wenn dies nicht der Fall ist. Darüber hinaus können wir weitere Prüfungen hinzufügen, um beispielsweise sicherzustellen, dass die Losgröße nicht größer als 10 ist. Nachdem die Funktionen onInit und checkInputs abgeschlossen sind, können wir nun den Code kompilieren und mit den nächsten Schritten im Video fortfahren.
Die Funktion ist darauf ausgelegt, mehrere Schritte auszuführen. Zunächst ruft es den aktuellen Tick ab und speichert ihn in der globalen Variablen „CT“. Anschließend werden die Indikatorwerte mithilfe der Funktion „CopyBuffer“ abgerufen. Die Funktion prüft auf Fehler und speichert die Werte bei Erfolg im „Main“-Puffer. Wenn ein Fehler auftritt, wird eine Meldung ausgegeben und die Funktion beendet.Im nächsten Schritt wird die Anzahl der offenen Positionen gezählt. Dies erfolgt über die Funktion „CountOpenPositions“, wobei der Zählerstand in zwei Integer-Variablen „CountBuy“ und „CountSell“ gespeichert wird. Tritt beim Zählen der Positionen ein Fehler auf, wird eine Meldung ausgegeben und die Funktion beendet.
Die Funktion prüft dann, ob ein Kauf- oder Verkaufsgeschäft vorliegt. Wenn keine offene Kaufposition vorhanden ist (CountBuy ist Null), werden die Indikatorwerte überprüft, um festzustellen, ob ein Kaufhandel eröffnet werden sollte. Voraussetzung für die Eröffnung eines Kaufhandels ist, dass der aktuelle Indikatorwert unter einem festgelegten unteren Niveau liegt und der vorherige Indikatorwert über dem unteren Niveau liegt. Wenn diese Bedingungen erfüllt sind, wird eine Meldung gedruckt, die auf die Eröffnung einer Kaufposition hinweist. Ebenso prüft die Funktion, ob ein Verkaufsgeschäft vorliegt, wenn keine offene Verkaufsposition vorhanden ist (CountSell ist Null). Voraussetzung für die Eröffnung eines Verkaufsgeschäfts ist, dass der Indikatorwert über einem festgelegten oberen Niveau liegt und der vorherige Indikatorwert unter dem oberen Niveau liegt. Wenn diese Bedingungen erfüllt sind, wird eine Meldung gedruckt, die auf die Eröffnung einer Verkaufsposition hinweist.
Nachdem die Handelslogik implementiert ist, schließt die Funktion alle Verkaufspositionen, wenn der Eingabeparameter „ClosedSignal“ auf true gesetzt ist. Es verwendet die Funktion „ClosePositions“ mit dem Parameterwert 2, um alle Verkaufspositionen zu schließen. Wenn beim Schließen der Positionen ein Fehler auftritt, wird die Funktion beendet und eine Meldung ausgegeben. Als nächstes berechnet die Funktion die Stop-Loss- und Take-Profit-Werte basierend auf den Eingabeparametern. Wenn der eingegebene Stop-Loss-Wert Null ist, wird der Stop-Loss auf Null gesetzt; Andernfalls wird er auf der Grundlage des aktuellen Tick-Preises und des eingegebenen Stop-Loss-Werts berechnet. Der gleiche Prozess wird zur Berechnung des Take-Profit-Werts befolgt.
Vor der Eröffnung einer Position normalisiert die Funktion die Stop-Loss- und Take-Profit-Preise mithilfe der Funktion „NormalizePrice“. Wenn bei der Normalisierung ein Fehler auftritt, wird die Funktion beendet. Abschließend eröffnet die Funktion eine Position über die Methode „PositionOpen“ des Handelsobjekts. Die Position wird basierend auf Typ (Kauf oder Verkauf), Volumen, Preis, Stop-Loss und Take-Profit-Werten eröffnet. Ein Bestellkommentar ist ebenfalls enthalten.
Die Funktion wird kompiliert, um sicherzustellen, dass keine Fehler vorliegen. Anschließend kann sie in MetaTrader anhand historischer Daten getestet werden, um festzustellen, ob die gewünschten Handelseröffnungen und -schließungen gemäß den angegebenen Bedingungen erfolgen. Nach dem Öffnen einer Position prüft die Funktion mithilfe der Funktion „GetLastError“ auf Fehler. Wenn ein Fehler auftritt, wird eine Meldung ausgegeben und der Vorgang beendet.
Abschließend aktualisiert die Funktion die globalen Variablen „LastTick“ und „LastSignal“ mit dem aktuellen Tick bzw. dem Signaltyp (Kauf oder Verkauf). Dies geschieht, um den zuletzt verarbeiteten Tick zu verfolgen und ein Signal für zukünftige Berechnungen zu geben.
Diese Funktion ruft den aktuellen Tick ab, erhält Indikatorwerte, zählt die Anzahl der offenen Positionen, prüft auf Handelsmöglichkeiten, eröffnet Positionen basierend auf festgelegten Bedingungen, schließt Verkaufspositionen bei Bedarf, berechnet Stop-Loss- und Take-Profit-Werte, normalisiert die Preise und eröffnet Positionen , behandelt Fehler und aktualisiert globale Variablen.
Um diese Funktion in einer MetaTrader 5-Umgebung nutzen zu können, müssen Sie sie in einen Expert Advisor oder ein Skript integrieren und die Eingabeparameter und Indikatorwerte entsprechend Ihrer Handelsstrategie anpassen. Darüber hinaus müssen Sie möglicherweise weitere Funktionen zur Verwaltung von Positionen, zur Fehlerbehandlung und zur Durchführung anderer Handelsvorgänge implementieren.
Bitte beachten Sie, dass es sich bei der bereitgestellten Erklärung um ein allgemeines Verständnis handelt, das auf den bereitgestellten Informationen basiert, und dass die tatsächliche Umsetzung je nach der spezifischen Handelsplattform und verwendeten Programmiersprache variieren kann.
Stochastischer EA für MetaTrader 5 | Teil 2
Stochastischer EA für MetaTrader 5 | Teil 2
In diesem Video stellt sich Toby als Moderator vor und erwähnt, dass sie über einen einfachen Filter zur Verbesserung von Handelsstrategien mithilfe des stochastischen Indikators diskutieren werden. Toby erwähnt, dass der Filter nicht nur auf den stochastischen Indikator, sondern auch auf andere Indikatoren angewendet werden kann.
Toby erklärt, dass sie im ersten Teil des Coding-Tutorials die Kernlogik des EA (Expert Advisor) und des Indikators behandelt haben. In diesem Teil planen sie, verschiedene Einstiegssignale und einen Filter hinzuzufügen, um die Strategie zu verbessern. Bevor er sich mit dem Programmieren beschäftigt, betont Toby, wie wichtig es ist, das Ziel zu verstehen. Sie erläutern die Komponenten, die sie dem EA hinzufügen möchten, einschließlich einer zweiten Art von Einstiegssignal, das auf dem Verlassen der unteren und oberen Zone des Indikators basiert, und der Option, die Signale umzukehren.
Toby schlägt dann vor, auf Visual Studio Code umzusteigen, einen Editor, den sie für die MQL5-Codierung empfehlen. Sie erwähnen, dass der Code, an dem sie arbeiten werden, der im ersten Teil erstellte EA ist. Nach dem Kompilieren, um sicherzustellen, dass es ordnungsgemäß funktioniert, fahren sie mit der Codierung fort.
Der erste Schritt besteht darin, einen Eingang für den Signalmodus hinzuzufügen, indem eine Aufzählung (Enumeration) für die verschiedenen Modi verwendet wird. Sie erstellen die Aufzählung „Signalmodus“ mit Optionen wie „Ausgangskreuz normal“, „Eingangskreuz normal“, „Ausgangskreuz umgekehrt“ und „Eingangskreuz umgekehrt“. Toby erklärt die Bedeutung jeder Option und wie sie sich auf die Handelsstrategie auswirkt.
Nach dem Hinzufügen der Enumeration fügt Toby sie als Eingabe in den Code ein und weist die Standardoption „Exit Cross Normal“ zu. Sie stellen außerdem sicher, dass der Code kompiliert wird, um ihn auf Fehler zu prüfen.
Als nächstes plant Toby, den Signalmodus in der OnTick()-Funktion zu verwenden, um nach neuen Signalen zu suchen. Um den Code zu vereinfachen und komplexe if-Anweisungen zu vermeiden, beschließt Toby, eine separate Funktion namens „check signal“ zu schreiben, um die Signallogik zu verwalten. Sie erklären, dass diese Funktion einen booleschen Wert zurückgibt, der angibt, ob ein Handel eröffnet werden soll oder nicht.
Toby erstellt die Funktion „Signal prüfen“, die zwei Parameter benötigt: einen booleschen Parameter, um anzugeben, ob auf ein Kauf- oder Verkaufssignal geprüft wird, und einen ganzzahligen Parameter für die Anzahl der offenen Positionen. Sie fügen einen Kommentar hinzu, der den Zweck der Funktion und der Parameter erläutert. Sie fügen außerdem eine Prüfung hinzu, die „false“ zurückgibt, wenn eine Position bereits offen ist.
Als nächstes fügt Toby Code hinzu, um basierend auf dem ausgewählten Signalmodus auf Überkreuzungen zu prüfen. Sie erstellen boolesche Variablen für jede Crossover-Option, z. B. „oberes Ausgangskreuz“, „oberes Eingangskreuz“, „unteres Ausgangskreuz“ und „unteres Eingangskreuz“. Sie erklären die Logik hinter jeder Crossover-Bedingung und beziehen sich dabei auf die Werte der stochastischen Indikatorpuffer.
Nachdem er die Crossover-Prüfungen hinzugefügt hat, kompiliert Toby den Code, um sicherzustellen, dass keine Fehler vorliegen. Sie fügen außerdem die fehlende if-Anweisung hinzu und beheben die Kompilierungsfehler.
Nachdem die Funktion „Signal prüfen“ und die Crossover-Prüfungen eingerichtet sind, kehrt Toby zur Funktion OnTick() zurück und ersetzt die vorhandenen if-Anweisungen zum Überprüfen von Kauf- und Verkaufspositionen durch Aufrufe der Funktion „Signal prüfen“. Sie übergeben die entsprechenden Parameter und die Anzahl der offenen Positionen an die Funktion und prüfen, ob sie „true“ zurückgibt, bevor sie einen Handel eröffnen.
Nachdem er den Code erneut kompiliert hat, wechselt Toby zu MetaTrader, um die Logik des EA zu testen. Sie wählen den EA aus, wählen den Modus „Nur offener Preis“ und aktivieren den visuellen Modus zum Testen. Sie konfigurieren die Eingangsparameter für jeden Signalmodus und führen den visuellen Test durch. Toby erklärt, dass es wichtig ist, den EA gründlich zu testen, um sicherzustellen, dass er sich wie erwartet verhält.
Toby kommt aufgrund der visuellen Testergebnisse zu dem Schluss, dass alle Signalmodi ordnungsgemäß funktionieren. Sie schlagen vor, im nächsten Teil des Tutorials mit dem Hinzufügen eines Filters fortzufahren.
Derzeit rufen wir die Werte „eins“ und „zwei“ ab, um zu prüfen, ob ein Signal vorliegt. Ich möchte dies jedoch so ändern, dass wir mit unserem Puffer bei Index 0 beginnen. Zusätzlich sollten wir drei Werte für das Prüfsignal abrufen. Wenn unser Filter zum Löschen von Balken aktiv ist, benötigen wir möglicherweise zusätzliche Werte. Um diese Änderungen umzusetzen, müssen wir den Code ändern.
Scrollen wir zunächst nach oben, bis wir die Indikatorwerte abrufen. In der Funktion „Häkchen aufheben“, wo wir die Zeile „Indikatorwerte abrufen“ haben, müssen wir einige Änderungen vornehmen. Der erste Parameter stellt die Puffernummer des Indikators dar. Uns interessiert nur die Hauptlinie, die bei Index 0 liegt. Das bleibt also gleich. Allerdings ist die Startposition derzeit auf Index 1 eingestellt und wir rufen zwei Werte ab. Wir wollen die Startposition auf Index 0 ändern und mindestens drei Werte abrufen. Daher ändern wir den Code so, dass er bei Index 0 beginnt und drei Werte abruft: Null, Eins und Zwei.
Wenn unser Filter „Check Clear Bars“ aktiv ist, müssen wir zusätzliche Indikatorwerte abrufen, um den Filter zu überprüfen. Wir müssen „drei“ plus unseren eingegebenen Wert für die Löschbalken abrufen. Wenn beispielsweise der Eingabewert für klare Balken auf 5 eingestellt ist, benötigen wir insgesamt acht Werte. Daher ändern wir den Code entsprechend, um Werte ab Index 0 bis zur erforderlichen Anzahl von Werten abzurufen.
Nachdem wir diese Änderungen vorgenommen haben, müssen wir die abgerufenen Werte im Puffer mit dem Namen „Main“ speichern. Darüber hinaus sollten wir prüfen, ob die Funktion die angeforderten Werte erfolgreich abrufen konnte, d. h. drei plus unseren Eingabewert für die Löschbalken. Wir ändern den Code, um diese Prüfung einzuschließen.
Als nächstes müssen wir den Code aktualisieren, in dem wir das Signal überprüfen. Anstatt bei Index 0 auf den Puffer Main zuzugreifen, müssen wir jetzt für die Crossover-Prüfung auf Index 1 und 2 zugreifen. Wir ersetzen alle Instanzen von Index 0 durch 1 und Index 1 durch 2.
Jetzt haben wir die richtigen Indikatorwerte und können mit der for-Schleife fortfahren. Wir sollten den Code kompilieren, um sicherzustellen, dass keine Fehler vorliegen.
In der for-Schleife wollen wir unseren Filter zum Löschen von Balken ab Index 3 überprüfen. Dies ist die Position nach der Signalkreuzungsprüfung. Wir setzen diese Schleife fort, bis unser Zähler unter drei plus dem Wert für klare Balken liegt. Wenn der Wert zum Löschen von Balken beispielsweise auf 5 eingestellt ist, wäre der Zähler 8. Das bedeutet, dass wir bis zum Index 7, dem letzten Wert in unserer Schleife, prüfen. Der Zweck dieser Schleife besteht darin, sicherzustellen, dass es innerhalb dieser Balken zu keinen Überschneidungen der oberen Linie kommt. Wir aktualisieren den Code, um diese Änderungen widerzuspiegeln.
Innerhalb der for-Schleife prüfen wir zunächst die obere Ebene. Wir vergleichen den Wert am Puffer Main[i-1] mit dem oberen Eingangspegel. Wenn es größer ist und der Wert am Puffer Main[i] kleiner oder gleich dem oberen Eingangsniveau ist, liegt ein Crossover vor. Wir prüfen auch die umgekehrte Bedingung für einen Übergang in die andere Richtung. Wir modifizieren den Code entsprechend.
Nach der for-Schleife fügen wir eine weitere if-else-Anweisung hinzu. Wenn unsere Eingabe „Clear Bars Reverse“ wahr ist, geben wir „true“ zurück, da wir einen Crossover wünschen, wenn der Filter umgekehrt wird. Andernfalls geben wir false zurück.
Schließlich fügen wir eine ähnliche if-else-Anweisung für die Prüfung auf niedrigerer Ebene hinzu. Wir kopieren die vorhandene if-Anweisung und nehmen die notwendigen Änderungen für die Prüfung auf niedrigerer Ebene vor.
Nachdem wir diese Änderungen vorgenommen haben, kompilieren wir den Code erneut, um sicherzustellen, dass keine Fehler vorliegen. Jetzt können wir die Funktion „Check Clear Bars“ in unserer OnTick-Funktion verwenden.
In der OnTick-Funktion fügen wir die Funktion „Check Clear Bars“ in die if-Anweisung ein, in der wir das Signal überprüfen.
Fahren wir mit dem Optimierungsprozess fort. Wir haben das Euro/Dollar-Symbol und den Zeitrahmen ab 2019 ausgewählt. Wir werden nur den offenen Preis und den schnellen generischen Algorithmus verwenden. Unser Optimierungsziel ist es, die besten Parameter für unseren Clearbars-Filter zu finden.
Bevor wir mit der Optimierung beginnen, definieren wir die Parameter, die wir optimieren möchten. In diesem Fall optimieren wir die Lookback-Periode des Clearbars-Filters, die die Anzahl der für den Filter zu berücksichtigenden Balken bestimmt. Wir testen Werte im Bereich von 5 bis 20 und erhöhen sie um 5. Darüber hinaus optimieren wir die oberen und unteren Schwellenwerte für den Filter, indem wir Werte von 50 bis 150 testen und um 25 erhöhen.
Lassen Sie uns nun die Optimierung durchführen und die Ergebnisse analysieren. Wir werden uns den Nettogewinn, die Gesamtzahl der Trades und den Gewinnfaktor ansehen, um die Leistung jeder Parameterkombination zu bewerten. Basierend auf diesen Kennzahlen können wir die besten Parameterwerte identifizieren, die den höchsten Gewinn erzielen.
Nachdem wir die Optimierung ausgeführt haben, können wir die Ergebnisse untersuchen und die Parameterwerte identifizieren, die die beste Leistung erbracht haben. Wir könnten feststellen, dass ein Rückblickzeitraum von 10, ein oberer Schwellenwert von 100 und ein unterer Schwellenwert von 75 den höchsten Nettogewinn und Gewinnfaktor lieferten.
Sobald wir die optimalen Parameterwerte identifiziert haben, können wir sie verwenden, um unsere Strategie anhand eines größeren Datensatzes zu testen oder sie auf einem Live-Handelskonto bereitzustellen.
Denken Sie daran, dass die Optimierungsergebnisse auf historischen Daten basieren und möglicherweise keine Garantie für die zukünftige Leistung sind. Es ist wichtig, die Leistung der Strategie kontinuierlich zu überwachen, zu bewerten und die Parameter bei Bedarf anzupassen.
Mit den optimierten Parametern können wir unsere Strategie weiter verfeinern und weitere Verbesserungsmöglichkeiten erkunden. Wir können erwägen, zusätzliche Filter oder Bedingungen hinzuzufügen, um die Wirksamkeit der Strategie zu erhöhen.
Zusammenfassend lässt sich sagen, dass uns der Optimierungsprozess dabei hilft, die besten Parameterwerte für unseren Clearbars-Filter zu finden, wodurch die Leistung der Strategie verbessert und möglicherweise die Rentabilität gesteigert wird. Es ist ein wertvolles Werkzeug bei der Entwicklung und Verfeinerung von Handelsstrategien.