MQL5 Tutorial - Automatisch traden mit Metatrader5

In diesem Video wollen wir uns einmal anschauen, wie man einen Expert Advisor erstellen kann, der in der Lage ist, die Richtung der letzten geschlossenen Position zu ermitteln. Also lassen Sie uns einmal schauen, wie man so etwas mit MQL5 programmieren kann. Ich hoffe, dass ich dieses Video aufnehmen kann, bevor der Baulärm wieder losgeht. Um zu starten, klicken Sie bitte im Metatrader 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 Vorlage, weiter. Ich vergebe hier mal den Namen SimplerLastOrderTyp, 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 hier oben mit einer include-Anweisung für die Datei trade.mqh. Die enthält die Klasse CTrade von der wir uns hier eine Instanz mit dem Namen trade erstellen. In der OnTick-Funktion berechnen wir zunächst den Ask-Preis. Das übernimmt die Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart.   Wir nutzen SYMBOL_ASK und mit NormalizeDouble und _Digits stellen wir sicher, dass wir die richtige Anzahl von Nachkommastellen für das jeweilige Währungspaar ermitteln. Das wiederholen wir dann nochmal für den Bid-Preis. Diesmal nutzen wir SYMBOL_BID. Natürlich brauchen wir zur Ermittlung einer Positionsrichtung auch Positionen, also machen wir hier eine Position auf. Jeweils trade.Buy für einen Buy-Trade und trade.Sell für einen Sell-Trade. Natürlich würden man das hier nicht auf einem Echtgeldkonto machen, aber dafür sind Demokonten ja da. Zur Ermittlung der letzten Position möchten wir eine Funktion aufrufen. Die hat den Namen GetLastOrderType, existiert aber momentan noch nicht, denn die müssen wir gleich noch programmieren. Und das Ergebnis lassen wir uns dann mit einem Comment-Befehl auf dem Chart ausgeben. Dort wird dann stehen „Meine letzte Position war: “ und die ermittelte Positionsrichtung. Kommen wir jetzt aber zum interessanten Teil und das ist diese Funktion hier. Unsere selbsterstellte Funktion soll einen string, also eine Textkette zurückgeben und den Namen GetLastOrderType haben. Wir benötigen hier einige Variablen zur Ermittlung der Positionsdetails. Mit HistorySelect suchen wir uns jetzt einen Bereich heraus, den wir ermitteln möchten. Wir starten am Anfang bis zur aktuellen Zeit. Danach gehen wir mit Hilfe einer Vorschleife alle Deals durch. Innerhalb der Schleife ermitteln wir zunächst die Ticketnummer. Das geht mit HistoryDealGetTicket für den aktuellen Schleifenzähler. Gleichzeitig prüfen wir hier, ob diese Nummer größer ist als 0.   Wenn das der Fall ist, ermitteln wir den OrderProfit. Das übernimmt die Funktion HistoryDealGetDouble für die aktuelle Ticketnummer und als Parameter nutzen wir hier DEAL_PROFIT. Des Weiteren benötigen wir den Order-Typen. Der wird ermittelt mit Hilfe von HistoryDealGetInteger für die Ticketnummer und hier nutzen wir als Parameter DEAL_TYPE. Weiter geht es mit dem Währungspaar. Das bekommen wir über HistoryDealGetString für die aktuelle Ticketnummer und diesmal nutzen wir DEAL_SYMBOL. Außerdem brauchen wir den Typ für die Schließung. Den bekommen wir mit HistoryDealGetInteger für die Ticketnummer und diesmal nutzen wir DEAL_ENTRY. Jetzt prüfen wir noch, ob das Währungspaar zu unserem Währungspaar auf dem Chart passt und wir möchten noch wissen, ob der DealEntry den Wert 1 entspricht. Das ist nämlich der Fall, wenn eine Position geschlossen wurde. Wenn das der Fall war und die Schließung den Order-Typ ORDER_TYPE_BUY hatte, dann handelt es sich bei der ursprünglichen Position um einen Sell-Trade. War der Typ bei der Schließung aber ORDER_TYPE_SELL, dann wurde eine Buy-Position geschlossen. Jetzt weisen wir unserem Resultat hier noch die Ergebnisse für den OrderProfit, die Ticketnummer und die Richtung der Position zu.   Danach schließen wir unsere ganzen Schleifen und schlussendlich...

