MQL5 Tutorial - Automatisch traden mit Metatrader5

In diesem Video wollen wir uns einmal anschauen wie man die Anzahl von Sell-Positionen ermitteln kann. Unser Expert Advisor hier zeigt uns derzeitig fünf Sell-Positionen an. Wir zählen das mal durch. Eins, zwei, drei, vier, fünf. Und wir wollen jetzt mal herausfinden, wie man so etwas mit MQL5 programmieren kann. Um das zu tun, klicken Sie im Metatrader bitte auf dieses kleine Symbol hier oder drücken Sie die F4-Taste. Das ruft dann hier den Metaeditor auf und hier klicken wir auf Datei, neue Datei, Expert Advisor aus Vorlage, weiter. Ich vergebe hier mal den Namen SimplerSellPositionCounter, klicke auf weiter, weiter und fertigstellen. Jetzt kann alles zwischen der OnTick-Funktion und dieser OnInit-Funktion hier gelöscht werden. Auch alles oberhalb der OnInit-Funktion wird entfernt und wir löschen auch die grauen Kommentarzeilen hier. Zunächst importieren wir die Datei Trade.mqh. Die stellt uns einige Handelsfunktionen bereit. Danach erstellen wir uns eine Instanz von CTrade, mit dem Namen Trade. Die nutzen wir später, um unsere Testpositionen zu eröffnen. Dazu rufe ich hier einmalig in der OnInit-Funktion eine Funktion mit dem Namen OpenTestPositions auf. Auf einem Echtgeldkonto würde man das natürlich nicht tun, aber ich brauche einige Positionen, damit ich etwas habe, das ich zählen kann. Innerhalb der OnTick-Funktion möchten wir gerne mit dem Comment-Befehl den Text Anzahl der Sell Positionen ausgeben. Gefolgt von den tatsächlichen Positionen die wir über eine noch zu erstellende Funktion mit dem Namen CountSellPositions ermitteln möchten. Diese Funktion soll uns einen Integer-Wert zurückliefern. Wir erstellen hier eine Variable mit dem Namen NumberOfSellPositions, die zunächst den Wert Null bekommt. Es handelt sich um eine Integer-Variable, da wir nur ganze Zahlen brauchen. Und jetzt nutzen wir eine Vorschleife, um alle Positionen durchzugehen. Die Gesamtanzahl von Positionen liefert uns die Funktion PositionsTotal. Und wir zählen hier so lange runter, wie wir noch offenen Positionen finden. Die Funktion PositionGetSymbol liefert uns das aktuelle Währungspaar für die entsprechende Position. Das Ergebnis weisen wir hier einer Text-Variable mit dem Namen CurrencyPair zu. Danach nutzen wir die Funktion PositionGetInteger und als Parameter verwenden wir POSITION_TYPE, alles in Großbuchstaben. Das brauchen wir, um die Richtung unserer Position zu ermitteln. Und wenn das aktuelle Währungspaar auf dem Chart übereinstimmt, mit dem Währungspaar unserer Position, dann prüfen wir im nächsten Schritt, ob die Positionsrichtung den Wert PositionTypeSell enthält. Wenn man sich das in der Hilfe einmal anschaut. Typ der Position gibt es hier einen Link und der zeigt uns, aha, POSITION_TYP_SELL, alles in Großbuchstaben, da handelt es sich um einen Verkauf und das ist genau das was wir brauchen und darum gehen wir jetzt hin und erhöhen die aktuelle Anzahl unserer Sell-Positionen um den Wert eins. Am Ende der Vorschleife, wenn wir alle Positionen durchgegangen sind, müssen wir hier noch die Klammer wieder schließen und dann nutzen wir den Befehl return NumberOfSellPositions um unsere ermittelte Positionsanzahl an das Hauptmodul zurückzugeben. Ich zeige jetzt noch kurz meine Funktion für die Testpositionen. Ich nutze hier einen Zufallsgenerator, der wird hier initialisiert. Berechnet dann eine zufällige Anzahl von Positionen und anhand dieser Anzahl werden hier unten entsprechend viele Buy- und Sell-Trades eröffnet. Auf einem Echtgeldkonto würde man das natürlich nicht so tun. Aber in diesem Fall, sind wir soweit fertig und können hier auf kompilieren klicken. Das hat hier ohne Fehler funktioniert. Falls bei Ihnen Fehler auftreten, oder Sie nicht wissen was dieser Code hier so macht, dann möchten Sie sich vielleicht die anderen Videos aus dieser Grundlagenserie noch einmal anschauen. Oder vielleicht ist auch der Premiumkurs interessant für Sie. Wir können jetzt jedenfalls hier oben auf dieses kleine Symbol hier klicken oder die F4-Taste d...