In diesem Video wollen wir uns einmal anschauen, wie man einen Trend auch von anderen Charts ermitteln und auf einem Chart anzeigen lassen kann. Also lassen Sie uns einmal schauen, wie man so etwas mit MQL5 umsetzt. Um das zu tun, klicken Sie bitten im Metatrader hier oben auf dieses kleine Symbol 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 SimplerMultiChartTrend, klicke auf weiter, weiter und fertigstellen. Jetzt kann alles oberhalb der OnTick-Funktion gelöscht werden und wir entfernen auch die zwei Kommentarzeilen.   Wir starten damit, dass wir uns zwei Signalvariablen erstellen. Einmal für das aktuelle Chart und einmal für das EUR/USD-Chart. Beide Variablen bekommen hier noch keine Werte zugewiesen. Außerdem brauchen wir zwei Arrays. Einmal für das aktuelle Chart für die Ermittlung eines Wertes von 20 Kerzen und ein zweites Array um das Ganze nochmal auf dem Chart für den EUR/USD zu ermitteln. Danach können wir die in MQL5 eingebaute Funktion iMA verwenden, um für das aktuelle Währungspaar auf dem Chart und die auf dem Chart ausgewählte aktuelle Zeiteinheit für 20 Kerzen einen Wert zu ermitteln. Wir nutzen hier keine Verschiebung.   Das Ergebnis soll für einen exponentiellen Moving Average ermittelt werden, darum nutzen wir hier MODE_EMA und das Ergebnis soll ermittelt werden anhand der Schlusskurse. Jetzt wiederholen wir das Ganze nochmal, mit einem kleinen Unterschied. Der Name der Variable hier ist anders. Und wir übergeben als ersten Parameter hartcodiert das Währungspaar, für das wir den Wert berechnen möchten. Je nachdem wie ihr Broker und ihr Konto eingerichtet sind, kann es sein, dass die Bezeichnung hier etwas anders aussieht. Darum stellen Sie bitte sicher, dass Sie das genauso abschreiben, wie das hier dargestellt wird. Alle anderen Parameter hier sind gleich. Jetzt nutzen wir ArraySetAsSeries um das Array für das aktuelle Währungspaar und das Array für den EUR/USD von der aktuellen Kerze an abwärts zu sortieren. Danach füllen wir beide Arrays mit Preisdaten, und zwar anhand der Definition, die wir hier oben getroffen haben, möchten wir für das aktuelle Chart für Buffer 0, also die einzige Signallinie, die unser exponentieller gleitender Durchschnitt hat, von der aktuellen Kerze 0 für 3 Kerzen die Daten in unser Array kopieren.   Das Ganze machen wir dann hier nochmal, diesmal für die Ermittlung des EUR/USD und jetzt können wir die Trendrichtung ermitteln, in dem wir überprüfen, ob der Wert für das EMA20Array für die Kerze 0 größer ist als für die Kerze 2. Das würde bedeuten, der Trend ist gestiegen. Und dann setzen wir das Signal für das aktuelle Chart auf buy, also auf Kaufen. Im umgekehrten Fall, wenn der EMA20Array für die aktuelle Kerze kleiner ist als der Wert für die Kerze 2 war, dann wäre das für uns ein Verkaufen-Signal und dann weisen wir den sell unserer Chartsignal-Variable zu. Genau so verfahren wir jetzt mit dem EUR/USD. Diesmal werden die Werte der zweiten Signalvariable zugewiesen. Und zum Schluss erstellen wir noch eine Chartausgabe. Das machen wir mit Hilfe des Comment-Befehls. Der wird uns für den EMA20 auf dem aktuellen Chart und für den EMA20 für den EUR/USD jeweils die Werte ausgeben. In den nächsten beiden Zeilen sehen wir dann den Trend für das aktuelle Chart und den aktuellen Trend für den EUR/USD auf dem anderen Chart. Und das war´s auch schon so weit.   Wenn Ihnen das hier zu schnell ging oder wenn Sie keine Ahnung haben, was alle diese Codezeilen hier bewirken sollen, dann möchten Sie sich vielleicht zunächst eines der anderen Videos aus der Grundlagenserie noch einmal anschauen. Vielleicht ist aber auch der Premiumkurs interessant für Sie. Den finden Sie auf unserer Webseite. Und das hier war wieder ein Beispiel von einer Frage, die ein Premiumkursmitglied gestellt hat. Und wenn Sie ebenfalls eine Idee für so ein Video haben und Premiummitglie...

In diesem Video wollen wir uns einmal anschauen, wie man einen Sell Trailing Stop für diesen Indikator hier programmieren kann. Es handelt sich um den Envelopes-Indikator. Also lassen Sie einmal schauen, wie man so etwas mit MQL5 programmieren kann. Um das zu tun, klicken Sie bitte im Metatrader hier oben auf dieses kleine Symbol 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 SimplerEnvelopesSellTrailingStop, klicke auf weiter, weiter und fertigstellen. Jetzt kann alles oberhalb der OnTick-Funktion gelöscht werden und auch die zwei Kommentarzeilen werden entfernt.   Wir starten hier mit einem include-Befehl für die Datei trade.mqh. Die ist Bestandteil von MQL5 und wir können darin von der Klasse CTrade eine Instanz mit dem Namen trade erstellen. Diese Instanz werden wir später nutzen, um eine Testposition zu eröffnen. Innerhalb der OnTick-Funktion starten wir damit, dass wir uns eine statische Variable vom Typ double erstellen. Die soll uns den letzten Stop Loss-Wert wieder zur Verfügung stellen, wenn die Funktion das nächste Mal aufgerufen wird. Danach berechnen wir den Ask Preis und Bid Preis. Das geht mit der Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Wir nutzen entweder SYMBOL_ASK oder SYMBOL_BID und mit NormalizeDouble und _Digits stellen wir sicher, dass jeweils die richtige Anzahl von Nachkommastellen hinter den Komma berechnet wird. Damit wir eine Trailing Stop auch anpassen können brauchen wir auch eine Position. Wir prüfen also im nächsten Schritt ob PositionsTotal uns einen Wert von kleiner 1 liefert. Wenn das der Fall ist, dann setzten wir hier unseren letzten Wert für den Stop Loss auf 0.   Danach eröffnen wir eine Testposition mit trade.Sell. Die Position soll 10 Microlot groß sein. Natürlich würden man diesen Schritt auf einem Echtgeldkonto überspringen, aber dafür sind Demokonto ja da. Weiter geht es. Wir benötigen jetzt jeweils ein Array für das obere und für das untere Band des Indikators. Danach nutzen wir ArraySetAsSeries, um das Array für das obere und für das untere Band von der aktuellen Kerze an abwärts zu sortieren und jetzt können wir die in MQL5 enthaltene Funktion iEnvelopes nutzen, um für das aktuelle Währungspaar und die auf dem Chat aktuell ausgewählte Zeiteinheit für 14 Kerzen den Wert des Indikators zu berechnen. Wir nutzen hier keinen Verschiebungswert. Dieser Parameter hier, MODE_SMA, steht für Simple Moving Average. Die Ergebnisse sollen anhand der Schlusskurse berechnet werden.   Und dieser Wert 0.100 den sieht man auch, wenn man auf einem leeren Chartfenster einmal auf Einfügen, Indikatoren, Tendenz, Envelopes klickt. Da ist der Wert. Es handelt sich um den Abweichungswert oder auf Englisch Deviation-Wert. Bitte übernehmen Sie hier alle grundlegenden Einstellungen, klicken auf OK. Jetzt erscheint der Indikator auf dem Chart und jetzt klicken wir mit der rechten Maustaste, wählen Vorlagen, Vorlage speichern und speichern das Ganze unter den Namen tester.tpl. Den alten Wert können Sie hier ersetzen. Tester.tpl ist die Schablone, die angezeigt wird, wenn wir einen Strategietest starten, aber zurück zum Programm. Mit CopyBuffer können wir uns jetzt anhand der Envelopes-Definition, die wir hier oben getroffen haben, entweder für Buffer 0 oder Buffer 1, das steht für das jeweilige Band, von der aktuellen Kerze 0 für drei Kerzen die Daten ins obere bzw. untere Band-Array kopieren. Das ermöglicht uns dann die Werte für die aktuelle Kerze zu ermitteln. Das hab ich hier aber mal auskommentiert, denn in diesem Fall interessiert uns eher die Kerze davor.   Das ist Kerze 1 und den Wert dafür erhalten wir, indem wir auf Kerze 1 im jeweiligen Array zugreifen. Ich hab hier noch NormalizeDouble und die Sechs genutzt, um die Wert auf sechs Nachkommastellen zu kürzen. Das ist nämlich auch das was wir angezeigt bekommen,

In diesem Video wollen wir einmal anhand dieses Indikators hier einen Buy Trailing Stop programmieren. Der vom Envelopes-Indikator gesteuert wird. Also lassen Sie uns einmal schauen, wie man so etwas mit MQL5 programmieren kann. Um das zu tun, klicken Sie bitte hier oben auf dieses kleine Symbol oder drücken Sie die F4-Taste im Metatrader. 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 SimplerEnvelopesBuyTrailingStop, 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 hier mit einem include-Befehl.   Der wird uns die Datei trade.mph importieren. Die ermöglicht es uns von der Klasse C-Trade eine Instanz mit dem Namen trade zu erstellen und die werden wir gleich nutzen, um eine Testposition zu eröffnen. In der OnTick-Funktion starten wir mit einer statischen Variable vom Typ double. Die soll den Wert für den letzten Stop-Loss speichern. Danach ermitteln wir den Ask-Preis und den Bid-Preis. Das geht über die Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Wir nutzen entweder SYMBOL_ASK oder SYMBOL_BID und mit NormalizeDouble und _Digits ermitteln wir automatisch wie viele Nachkommastellen das jeweilige Währungspaar hat. Damit wir einen Stop-Loss testen können müssen wir eine Testposition eröffnen.   Das macht man natürlich nur auf einem Demokonto und immer, wenn PositionsTotal uns einen Rückgabewert von kleiner 1 zurückgibt, dann bedeutet das, dass wir keine geöffnete Position haben. Und dann eröffnen wir hier mit trade.Buy eine Testposition über 10 Microlot. Direkt im Anschluss setzen wir den letzten Stop-Loss-Wert zurück, denn mit einer neuen Position muss der Stop-Loss natürlich auch neu berechnet werden. Für unseren Envelopes-Indikator brauchen wir zwei Arrays. Die erstellen wir hier und im Anschluss nutzen wir ArraySetAsSeries, um diese beiden Arrays von der aktuellen Kerze an abwärts zu sortieren. Danach nutzen wir die in MQL5 eingebaute Funktion iEnvelopes für das aktuelle Währungspaar auf dem Chart und die auf dem Chart ausgewählte Zeiteinheit, um den Indikatorwert für 14 Kerzen zu berechnen. Den Verschiebungswert setzen wir auf 0.   Wir nutzen MODE_SMA für Simple Moving Average. Das Ergebnis soll anhand der Schlusskurse berechnet werden und dieser letzte Parameter hier ist der sogenannte Diviation-Wert. Wenn Sie einmal ein leeres Chart öffnen und auf Einfügen, Indikatoren, Tendenz, Envelopes klicken, dann sehen Sie auch hier diesen Wert als Abweichung von 0.100. Wir übernehmen hier mal die Standardwerte, klicken auf OK, klicken mit der rechten Maustaste in das Chart, speichern diese Vorlage unter dem Namen tester.tpl, denn das ist die Vorlage, die wir gleich im Strategietester sehen werden. Den alten Wert können Sie hier getrost ersetzen. Weiter geht´s im Metaeditor mit dem Befehl CopyBuffer. Der wird uns anhand der Envelopes-Definition, die wir hier oben getroffen haben, die Daten für Buffer 0 und für Buffer 1 in das obere beziehungsweise in das untere Band kopieren. Wir starten jeweils mit Kerze 0 und kopieren uns Preisdaten für drei Kerzen. Um den aktuellen Wert zu berechnen, brauchen wir nur in Kerze  des jeweiligen Arrays hineinzuschauen. Mit NormalizeDouble und ,6 kürze ich das Ganze hier auf sechs Nachkommastellen.   Uns interessiert in diesem Fall eher die Kerze davor. Die Werte lassen sich ähnlich ermitteln. Hier schauen wir einfach auf den Wert von Kerze 1 und natürlich müssen wir auch den Namen der Variablen entsprechend anpassen. Weiter geht´s mit den Prüfkonditionen, denn wir möchten gerne wissen, ob der letzte Wert für das untere Band kleiner ist als der Bid-Preis. Als nächstes überprüfen wir, ob der Wert für das letzte untere Band größer ist als der Wert für unseren letzten Stop-Loss und wenn beide Bedingungen zutreffen,