In diesem Video wollen wir einmal herausfinden, wie man die Anzahl von Positionen zählen kann. Hier oben steht der Text „Anzahl der Buy-Positionen“ und wir haben hier ein, zwei, drei, vier, fünf Buy-Positionen, das ist auch was unser Expert Advisor berechnet hat. Es gibt hier auch Verkaufspositionen, aber in diesem Video soll es darum gehen, wie man die Anzahl der Kaufpositionen mit MQL5 berechnen kann. Es handelt sich hierbei um eine Frage von einem Mitglied aus dem Premiumkurs. Also lassen sie uns herausfinden, wie man das mit MQL5 macht. Um das zu tun klicken sie im Metatrader bitte auf dieses kleine Symbol hier oben oder drücken sie die F4-Taste. Das ruft den Meta-Editor auf und hier klicken wir auf Datei, neue Datei, Expert Advisor aus Vorlage, weiter. Ich vergebe hier einmal den Namen SimplerBuyPositionCounter, klicke auf weiter, weiter und fertigstellen. Jetzt kann alles zwischen der OnTick-Funktion und der OnInit-Funktion gelöscht werden. Auch die Kommentarzeilen können gelöscht werden. Wir starten damit dass wir die Datei Trade.mqh importieren. Die enthält Handelsfunktionen mit den wir Positionen eröffnen können. Wir erstellen uns von der Klasse CTrade eine Instanz mit dem Namen Trade, die wir später nutzen werden um diese Positionen zu eröffnen. In der OnInit-Funktion möchte ich gerne eine Funktion aufrufen, die OpenTestPositions heißt, denn ich muss einige Testpositionen eröffnen, damit wir etwas zum Zählen haben. Auf einem Echtgeldkonto würde man das natürlich nicht so machen. Und innerhalb der OnTick-Funktion tun wir nur eins, nämlich, wir nutzen den Comment-Befehl um die Anzahl der Buy- Positionen auszugeben und dazu rufen wir diese Funktion CountBuyPositions auf, die wir jetzt noch programmieren müssen. Unsere selbsterstellte Funktion soll einen ganzzahligen Wert, also einen Integerwert zurückliefern. Sie heißt CountBuyPositions und wir übergeben hier keine Parameter. Im ersten Schritt erstellen wir hier eine Intergervariable mit dem Namen NumberOfBuyPositions. Das ist eine lokale Variable für die Positionsanzahl. Danach gehen wir mit einer Vorschleife alle Positionen durch. Wir nutzen die Funktion PositionsTotal um die Anzahl der Gesamtpositionen zu ermitteln. Und innerhalb der Vorschleife zählen wir solange alle Positionen runter, bis keine mehr übrig ist. Für jede gefundene Position ermitteln wir mit der Funktion PositionGetSymbol, anhand der aktuellen Positionsnummer, das aktuelle Währungspaar für diese Position, danach ermitteln wir den Positionstypen. Das geht mit der Funktion PositionGetInteger und als Parameter übergeben wir Position_Type. Alles in Großbuchstaben. Jetzt prüfen wir ob das Symbol, also das Währungspaar auf dem aktuellen Chart zum Währungspaar der entsprechenden Position passt. Zusätzlich möchten wir prüfen, ob die entsprechende Richtung unseres Trades den Wert Position_Type_Buy hat. In dem Fall handelt es sich um eine Kaufen-Position und wenn das so ist, dann möchten wir gerne unsere Variable für die Anzahl der Positionen um eins erhöhen. Danach beenden wir die Vorschleife und geben die Positionsanzahl an unser Hauptmodul zurück. Das machen wir mittels return. Bitte vergessen sie nicht hier die schließende Klammer, für die Funktion. Im Großen und Ganzen wars das. Ich zeigen ihnen noch kurz meine Testfunktion um die Testpositionen zu eröffnen. Auf einem Echtgeldkonto würden sie das natürlich nicht machen. Ich nutze hier einen Zufallsgenerator, um bis zu zehn Positionen gleichzeitig zu erzeugen. Hier machen wir dann Buy- und Sell-Trades auf, damit wir etwas haben was zählen können. Jetzt klick ich hier auf kompilieren oder drücke die F7-Taste. Ich habe keine Fehler und wenn das bei Ihnen auch der Fall ist, dann klicken sie bitte hier oben, oder drücken sie die F4-Taste um in den Metatrader zurückzukehren. Und im Metatrader klicken wir auf Ansicht, Strategietester oder drücken die Tastenkombination Steuerung und R. Hier wählen wir jetzt die neue Datei SimplerBuyPositionCounter.ex5 aus.