In diesem Video wollen wir uns einmal anschauen, wie man einen Expert Advisor erstellen kann, der in der Lage ist, anhand von Preisdaten auf einem Line-Chart zu handeln. Also lassen Sie uns einmal schauen, wie man so etwas 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, neue Datei, Expert Advisor aus Vorlage, weiter. Ich vergebe hier einmal den Namen SimplerShiftedPriceEA, klicke auf weiter, weiter und fertigstellen. Jetzt kann hier alles oberhalb der OnTick-Funktion gelöscht werden und auch die zwei Kommentarzeilen werden entfernt. Wir starten mit einem include-Befehl für die Datei trade.mqh.   Die ist Teil von MQL5 und stellt vereinfachte Handelsfunktionen zur Verfügung. Um diese Funktionen nutzen zu können erstellen wir uns hier eine Instanz von der Klasse CTrade. Die bekommt den Namen trade. Innerhalb der OnTick-Funktion berechnen wir uns jetzt den Ask-Preis und den Bid-Preis. Das geht mit der Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. SYMBOL_ASK oder SYMBOL_BID liefert uns den jeweiligen Preis und mit NormalizeDouble und _Digits stellen wir sicher, dass die richtige Anzahl von Nachkommastellen für das jeweilige Währungspaar auch berechnet wird. Außerdem brauchen wir noch eine Variable für unser Signal. Hier weisen wir aber noch keinen Wert zu, denn den möchten wir gleich noch ermitteln. Mit der Funktion MqlRates erstellen wir uns jetzt ein Preis-Array für Preisinformationen.   Das wird mit der Funktion ArraySetAsSeries im Anschluss von der aktuellen Kerze an abwärts sortiert und mit CopyRates füllen wir unser Array für das aktuelle Währungspaar auf dem Chart und die aktuell ausgewählte Zeiteinheit, von der aktuellen Kerze 0, für drei Kerzen mit Daten, die wir hier im PriceInformation-Array speichern. Wir brauchen aber noch ein zweites Array und zwar für unseren MovingAverage. Und hier nutzen wir die Funktion iMA. Für das aktuelle Währungspaar auf dem Chart und die auf dem Chart ausgewählte Zeiteinheit möchte ich gerne einen SimpleMovingAverage für eine Kerze berechnen und die Ausgabe soll 20 Kerzen in die Zukunft verschoben werden. Wir nutzen MODE_SMA, das steht für SimpleMovingAverage und die Ergebnisse sollen anhand der Schlusskurse berechnet werden. Auch in diesem Fall nutzen wir ArraySetAsSeries, um unser Array von der aktuellen Kerze an abwärts zu sortieren. Mit CopyBuffer können wir jetzt unser Array mit Daten füllen.   Anhand der Definition, die wir hier oben getroffen haben, kopieren wir uns für Buffer 0, von der aktuellen Kerze 0, für drei Kerzen, die Daten und speichern sie uns in unserem Array. Und jetzt sind wir in der Lage, den aktuellen Wert für unser Array zu ermitteln. Dazu greifen wir einfach auf Kerze 0 in unserem MovingAverageArray zu und wenn der Wert den wir da ermitteln haben unter dem aktuellen Schlusskurs für Kerze 0 in unserem Preisinformations-Array liegt, dann ist das für uns ein Buy-Signal und dann weisen wir den Begriff Buy unserer Signalvariable zu. Andernfalls, wenn der aktuelle MovingAverage-Wert größer ist als der Schlusskurs für Kerze 0 in unserem Preisinformations-Array, dann wäre das ein Verkaufen-Signal und dann weisen wir den Begriff Sell unsere Signalvariable zu. Und wenn unser Signal auf Verkaufen steht und uns der Rückgabewert für PositionsTotal einen Wert kleiner 1 liefert, dann haben wir keine geöffneten Positionen, aber ein Sell-Signal. Und jetzt nutzen wir trade.Sell, um 10 Microlot zu verkaufen. Umgekehrt, wenn unser Signal auf Kaufen steht und wir ebenfalls keine geöffneten Positionen haben, dann nutzen wir hier trade.Buy, um 10 Microlot zu kaufen.   Zum Schluss gönnen wir uns noch mit dem Comment-Befehl eine Chartausgabe. Die wird uns den Text „Das aktuelle Signal ist jetzt:“ gefolgt von dem ermittelten Signal ausgeben. Das war´s soweit.

In diesem Video wollen wir uns einmal anschauen, wie man einen Expert Advisor programmieren kann, der Verkaufspositionen bei einem bestimmten, vom Benutzer definierten Wert, schließt. Also lassen Sie uns einmal schauen, wie man so etwas mit MQL programmiert.   Um das zu tun, klicken Sie bitte im Metatrader hier oben auf dieses kleine Symbol oder drücken Sie die F4-Taste. Das öffnet dann hier den Metaeditor und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, weiter. Ich vergebe hier mal den Namen SimplesSellPercentageRisiko, klicke auf weiter, weiter und fertigstellen. Jetzt kann hier alles oberhalb der OnTick-Funktion gelöscht werden und auch die zwei Kommentarzeilen werden entfernt. Wir starten hier mit einem include-Befehl. Die in MQL5 enthaltene Datei trade.mqh ermöglicht es uns vereinfachte Trading-Funktionen zu nutzen. Dazu erstellen wir uns zunächst einmal eine Instanz von der Klasse C-Trade. Die bekommt den Namen trade und wir werden sie später verwenden, um Testpositionen zu eröffnen. Außerdem hätte ich gerne eine input-Variable. Wenn man diesen input-Begriff einmal mit der Maus markiert und die F1-Taste drückt, dann sieht man, dass es sich um eine sogenannte Eingabevariable handelt.   Die können dann vom Benutzer im Fenster für die Eigenschaften des Expert Advisor geändert werden ohne dass man neu kompilieren muss. Die Variable ist vom Typ double, damit sie auch Nachkommastellen verarbeiten kann, und der Startwert sind 0,5 Prozent. Außerdem benötigen wir eine weitere Variable für den maximalen Verlust, den wir akzeptieren werden. Auch die ist vom Typ double. Innerhalb der OnTick-Funktion starten wir damit, dass wir den Bid-Preis berechnen. Das geht mit der Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Wir nutzen hier SYMBOL_BID, da wir den Bid-Preis benötigen. Und mit NormalizeDouble und _Digits stellen wir sicher, dass wir die richtige Anzahl von Nachkommastellen für das jeweilige Währungspaar automatisch berechnen. Jetzt holen wir uns noch die Account Balance. Das geht mit Hilfe der Funktion AccountInfoDouble. Als Parameter übergeben wir hier ACCOUNT_BALANCE. Wenn Sie das markieren und die F1-Taste drücken, dann werden Sie feststellen, dass man sich noch sehr viele andere Eigenschaften vom Konto anzeigen lassen kann. Uns interessiert hier aber nur das Bruttoguthaben.   Und damit wir eine Position schließen können, müsse wir Testpositionen eröffnen. Dazu prüfen wir, ob PositionsTotal einen Wert kleiner eins zurückliefert. Das würde bedeuten, wir haben keine geöffnete Position. Und dann nutzen wir hier trade.Sell, um eine Testposition für zehn Microlot zu eröffnen. Natürlich würden wir das nicht auf einem Echtgeldkonto machen, aber dafür sind Demokonten ja gut und ohne Positionseröffnung können wir auch nichts schließen. Auf dem Echtgeldkonto könnten Sie aber mehrere Positionen haben, darum gehen wir mit einer Vorschleife alle diese Positionen durch. Mit Hilfe von PositionGetTicket für den aktuellen Schleifenzähler ermitteln wir die Ticketnummer für die aktuelle Position. Den Profit kann man ermitteln, indem man PositionGetDouble nutzt. Hier übergeben wir POSITION_PROFIT. Auch da gibt es diverse Informationen, die man sich so ermitteln lassen kann. Wenn Sie es richtig machen wollen, dann müssen Sie den SWAP, also die Zinsen für das Halten von Positionen über Nacht auch mit im Profit ermitteln, aber für dieses einfache Beispiel soll uns das hier so reichen. Weiter geht’s mit der Berechnung für den maximalen Verlust, den wir erlauben möchten. Und um das zu berechnen, nehmen wir die Balance, also das Bruttoguthaben, teilen es durch 100, dann haben wir ein Prozent vom Bruttoguthaben. Dieses Prozent können wir dann mit dem benutzerdefinierten Wert multiplizieren, den der Expert Advisor vom Benutzer übergeben bekommt. Und falls Sie sich über diesen Teil hier wundern, damit kehren wir das Ganze ins Negative um, denn ein maximaler Positionsverlust ist ein negativer Wert.