In diesem Video wollen wir uns einmal anschauen, wie man mit MQL5 einen Trailing Stop für Sell Trades programmieren kann. Wir haben hier oben einen Stop Loss, der automatisch angepasst wird, sobald der Preis hier sinkt. Und wir wollen uns einmal anschauen, wie man das in MQL5 programmieren kann. Dazu klicken Sie bitte im Metatrader auf dieses kleine Symbol hier oder drücken Sie die F4 Taste. Das ruft dann hier den Metaeditor auf. Und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier einmal den Namen SimplerSellTrainlingStop. Klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles hier oberhalb der OnTick Funktion gelöscht werden. Und auch die zwei Kommentarzeilen werden entfernt. Wir starten wieder mit include und importieren die Datei Trade.mqh. Die enthält die Klasse CTrade. Und davon erstellen wir uns jetzt eine Instanz, mit der wir später eine Position eröffnen möchten. Da das eine Sell Position sein, müssen wir zunächst den Bid Preis berechnen. Das machen wir mit der Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Und wir nutzen SYMBOL_BID, alles in Großbuchstaben. Ich nutze in der Regel auch noch NormalizeDouble und _Digits, denn das berechnet mit automatisch die aktuelle Anzahl von Nachkommastellen für das jeweilige Währungspaar. Jetzt prüfen wir, ob uns die Funktion PositionsTotal einen Wert von null zurückliefert. Denn wenn das der Fall ist, dann haben wir keine offenen Positionen. Und in dem Fall werden wir jetzt eine Beispiel Position eröffnen. Denn wir brauchen etwas, um auszuprobieren, ob unser Trailing Stop funktioniert. Da nutze ich trade.Sell und eröffne hier eine Position von zehn Microlot. Anschließend möchte ich gerne den Trailing Stop setzen. Dazu nutze ich die Funktion CheckTrailingStop und übergeben ihr den ermittelten Bid Preis. Die Funktion gibt es aber noch gar nicht. Also müssen wir die jetzt erstellen. Ich nutze hier void, denn diese Funktion soll nur den Trailing Stop setzen. Ich brauche keinen Rückgabewert. Allerdings übergeben wir als Parameter den Bid Preis. In der Funktion selbst setzen wir das Ziel für unseren Trailing Stop 150 Punkte oberhalb des Bid Preises an. Und da wir auch mehr als eine Position geöffnet haben könnten, müssen wir jetzt mit einem for Loop alle Positionen durchgehen. Die Funktion PositionsTotal liefert uns die Gesamtmenge der offenen Positionen. Von da aus zählen wir runter. Und für die jeweilige Position nutzen wir jetzt PositionGetSymbol, um die Positionswährung zu ermitteln. Denn wir wollen natürlich nur dann weitermachen, wenn das Währungspaar auf dem Chart mit dem Positionssymbol übereinstimmt. Und außerdem möchte ich noch prüfen, ob der Positionstyp einem Sell Trade entspricht. Das machen wir mit der Funktion PositionGetInteger, übergeben als Parameter POSITION_TYPE, auch wieder in Großbuchstaben und überprüfen, ob der Rückgabewert den Wert ORDER_TYPE_SELL hat. Denn das ist der Wert den wir zurückbekommen, wenn es sich um eine Markt Sell Order, also eine Marktverkaufsorder handelt. Wenn alle diese Vorbedingungen zutreffen, dann ermitteln wie das Positionsticket. Wiederum mit der Funktion PositionGetInteger. Diesmal für POSITION_TICKET, auch wieder alles in Großbuchstaben. Das Positionsticket ist eine eindeutige Möglichkeit zur Identifizierung, ähnlich wie bei einem Nummernschild. Außerdem hätte ich gerne noch den aktuellen Stop Loss für die Position. Den bekomme ich mit PositionGetDouble. Und hier nutzen wir als Parameter POSITION_SL. Mit dieser Information kann ich jetzt prüfen, ob der aktuelle Stop Loss für die Position größer ist, als der gewünschte Stop Loss. Und wenn dem so ist, dann passen wir das Ganze an. Das machen wir mit der Funktion trade.PostitionModify für das aktuelle Ticket. Und hier passen wir den aktuellen Stop Loss an, indem wir ihn um zehn Punkte nach unten schieben. Das war es soweit. Wir müssen jetzt hier noch die ganzen offenen Schleifen schließen.

In diesem Video wollen wir uns einmal anschauen, wie man einen Trailing Stop für eine Buy Position programmieren kann. Man sieht hier, dass der Stop Loss hinter dem Preis herwandert. Also nachgezogen wird, wenn der Preis hier oben steigt. Und wir wollen uns einmal anschauen, wie man das in MQL5 programmieren kann. Um das zu tun, klicken Sie im Metatrader bitte hier oben auf dieses kleine Symbol oder drücken Sie die F4 Taste. Das ruft dann hier den Metaeditor auf. Und hier wählen wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, Weiter. Ich verwende hier einmal den Namen SimplerBuyTrainlingStop. Klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb der OnTick Funktion hier gelöscht werden. Auch die zwei Kommentarzeilen werden entfernt. Wir starten damit, dass wir die Datei Trade.mqh einbinden. Die gehört zum Lieferumfang von MQL5 dazu und bietet uns vereinfachte Handelsfunktionen. Wir starten damit, dass wir eine Instanz von CTrade erstellen, die den Namen trade bekommt. Die werden wir gleich verwenden, um eine Testposition zu eröffnen. Dazu müssen wir zunächst einmal den Ask Preis ermitteln. Das geht mit SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Wir verwenden SYMBOL_ASK, alles in Großbuchstaben. Und mit NormalizeDouble und _Digits ermitteln wir auch noch die Anzahl der Nachkommastellen. Denn je nach Währungspaar können das drei oder fünf Nachkommastellen sein. Danach prüfen wir, ob wir keine Positionen geöffnet haben. Das geht mit PositionsTotal. Und wenn der Rückgabewert null ist, dann eröffnen wir eine Testposition. Das soll ein Buy Trade für zehn Microlot sein. Das würde man auf einem Echtgeldkonto natürlich jetzt nicht so machen. Aber für unseren Testfall brauchen wir eine Position, damit wir den Trailing Stop ausprobieren können. Den rufen wir auf mit CheckTrailingStop und übergeben hier den ermittelten Ask Preis als Parameter. Aber diese Funktion hier muss jetzt noch programmiert werden. Für unseren Trailing Stop brauchen wir keinen Rückgabewert. Die Funktion soll ChecktrailingStop heißen. Und als Parameter übernimmt sie den Ask Preis, den wir hier oben übergeben haben. Zunächst definieren wir hier den gewünschten Stop Loss Wert von 150 Punkten. Denn wir möchten gerne vom aktuellen Ask Preis aus, 150 Punkte unterhalb unseren Stop Loss setzen. Dazu gehen wir zunächst einmal erst alle Positionen durch. Wir nutzen dafür PositionsTotal. Das ist eine Funktion, die uns die Anzahl der offenen Positionen zurückgibt. Und von dieser Anzahl zählen wir jetzt mit einer for Schleife komplett runter, bis keine Position mehr übrig ist. Für jede Position ermitteln wir das aktuelle Positionssymbol, also das Währungspaar, in dem die Position eröffnet wurde. Und wenn das aktuelle Währungspaar auf dem Chart und das Währungspaar der geöffneten Position übereinstimmen, dann möchten wir gerne den Stop Loss prüfen. Dazu brauchen wir aber erst noch ein paar Eigenschaften der Position. Die erste Eigenschaft ist die Ticket Nummer. Die kann ermittelt werden mit PositionGetInteger, POSITION_TICKET, bitte alles in Großbuchstaben schreiben. Es handelt sich hier um einen Datentyp ulong. Das steht für unsigned long integer. Außerdem brauchen wir noch den aktuellen Stop Loss Wert für die Position. Den ermitteln wir mit PositionGetDouble. POSITION_SL liefert uns als Wert den aktuellen Stop Loss. Und wenn der aktuelle Stop Loss für die Position mehr als 150 Punkte unter dem Ask Preis ist, wenn als der CurrentStopLoss kleiner ist als der gewünschte Stop Loss von 150 Punkten, den wir hier oben definiert haben, dann nutzen wir trade.PostitionMedify für das aktuelle Ticket und ziehen unseren aktuellen Stop Loss um zehn Punkte nach oben. Zum Schluss machen wir hier noch alle Schleifen zu. Wenn man eine Klammer hier markiert, kann man ganz gut erkennen, zu welchen anderen Klammer sie gehört. Und das war es im Großen und Ganzen. Wenn Ihnen das zu schnell war oder wenn Sie nicht verstehen,