In diesem Video wollen wir uns einmal anschauen, wie man einen Expert Advisor programmieren kann, der in der Lage ist, aufgrund von prozentuellen Verlustwerten Positionen zu schließen. Also lassen Sie uns einmal schauen, wie man so etwas in MQL5 programmieren kann. Um das zu tun, klicken Sie bitte im Metatrader hier oben auf dieses kleine Symbol 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 SimplesBuyPercentageRisiko, klicke auf weiter, weiter und fertigstellen. Jetzt kann hier alles oberhalb der OnTick-Funktion gelöscht werden und auch die zwei Kommentarzeilen werden entfernt.   Wir starten mit einem include-Befehl für die Datei trade.mqh. Die enthält die Klasse CTrade von der wir uns hier eine Instanz erstellen. Außerdem benötigen wir noch eine input-Variable vom Typ double für den Risikoprozentwert. Dieser Zusatz input wird es ermöglich, dass das der Benutzer ohne Neukompilierung verändern kann. Und wir brauchen noch eine Variable vom Typ double für den maximalen Positionsverlust, den wir erlauben. Innerhalb der OnTick-Funktion starten wir damit, dass wir zunächst den Ask-Preis berechnen. Das übernimmt die Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart und wir nutzen hier SYMBOL_ASK mit Hilfe von NormalizeDouble und _Digits stellen wir sicher, dass wir die richtige Anzahl von Nachkommastellen für das jeweilige Währungspaar automatisch berechnen. Im nächsten Schritt berechnen wir hier die Balance, also das Bruttoguthaben. Das übernimmt die Funktion AccountInfoDouble und hier übergeben wir als Parameter ACCOUNT_BALANCE.   Damit wir auch prüfen können, ob unser Expert Advisor funktioniert benötigen wir eine Testposition. Das macht man natürlich nur auf einem Demokonto. Falls wir also keine offene Position haben, dann nutzen wir hier trade.Buy um eine Testposition für zehn Microlot zu eröffnen. Es handelt sich hier um eine buy, also eine Kauf-Position. Kommen wir zum eigentlichen interessanten Teil. Wir gehen hier mit einer Vorschleife alle offenen Positionen durch. Für jede dieser gefundenen Positionen benutzen wir PositionGetTicket für den aktuellen Schleifenzähler, um die Ticketnummer für unsere Position zu ermitteln. Danach ermitteln wir mit PositionGetDouble den Profit der Position. Wenn man das einmal markiert und die F1-Taste drückt, dann sieht man, dass der Profit nicht den SWAP, also die Gebühren für das Halten einer Position über Nacht enthält. Falls sie längerfristig Positionen halten, sollten Sie das auch berücksichtigen. Für unser einfaches Beispiel soll das aber so reichen.   Jetzt berechnen wir den maximalen Positionsverlust. Wir nehmen unser Bruttoguthaben, also die Balance und teilen es durch 100. Das multiplizieren wir dann mit dem Wert den der Benutzer als Risiko eingegeben hat. Und falls Sie sich hier vorne über den Teil wundern, wir müssen das Ganze als negativen Wert berechnen, denn ein Verlust ist negativ. Danach baue ich hier noch zwei Print-Ausgaben ein. Die werden uns im Journal den Positionsprofit und den Wert für den maximalen Positionsverlust angeben. Denn immer, wenn der Positionsprofit niedriger ist als das was wir als maximalen Positionsverlust erlauben, dann nutzen wir trade.PositionClose, um unser jeweiliges Ticket zu schließen. Bitte vergessen Sie nicht die schließende Klammer hier für den Vorloop einzusetzen. Und zum Schluss gönnen wir uns noch eine Comment-Ausgabe. Die wird uns auf dem Chart den Wert für die Balance, den maximalen Positionsverlust und den prozentualen Risikowert ausgeben.   Das wars auch schon so weit. Wenn Ihnen das hier zu schnell ging oder wenn Sie keine Ahnung haben, was alle diese Codezeilen hier bedeuten, dann möchten Sie sich vielleicht zunächst eines der Grundlagenvideos noch einmal anschauen. Vielleicht ist aber auch der Premiumkurs interessant für Sie. Den finden Sie auf unserer Webseite.

In diesem Video wollen wir uns einmal anschauen, wie man für diesen Standard Deviation Indikator einen Expert Advisor erstellt, der in der Lage ist, anhand der letzten 200 Kerzen die Höchste und Niedrigste zu ermitteln. Also lassen Sie uns einmal schauen, wie man so etwas mit MQL5 programmieren kann. Um das zu tun, klicken Sie bitte im Metatrader hier oben auf dieses kleine Symbol 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 SimplerStandardDeviationEA, klicke auf weiter, weiter und fertigstellen. Jetzt kann hier alles oberhalb dieser OnTick-Funktion gelöscht werden und auch die zwei Kommentarzeilen werden entfernt. Wir starten mit einem include-Befehl. Damit können wir uns die Inhalte der Datei trade.mqh zu Nutze machen.   Die enthält auch die Klasse CTrade von der wir uns hier eine Instanz mit dem Namen trade erstellen. Die werden wir später nutzen, um Positionen zu eröffnen. Innerhalb der OnTick-Funktion starten wir damit, dass wir uns zunächst eine signal-Variable erstellen. Der weisen wir hier aber noch keinen Wert zu, denn den möchten wir gleich noch ermitteln. Dazu berechnen wir uns zunächst einmal den ask-Preis und den bid-Preis. Das übernimmt die Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart.   Wir nutzen entweder SYMBOL_ASK oder SYMBOL_BID und mit der Funktion NormalizeDouble und _Digits stellen wir sicher, dass wir die richtige Anzahl von Nachkommastellen berechnen. Je nach Währungspaar kann das dreistellig oder fünfstellig sein. Jetzt brauchen wir auch noch ein Array für unsere Preisdaten.   Das ist vom Typ double damit es auch Nachkommastellen aufnehmen kann und mit Hilfe der Funktion ArraySetAsSeries sortieren wir jetzt die Daten von der aktuellen Kerze an abwärts. Um unsere Werte zu ermitteln steht uns die Funktion iStdDev zur Verfügung. Die ist Bestandteil von MQL5 und benötigt einige Parameter. Und das sind das aktuelle Währungspaar auf dem Chart und die auf dem Chart eingestellte Zeiteinheit. Wir möchten das Ganze für 20 Kerzen berechnen, ohne einen Wert für die Verschiebung anzugeben.   Wir nutzen hier MODE_SMA für SimpleMovingAverage und die Ergebnisse sollen anhand er Schlusspreise berechnet werden. Mit Hilfe der Funktion CopyBuffer füllen wir jetzt unser Array anhand er Definition, die wir hier oben getroffen haben und zwar für Buffer 0. Angefangen von Kerze 0 für 200 Kerzen mit Werten. Das ermöglicht uns herauszufinden, welches die Nummer der höchsten Kerze ist.   Dazu nutzen wir die Funktion ArrayMaximum. Die wird in unserem Array suchen. Angefangen von Kerze 0 wird das ganze Array durchsucht und die Nummer der höchsten Kerze landet dann in dieser Variable. Das Ganze gibt’s natürlich dann auch noch in umgekehrter Form. Mit ArrayMinimum können wir die Nummer der niedrigsten Kerze ermitteln. Der Rest des Befehls ist hier identisch. Und damit wir den aktuellen Wert auf dem Chart ausgeben können, ermitteln wir den noch, indem wir uns den Wert von unserem Array für Kerze 0 holen. Der wird mit NormalizeDouble hier auf sechs Stellen verkürzt. Denn das ist auch das was uns der Indikator hier unten anzeigt.   Kommen wir zur Definition der Signale. Wenn unsere aktuelle Kerze 0 den niedrigsten Wert für unseren Indikator beinhaltet, dann ist das für uns ein Kaufen-Signal und dann setzen wir unser Signal hier auf buy. Andernfalls, wenn unsere aktuelle Kerze den höchsten Wert hat, dann ist das für uns ein Verkaufen-Signal und dann setzen wir unser Signal hier auf sell. Und so fern unser Signal auf verkaufen steht und uns der Rückgabewert von PositionsTotal einen Wert von <1 zurückliefert, dann bedeutet das wir haben keine offenen Positionen, aber ein verkaufen-Signal und dann nutzen wir trade.Sell, um zehn Microlot zu verkaufen.   Haben wir aber ein kaufen-Signal und ebenfalls keine geöffneten Positionen, dann nutzen wir hier trade.