In diesem Video wollen wir uns einmal anschauen, wie man so einen Indikator hier programmieren kann. Es handelt sich um einen verschobenen gleitenden Durchschnitt, einen sogenannten Shifted Moving Average. Der rote gleitenden Durchschnitt hier, ist ein normaler Moving Average. Und der grüne ist der gleiche Moving Average, zwanzig Kerzen in die Zukunft verschoben. Und wir wollen jetzt einmal anschauen, wie man so was programmiert und wie man damit kaufen und verkaufen Signale erstellen kann. Um das zu tun, klicken Sie im Metatrader bitte auf dieses kleine Symbol hier oben oder drücken Sie die F4 Taste. Das ruft dann hier den Metaeditor auf. Und hier klicken wir auf Datei, Neu, Expert Advisor aus Vorlage. Ich vergebe hier mal den Namen SimplerShifteSMAEA, klicke auf Weiter, Weiter und Fertigstellen. Jetzt können Sie alles löschen, was sich oberhalb dieser OnTick Funktion befindet. Und auch die zwei Kommentarzeilen werden entfernen. Wir starten mit einem include Befehl und importieren uns die Datei Trade.mqh. Die enthält Handelsfunktionen. Und damit erstellen wir uns jetzt von der Klasse CTrade eine Instanz mit dem Namen trade. Die werden wir später benutzen, um Positionen zu eröffnen. Damit wir das können, müssen wir den Aks Preis und den Bid Preis berechnen. Das geht mit der Funktion SymbolInfoDouble. Der erste Parameter _Symbol steht für das aktuelle Währungspaar auf dem Chart. Parameter Nummer zwei, SYMBOL_ASK, wird benutzt, um den Ask Preis zu ermitteln. Bitte alles in Großbuchstaben schreiben. Und mit NormalizeDouble und _Digits stelle ich sicher, dass ich je nach Währungspaar die jeweils richtige Anzahl von Nachkommastellen berechne. Dieses Währungspaar hier hat drei Nachkommastellen, während andere Währungspaar fünf Nachkommastellen haben. Das Gleiche machen wir hier noch mal mit SYMBOL_BID, um Bid Preis zu errechnen. Danach erstellen wir uns für unser Signal eine string Variable, weisen hier aber noch keinen Wert zu, denn der muss noch ermittelt werden. Für unseren ersten gleitenden Durchschnitt erstellen wir uns ein Moving Average Array. Das Ganze machen wir auch noch mal für den verschobenen gleitenden Durchschnitt, also für den Shifted Moving Average. Unser normaler gleitender Durchschnitt wird mit der Funktion iMA erstellt. Und zwar für das aktuelle Währungspaar auf dem Chart und die auf dem Chart aktuell ausgewählte Zeiteinheit. Wir möchten das Ergebnis aufgrund der letzten zwanzig Kerzen zunächst ohne Verschiebung errechnen. Dazu nutzen wir MODE_SMA für Simple Moving Average. Und das Ganze soll errechnet werden anhand der Schlusskurse. Um das Ganze für den Shifted Moving Average zu berechnen, nutzen wir die gleichen Parameter, einen etwas anderen Namen. Und dieses Mal verändern wir den Verschiebungsparameter und machen eine zwanzig draus. Das sorgt dann dafür, dass der aktuelle gleitenden Durchschnitt noch einmal gezeichnet wird, dieses Mal zwanzig Kerzen in die Zukunft verschoben. Für jedes Array nutzen wir jetzt noch ArraySetAsSeries um von der aktuellen Kerze an, die Preise absteigend zu sortieren mit CopyBuffer. Danach nutzen wir CopyBuffer, um anhand der Moving Average Definition, die wir hier oben getroffen haben, für Buffer null, also die einzige Linie, die wir bei dem Indikator für einen gleitenden Durchschnitt sehen, von der aktuellen Kerze null für drei Kerzen, die Preisdaten zu kopieren und in unserem MovingAverageArray zu speichern. Das Ganze wiederholen wir noch mal für den Shifted Moving Average. Bitte achten Sie darauf, dass Sie den Namen und den Namen für das Array entsprechend abändern. Ansonsten ist auch diese Zeile identisch. Das Gleiche gilt für die nächsten beiden Zeilen. Hier greifen wir nämlich auf Kerze null im MovingAverageArray zu, um den aktuellen Wert für den aktuellen gleitenden Durchschnitt zu ermitteln. Und der Wert in Kerze null für den verschobenen, also für den ShiftedMovingAverage wird der Variable myShiftedAverageValue zugewiesen. Und wenn der MovingAverage größer ist,