In diesem Video wollen wir uns einmal anschauen, wie man eine Liste mit benutzerdefinierten Werten erstellen kann, die man hier als Einstellungen für den Expert Advisor auswählen kann, ohne dass der Benutzer das Programm neu Kompilieren muss. Also lassen Sie uns einmal schauen, wie man so etwas in MQL5 programmieren kann. Um das zu tun, klicken Sie bitte hier oben auf dieses kleine Symbol oder drücken Sie die F4 Taste auf Ihrer Tastatur. Das ruft hier dann den Metaeditor auf. Und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier den Namen SimplerMultipleInput, klicke auf Weiter, Weiter und Fertigstellen.   Jetzt kann alles oberhalb dieser OnTick Funktion hier gelöscht werden. Und auch die zwei Kommentarzeilen werden entfernt. Wir starten damit, dass wir uns hier eine Liste mit Einstiegssignalen erstellen. Dazu nutzen wir enum. Wenn man das markiert und die F1 Taste drückt, dann sehen wir, es handelt sich hier sogenannte Enumerationen. Das ist eine begrenzte Datenmenge. Zum Beispiel zwölf Monate. In unserem Fall möchten wir aber statt der Monate die entsprechenden Einstiegsmöglichkeiten verwenden. Und wir weisen hier jedem Einstieg gleichzeitig auch noch eine Zahl zu, denn auch das ist möglich. Danach erstellen wir eine Instanz von unserer Liste. Die bekommt den Namen Choice. Und mein Anfangswert soll hier ein zufälliger Einstieg sein, also RANDOM. Ich möchte das Ganze aber auch gerne etwas lesbarer gestalten. Und darum brauche ich eine zusätzliche Variable für den Einstieg als Textkette. Und in der OnTick Funktion setzen wir jetzt das Einstiegssignal.   Das lässt sich ganz einfach machen, indem wir hier auf den Wert für Choice prüfen. Und wenn Choice den Wert null hat, dann setzen wir unsere string Variable Entry hier auf den Wert RANDOM. Das Ganze wiederholen wir dann noch für die anderen Einstiegssignale. Und damit wir auch etwas sehen, fügen wir hier unten noch eine Comment Ausgabe hinzu. Die wird uns auf dem Chart die Werte für Entry und Choice ausgeben. Man könnte das Ganze jetzt hier weiter ergänzen und je nachdem, welchen Wert der Benutzer auswählt, bestimmte Funktionen aufrufen. In diesem kurzen Video soll es aber nur darum gehen, dass man so eine Enumerationsliste überhaupt nutzen kann. Und das war es auch schon so weit. Wenn Sie keine Ahnung haben, wofür alle diese Codezeilen hier gut sind oder wenn Ihnen das zu schnell ging, dann möchten Sie sich vielleicht zunächst eines der anderen Videos aus dieser Grundlagenserie noch einmal anschauen. Vielleicht ist auch der Premiumkurs interessant für Sie.   Den finden Sie auf unserer Webseite. Und dort gibt es jetzt auch für diese Quelltexte hier Angebote zu diesen Basiskursvideos. Für den Moment klicken wir mal auf Ansicht und blenden die Werkzeugleiste ein. Hier klicken wir dann auf Kompilieren oder drücken die F7 Taste. Das sollte ohne Fehler funktionieren. Und wenn das bei Ihnen auch so ist, dann können Sie jetzt hier oben klicken oder mit der F4 Taste in den Metatrader zurückkehren. Im Metatrader öffnen wir ein neues Chartfenster. Hier wählen wir jetzt die neu erstellte Datei SimplerMultipleInput aus, ziehen sie auf das Live Chart. Und wie man sieht, kommt hier direkt die Box mit den Einstellungen hoch. Diese Einstellungen können wir jetzt hier setzen. Und wenn wir auf Okay klicken, dann sehen wir auf dem Chart die Ausgabe.   Wir haben den EMA gewählt und das ist die Auswahlnummer eins. Jetzt wiederholen wir das Ganze nochmal, bestätigen mit Ja. Diesmal wähle ich hier ADX aus und klicke auf Okay. Und sobald die nächste Preisänderung hereinkommt sehen wir: der Entry steht auf ADX, Choice hat den Wert drei. Man kann das Ganze auch mit der F7 Taste wieder aufrufen und hier einen anderen Wert setzen.   Das war übrigens wieder eine Idee von einem Premiumkurs Mitglied. Und wenn Sie bereits Premiumkurs Mitglied sind und eine Idee für so ein Video haben, dann schreiben Sie mir doch einfach ein E-Mail.