In diesem Video wollen wir uns einmal den Average True Range Oszillator anschauen. Wir erstellen Kaufen und Verkaufen Signale, die auch auf dem Chart direkt gehandelt werden anhand dieser Werte hier. Eigentlich wird so ein Oszillator als Filter eingesetzt. Wir wollen ihn jetzt mal als Signal programmieren. Klicken Sie im Metatrader bitte auf dieses kleine Symbol hier oder drücken die F4 Taste. Das ruft dann hier den Metaeditor auf. Und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier mal den Namen SimplerAverageTrueRangeEA, klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb der OnTick Funktion entfernt werden. Und auch die zwei Kommentarzeilen kommen weg. Wir starten damit, dass wir mitteln include die Datei Trade.mqh importieren. Damit lässt sich eine Instanz der Klasse CTrade erstellen. Die nennen wir trade und die wird später noch benötigt, um Positionen zu eröffnen. In der OnTick Funktion erstellen wir uns erst einmal eine leere Variable für das Signal. Die bekommt auch den Namen signal, aber noch keinen Wert. Da wir kaufen und verkaufen möchten, müssen wir zunächst den Ask und den Bid Preis berechnen. Das geht mit der Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. SYMBOL_ASK, alles in Großbuchstaben, liefert uns den Ask Preis. Und SYMBOL_BID würde uns den Bid Preis anzeigen. Mittels NormalizeDouble und _Digits lassen wir uns hier für die Währungspaare ermitteln, ob wir drei oder fünf Nachkommastellen haben. Je nach Währungspaar ist das unterschiedlich. Als nächstes erstellen wir uns ein Array für Preisdaten. Das bekommt den Namen PriceArray. Und jetzt können wir mit der eingebauten MQL5 Funktion iATR definieren, wie wir die AverageTrueRange berechnen möchten. _Symbol ermittelt das aktuelle Währungspaar auf dem Chart. _Period wird uns die aktuelle Zeiteinheit auf dem Chart ausgeben. Und dieser letzte Parameter 14 steht für 14 Kerzen. Wenn Sie auf einem leeren Chart einmal auf Einfügen, Indikatoren, Oszillatoren, Average True Range klicken, dann sehen Sie auch hier die 14 Kerzen als Voreinstellung. Wir übernehmen das mal mit Okay. Diese Ansicht ließe sich jetzt mit der rechten Maustaste über Vorlagen, Vorlage speichern, als tester.tpl speichern, die aktuelle Schablone ersetze ich hier mal. Denn das ist die Schablone, die auch im Strategietester später benutzt wird. Seit dem letzten Update kommt es vor, dass man die Signale zweimal angezeigt bekommt. In dem Fall lösche ich hier den Indikator einfach und speichere die leere Vorlage als tester.tpl. Machen wir mal weiter. Wir nutzen ArraySetAsSeries um unser PriceArray von der aktuellen Kerze an abwärts zu sortieren. Und mittels CopyBuffer füllen wir jetzt unser PriceArray mit Daten anhand der Definition, die wir hier oben getroffen haben. Und zwar für Buffer null, das ist diese Signallinie hier, von der aktuellen Kerze null für drei Kerzen. Und diese Daten speichern wir in unserem PriceArray. Und jetzt können wir den aktuellen Wert ermitteln, indem wir uns den Wert von Kerze null aus unserem PriceArray holen. Mit NormalizeDouble und Komma fünf stelle ich sicher, dass die Darstellung hier auch fünf Nachkommastellen hat, wie der Indikator selbst. Ich möchte hier gerne eine statische Variable verwenden für einen alten Wert, den ich dann mit dem aktuellen Wert vergleichen kann. Und wenn dieser alte Wert beim ersten Mal noch keinen Wert hat, dann weisen wir den aktuellen Wert als alten Wert zu. Und wenn jetzt unser aktueller Wert größer ist, als der alte Wert, dann betrachten wir das in diesem Fall als Kaufsignal und weisen das Wörtchen buy unserer signal Variable zu. Im anderen Fall, ein Verkaufssignal würde entstehen, wenn es runtergeht. Wenn also der aktuelle Wert kleiner ist als der alte Wert, in dem Fall weisen wir unserer signal Variable den Wert sell zu. Denn jetzt wollen wir verkaufen. Und zwar immer, wenn unser signal auf sell steht und uns die Funktion PositionsTotal einen Wert von ...