In diesem Video wollen wir uns einmal anschauen, wie man diesen Indikator hier berechnen kann. Es handelt sich um sogenannte Fractale. Also lassen Sie uns einmal schauen, wie man das mit MQL5 automatisieren kann. Um das zu tun, klicken Sie bitte im Metatrader hier oben auf dieses kleine Symbol oder drücken Sie die F4 Taste. Das ruft hier dann den Metaeditor auf. Und hier klicken wir auf Datei, Neue Datei, Expert Advisor aus Vorlage, Weiter. Ich vergebe hier einmal den Namen SimplerFractalsEA, klicke auf Weiter, Weiter und Fertigstellen. Jetzt kann alles oberhalb dieser OnTick Funktion gelöscht werden.   Und auch die Kommentarzeilen werden entfernt. Wir starten damit, dass wir einen include Befehl nutzen, um die Datei Trade.mqh zu importieren. Das ermöglicht uns, von der Klasse CTrade eine Instanz mit dem Namen trade zu erstellen. Die werden wir gleich nutzen, um Positionen zu eröffnen. In der OnTick Funktion berechnen wir den Ask Preis und den Bid Preis. Das übernimmt die Funktion SymbolInfoDouble für das aktuelle Währungspaar auf dem Chart. Wir nutzen entweder SYMBOL_ASK oder SYMBOL_BID. Und mit NormalizeDouble und _Digits stellen wir sicher, dass automatisch die richtige Anzahl von Nachkommastellen für das jeweilige Währungspaar berechnet wird. Außerdem brauchen wir noch eine Variable für das Signal. Die ist vom Typ string, nimmt hier also Textketten auf. Wir weisen aber noch keinen Wert zu, denn den möchten wir gleich berechnen. Dazu brauchen wir ein Preis Array für die Preis Daten. Das erstellen wir mit Hilfe von MqlRates. Mit Hilfe von ArraySetAsSeries sortieren wir unser Preis Array jetzt von der aktuellen Kerze an abwärts.   Und mit CopyRates füllen wir es für das aktuelle Währungspaar auf dem Chart und die aktuelle Zeiteinheit auf diesem Chart. Wir sollten das aber immer gleich schreiben. Deswegen verwenden wir hier _Symbol und _Period. Wenn man das aber mal markiert und die F1 Taste drückt, dann sieht man, dass man das auch mit Klammern verwenden kann. Wir benötigen die Kerzen von Kerze null bis Kerze drei. Und speichern die Werte in unserem Preis Array ab. Wir starten mit Kerze null und benötigen die Daten für drei Kerzen, die wir in unserem Preis Array speichern. Jetzt brauchen wir noch zwei Arrays. Eins für das obere und eins für das untere Fractal. Und um die Werte zu ermitteln nutzen wir die Funktion iFractals für das aktuelle Währungspaar auf dem Chart und die aktuell auf dem Chart ausgewählte Zeiteinheit. Auch diese beiden Arrays sortieren wir wieder mit Hilfe von ArraySetAsSeries von der aktuellen Kerze an abwärts. Und jetzt füllen wir sie mit Werten.   Das geht mit der Funktion CopyBuffer. Anhand der Fractals Definition die wir hier oben getroffen haben, füllen wir für die obere Linie, angefangen von Kerze eins für drei Kerzen unser Fractal Array. Das gleiche wiederholen wir hier nochmal für das untere Fractal Array. Das ist ziemlich ähnlich, aber diesmal nutzen wir LOWER_LINE. Und auch der Name von unserem Array wird entsprechend angepasst. Das alles ermöglicht und jetzt, den Wert für die letzte Kerze zu ermitteln. Das bedeutet, wir schauen uns den Wert für Kerze eins in unserem UpperFractalsArray an. Um den oberen Wert zu berechnen beziehungsweise den Wert für Kerze eins in unserem LowerFractalsArray für den unteren Wert. Jetzt kommt eine kleine Besonderheit. Und zwar müssen wir unsere ermittelten Werte jetzt daraufhin prüfen, ob sie dem Wert EMPTY-VALUE entsprechen. Wenn das der Fall ist, dann setzen wir die jeweilige Variable hier auf null. Das machen wir hier auch für den unteren Wert. Denn, wenn das das der Fall ist, dann würden Sie auf dem Chart exponentielle Werte sehen. EMPTY-VALUE steht hier für einen leeren Wert im Indikatorpuffer. Jetzt können wir prüfen, ob unsere Einstiegsbedingungen erfüllt sind.   Denn wenn der Wert für das untere Fractal ungleich null ist und dieser Wert kleiner ist, als der niedrigste Preis für Kerze eins in unserem Preis Array, dann wäre das für uns ein buy Signal,