In diesem Video wollen wir uns einmal anschauen, wie man den Parabolischen SAR Indikator hier programmieren kann. Der produziert solche Punkte, die sich entweder unterhalb oder oberhalb der Kerzen bewegen. Und wir wollen jetzt mal schauen, wie man so was mit MQL5 automatisieren kann. Um das zu tun klicken Sie im Metatrader bitte auf dieses kleine Symbol hier oben oder drücken Sie die F4 Taste. Das ruft dann hier den Metaeditor auf. Und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlagen, Weiter. Ich vergebe hier mal den Namen SimplerParabolicSAREA, klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb der OnTick Funktion gelöscht werden. Und wir können auch die zwei Kommentarzeilen hier entfernen. Wir starten mit einem include Befehl für die Datei Trade.mqh. Die ermöglicht uns eine Instanz von CTrade zu erstellen. Die nennen wir trade und die wird später noch benötigt, um Positionen zu eröffnen. Innerhalb der OnTick Funktion berechnen wir jetzt den Aks Preis und den Bid Preis. Das macht die Funktion SymbolInfoDouble für das aktuelle Währungspaar. Wir nutzen SYMBOL_ASK, alles in Großbuchstaben, um den Ask Preis zu berechnen. Den brauchen wir, wenn wir kaufen wollen. Und mit SYMBOL_BID bekommen wir den Bid Preis. Den brauchen wir, wenn wir verkaufen. Zusätzlich nutze ich hier NormalizeDouble und _Digits, denn mit _Digits bekomme ich die Anzahl der Ziffern nach dem Dezimalpunkt und zwar für das aktuelle Währungspaar. Das kann unterschiedlich sein. Und ich möchte das gerne automatisiert berechnen lassen. Jetzt brauchen wir noch eine signal Variable. Die bekommt auch den Namen signal. Wir weisen hier noch keinen Text zu, das machen wir später noch. Holen wir uns erst einmal mit MqlRates die Preisdaten für ein PriceArray. MqlRates stellt diese ganzen Preisinformationen für jede Kerze bereit. Mit ArraySetAsSeries wird unser PriceArray zunächst von der aktuellen Kerze an abwärts sortiert. Danach nutzen CopyRates für das aktuelle Währungspaar und die aktuelle Zeiteinheit. Die man übrigens auch mit Unterstrich schreiben könnte. Denn das hier oben ist dasselbe, wie das hier. Und das gilt auch für die Periode auf dem Chart. Mit CopyRates holen wir uns von der aktuellen Kerze an für drei Kerzen die Preisdaten und speichern sie in unserem PriceArray. Jetzt brauchen wir noch ein Array. Diesmal für den SAR Indikator. Wir definieren jetzt mit Hilfe der eingebauten Funktion iSAR für das aktuelle Währungspaar auf dem Chart und die auf dem Chart ausgewählte Zeiteinheit. Schauen wir uns doch mal an, was diese beiden Parameter hier bedeuten. Dazu klicken wir auf Einfügen, Indikatoren, Tendenz, Parabolic SAR und dann sehen wir hier einen Schrittwert von 0,02 und einen Maximum Wert von 0,2. Bestätigen wir den mal. Dann wird der Indikator hier auf dem Chart angezeigt. Klicken wir die rechte Maustaste, wählen Vorlagen und Vorlage speichern. Dann können wir diese Ansicht jetzt unter dem Namen tester.tpl speichern. Denn das ist die Schablone, die vom Backtest genutzt wird. Also bitte speichern Sie das ab. Der aktuelle Wert kann überschrieben werden. Wenn Sie das nicht tun, dann sehen Sie eventuell nach dem letzten Update im Backtest sonst den Indikator nicht. Wir wissen jetzt, dass dieser Parameter für die Schrittweite und dieser hier für den Maximalwert steht. Diese Werte übernehmen wir und sortieren unser Array von der aktuellen Kerze an abwärts indem wir ArraySetAsSeries verwenden. Jetzt können wir mittels CopyBuffer anhand der SARDefinition, die wir hier oben getroffen haben, für das Buffer null, das sind diese Punkte hier, beginnend von Kerze null für drei Kerzen die Werte in unserem SARArray speichern. Denn das ermöglicht uns, den Wert für die letzte Kerze zu ermitteln, indem wir uns den Wert aus Kerze eins von unserem Array holen. Der wird hier mit NormalizeDouble und dieser fünf noch so formatiert, dass wir fünf Nachkommastellen erhalten. Und wenn der Wert kleiner ist,

In diesem Video wollen wir uns einmal anschauen, wir man für diesen Oszillator hier, für den RSI, einen Expert Advisor programmieren kann, der in der Lage ist, nicht nur Signale zu generieren, sondern auch automatisch zu handeln. Der RSI ist auch bekannt als Relative Strength Index. Es handelt sich um einen Oszillator. Und wir wollen uns jetzt einmal anschauen, wie man sowas in MQL5 programmiert. Um das zu tun, klicken Sie im Metatrader bitte auf dieses Symbol hier oben oder drücken Sie die F4 Taste. Das ruft dann hier den Metaeditor auf. Und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier einmal den Namen SimplerRSIEA, klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann hier alles oberhalb der OnTick Funktion gelöscht werden. Und auch die zwei Kommentarzeilen kommen weg. Wir starten mit einem include Befehl. Der wird uns die Datei trade.mqh importieren, die zu MQL5 dazugehört und Handelsfunktionen bereitstellt. Damit können wir uns von der Klasse CTrade eine Instanz mit dem Namen trade erstellen. Die werden wir später nutzen, um damit auch Positionen zu eröffnen. Dazu berechnen wir erst einmal den Ask Preis und den Bid Preis. Das geht mit der Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart und die auf dem Chart abgebildete Zeiteinheit. Wir nutzen SYMBOL_ASK, alles in Großbuchstaben, um den Ask Preis zu ermitteln. Mit NormalizeDouble und _Digits ermitteln wir die Anzahl der Ziffern nach dem Dezimalpunkt. Das ist bei manchen Währungspaaren dreistellig und bei anderen fünfstellig. Für den Bid Preis sieht die Zeile nahezu identisch aus. Diesmal verwenden wir SYMBOL_BID, alles in Großbuchstaben bitte. Danach erstellen wir eine Variable für das Signal. Die bekommt auch den Namen Signal, aber zunächst noch keinen zugewiesenen Wert. Denn, den möchten wir gleich noch berechnen. Dazu erstellen wir uns ein Array für die Preisdaten. Ich vergebe hier mal den Namen MyRSIArray. Mit ArraySetAsSeries sortieren wir das Preis Array von der aktuellen Kerze an absteigend. Und jetzt nutzen wir die eingebaute Funktion iRSI um für das aktuelle Währungspaar und die aktuell auf dem Chart ausgewählte Zeiteinheit, den RSI Wert zu berechnen. Hier steht eine 14. Schauen wir mal, was das zu bedeuten hat. Wenn Sie auf einem beliebigen Chart auf Einfügen, Indikatoren, Oszillatoren, Relative Strength Index klicken, dann sehen Sie hier, dass für die Periode 14 eingetragen ist. Das ist der Standardwert. Und der RSI wird auf 14 Kerzen anhand der Schlusskurse berechnet. Bestätigen wir das mal mit Okay. Dann haben wir hier auch den Oszillator im Chart. Und damit wir das gleich auch im Strategietester sehen, klicken wir mit der rechten Maustaste, wählen Vorlagen, Vorlage speichern und speichern die Schablone als tester.tpl. Denn das ist die Schablone, die im Strategietest verwendet wird. Die aktuelle tester.tpl wird überschrieben. Jetzt ist auch klar, wofür die letzten beiden Parameter stehen. Nämlich für 14 Kerzen und den Schlusskurs. Danach nutzen wir CopyBuffer um unser RSIArray anhand der RSI Definition, die wir hier oben getroffen haben, mit Daten zu füllen. Und zwar für Buffer null, das ist diese blaue Signallinie hier, angefangen von Kerze null, kopieren wir uns für drei Kerzen die Preisdaten und speichern sie in unserem RSIArray. Das ermöglicht uns jetzt, einen RSI Wert zu berechnen, indem wir uns den Wert aus Kerze null aus dem RSIArray holen. Mit NormalizeDouble und diesem Komma zwei Wert hier sorgen wir dafür, dass der Wert auf zwei Nachkommastellen gekürzt wird, so wie hier im Indikator auch angegeben. Und wenn der RSI Wert größer ist als siebzig, das bedeutet, die Signallinie würde oberhalb dieser gestrichelten Linie sein, dann ist das für uns ein Verkaufssignal. Also weisen wir den Begriff sell unserer Signal Variable zu. Im anderen Fall, wenn der RSI Wert kleiner ist als dreißig, dann bedeutet das, dass die blaue Linie unterhalb der unteren gestrichelten Linie ist.

In diesem Video wollen wir uns einmal anschauen, wie man den MACD automatisieren kann. Das ist dieser Oszillator hier unten. Und wir möchten herausfinden, wie man mit MQL5 die entsprechenden Signale nutzen kann, um Positionen automatisiert zu eröffnen. Um das zu tun, klicken Sie im Metatrader bitte auf dieses kleine Symbol hier oder drücken Sie die F4 Taste. Das ruft dann hier den Metaeditor auf. Und hier klicken wir auf Datei, Neu, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier einmal den Namen SimplerMacDEA, klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb der OnTick Funktion hier gelöscht werden. Und auch die zwei Kommentarzeilen werden entfernt. Wir starten mit einem include Befehl für die Datei Trade.mqh. Die gehört zum Lieferumfang von MQL5 dazu und stellt Handelsfunktionen bereit. Danach erstellen wir eine Instanz von der Klasse CTrade. Die bekommt den Namen trade. Und diese Instanz werden wir gleich verwenden, um Positionen zu eröffnen. Dazu müssen wir erst einmal den Ask Preis und den Bid Preis ermitteln. Das macht die Funktion SymbolInfoDouble für das aktuelle Symbol, also das Währungspaar auf dem Chart. Wir verwenden SYMBOL_ASK, alles in Großbuchstaben, für den Ask Preis, beziehungsweise SYMBOL_BID für den Bid Preis. Und mit NormalizeDouble und _Digits stellen wir sicher, dass die Berechnung entweder drei oder fünf Nachkommastellen hat, je nachdem welches Währungspaar wir verwenden. Danach bauen wir uns eine Variable für unser Signal. Das soll eine Textkette sein. Darum ist sie vom Typ string. Und der Name ist signal. Wir weisen hier noch keinen Wert zu, denn der muss noch ermittelt werden. Für die Berechnung brauchen wir zunächst einmal ein Array für Preisdaten. Das bekommt den Namen myPriceArray. Und jetzt nutzen wir die in MQL5 integrierte Funktion iMACD für das aktuelle Währungspaar auf dem Chart und die dort verwendete Zeiteinheit. Um anhand der Schlusskurse einen Wert zu berechnen. Diese drei Werte hier schauen wir uns jetzt mal an. Denn wenn Sie auf irgendeinem Chart auf Einfügen, Indikatoren, Oszillatoren, MACD klicken, dann sehen Sie hier die Werte zwölf, 26 und neun. Zwölf steht für den schnellen exponentiellen Moving Average. 26 für den langsamen exponentiellen Moving Average. Und neun für den Simple Moving Average. Wenn Sie sich die genauen Formeln für den MACD einmal anschauen wollen, dann können Sie auf Seiten wie Investopedia.com die Formeln dafür finden. Für jetzt reicht es aus zu wissen, dass diese Werte hier mit den Grundwerten übereinstimmen. Mit CopyBuffer möchten wir jetzt anhand der MACD Definition, die wir hier oben getroffen haben, für den Buffer null, also unsere Signallinie, von der aktuellen Kerze null für drei Kerzen die Preisdaten in unser Preisarray kopieren. Warum nutze ich hier immer drei Kerzen? Nun, das ist schneller als alle Kerzen auf dem Chart zu berechnen und spart deshalb etwas Rechenzeit. Und gleichzeitig sind drei Kerzen genug, um auch Überkreuzungen zu berechnen. Für dieses einfache Beispiel brauchen wir eigentlich nur den Wert von Kerze null, von der aktuellen Kerze aus unserem Preisarray. Denn, wenn unser MACD Wert größer ist als null, das bedeutet, wenn er sich oberhalb dieser gestrichelten Linie hier befindet, dann hätten wir ein Verkaufssignal und weisen den Begriff sell unsere Signal Variable zu. Im anderen Fall, wenn der MACD Wert kleiner ist als Null, dann wäre das ein Kauf Signal. In dem Fall weisen wir unserer Signal Variable den Wert buy zu. Und wenn unser Signal den Wert sell hat, und PositionsTotal kleiner ist als eins, dann bedeutet das, wir keine offenen Positionen. Und in dem Fall nutzen wir trade.sell um zehn Mikrolot zu verkaufen. Andernfalls, wenn das Signal den Wert buy hat und wir keine offenen Positionen haben, dann nutzen wir trade.buy und kaufen zehn Mikrolot. Zum Schluss generieren wir noch eine Chart Ausgabe. Die soll den Comment Befehl nutzen und uns den Text: Das aktuelle Signal ist gerade,

In diesem Video wollen wir uns einmal anschauen, wie man so einen Crossover Moving Average Expert Advisor automatisieren kann. Wir haben hier einen gelben und einen roten Moving Average. Und wenn die zwei sich überkreuzen, dann wird hier oben ein Signal generiert, das hier unten eine automatische Positionseröffnung verursacht. Und wir wollen uns in diesem Video einmal anschauen, wie man das mit MQL5 programmieren kann. Um das zu tun, klicken Sie im Metatrader bitte auf dieses kleine Symbol hier oben oder drücken Sie die F4 Taste. Das ruft dann hier den Metaeditor auf. Und hier klicken wir auf Datei, Neu, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier mal den Namen SimplerCrossoverEA, klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb der OnTick Funktion gelöscht werden. Und wir entfernen auch die zwei Kommentarzeilen hier. Wir starten mit einer include Anweisung, mit der wir uns die Datei Trade.mqh importieren. Die gehört mit zum Lieferumfang von MQL5 und stellt vereinfachte Handelsfunktionen bereit. Danach erstellen wir uns hier eine Instanz von der Klasse CTrade. Die bekommt den Namen trade und wir werden sie gleich verwenden, um damit eine Position zu eröffnen. Bevor wir das aber tun können, brauchen wir erst einmal den Ask Preis und den Bid Preis. Die kann man ermitteln mit der Funktion SymbolInfoDouble. Als Parameter übergeben wir hier das aktuelle Währungspaar auf dem Chart. Das wird automatisch ermittelt durch _Symbol. Und im zweiten Parameter geben wir an, ob wir den Ask Preis oder den Bid Preis haben möchten. Für den Ask Preis verwenden wir SYMBOL_ASK, alles in Großbuchstaben. Und für den Bid Preis dann entsprechend SYMBOL_BID. NormalizeDouble und _Digits sorgt dafür, dass je nach Währungspaar entweder drei oder fünf Nachkommastellen automatisch ermittelt werden. Als nächstes brauchen wir noch eine Variable für unser Signal. Die bekommt auch den Namen Signal und zunächst einen leeren Wert zugewiesen. Für unseren Crossover brauchen wir ein SmallMovingAverageArray und ein BigMovingAverageArray. Legen wir zunächst hier oben einmal fest, dass der SmallMovingAverage einen Wert von zwanzig Kerzen und der BigMovingAverage einen Wert von fünfzig Kerzen haben soll. Wir nutzen die Funktion iMA für das aktuelle Währungspaar auf dem Chart und die auf dem Chart ausgewählte Zeiteinheit um für unseren SmallMovingAverage ohne Verschiebung, mit MODE_SMA für SimpleMovingAverage den Wert auf Basis der Schlusskurse zu berechnen. Bitte beachten Sie, dass Mode SMA und PRICE_CLOSE jeweils in Großbuchstaben geschrieben wird. Das Ganze wiederholen wir dann noch mal für den BigMovingAverage. Im Großen und Ganzen ist diese Zeile identisch. Aber dieses Mal wird halt der BigMovingAverage Wert genutzt, den wir hier oben mit fünfzig initialisiert haben. Dadurch, dass das beides hier input Variablen sind, lässt sich das später im laufenden Betrieb noch verändern. Die vier hat hier nichts zu suchen. Im Anschluss nutzen wir CopyBuffer um anhand der SmallMovingAverage Definition, die wir hier oben getroffen haben, für Buffer null, also die einzige Linie, die wir in einem gleitenden Durchschnitt als Signal zur Verfügung haben, zu berechnen. Wir hätten gerne die Daten von der aktuellen Kerze null für drei Kerzen. Und das Ergebnis wird in unserem SmallMovingAverageArray gespeichert. Das Gleiche machen wir hier noch mal für das BigMovingAverageArray. Und jetzt können wir unser Einstiegssignal berechnen. Wenn der BigMovingAverageArray für Kerze eins > SmallMovingAverageArray für Kerze eins und der BigMovingAverageArray Wert für Kerze zwei noch < als für den SmallMovingAverage für Kerze zwei, dann haben wir eine Überkreuzung und möchten kaufen. Also weisen wir den Begriff Kaufen unserer Signal Variable zu. Das Ganze gibt es auch noch mal anders rum. Wenn der Wert für Kerze eins im BigMovingAverageArray < war als für Kerze eins im SmallMovingAverageArray und der BigMovingAverageArray Wert für Kerze zwei > war,