Implementierung des Deus EA: Automatisierter Handel mit RSI und gleitenden Durchschnitten in MQL5
11
0
Einführung
In diesem Artikel werden wir uns die wesentlichen Komponenten des Deus Expert Adviser (EA) ansehen, einschließlich seiner Handelslogik, der Parametereinstellungen und des MQL5-Codes, der für seine Implementierung erforderlich ist. Dieser Artikel soll Ihnen das Wissen und die Werkzeuge an die Hand geben, die Sie zur Entwicklung und Verbesserung Ihres Handelsalgorithmus benötigen. Durch den Einsatz des Deus EA können Sie die Welt des automatisierten Handels erkunden und neue Möglichkeiten für Ihre Handelsbemühungen entdecken.
Wir werden die Funktionalität von Deus EA untersuchen, einer automatisierten Handelstechnik, die auf MQL5 basiert. Unsere Diskussion wird sich darauf konzentrieren, wie Deus EA gleitende Durchschnitte und den Relative Strength Index (RSI) einbezieht, um Handelsentscheidungen zu treffen. Durch die Analyse dieser Indikatoren bestimmt der EA die besten Einstiegs- und Ausstiegspunkte im Markt, um die Handelsrentabilität zu maximieren und gleichzeitig das Risiko zu minimieren.
Der Deus EA ist ein automatisiertes Handelssystem, das für die MetaTrader5-Plattform entwickelt wurde und Kauf- und Verkaufssignale auf der Grundlage von gleitenden Durchschnitten und dem Relative Strength Index (RSI) erzeugt. Durch die Identifizierung von Markttrends und die Erkennung von überkauften oder überverkauften Bedingungen soll es Handelsentscheidungen verbessern. Darüber hinaus enthält es Risikomanagement-Tools wie Stop-Loss, Take-Profit und Trailing-Stops.
Deus EA Übersicht
Der Deus Expert Advisor (EA) stützt sich auf Indikatoren wie den Relative Strength Index (RSI) und die Gleitenden Durchschnitte, um Handelsentscheidungen zu automatisieren. Ziel dieses EA ist es, die Handelsperformance zu verbessern und das Risiko effektiv zu managen, indem diese Indikatoren genutzt werden, um umsetzbare Kauf- und Verkaufsempfehlungen zu erstellen.
Im Folgenden sind die wichtigsten Elemente des Deus EA aufgeführt:
- Technische Maßnahmen:
- Relative Stärke Index (RSI): Dieser Momentum-Oszillator misst, wie schnell und wie sich die Kurse bewegen, und hilft dabei, festzustellen, wann der Markt überkauft oder überverkauft ist, und schnell auf Marktbewegungen zu reagieren. In unserem Fall wird der EA einen kurzen 7-Tage-RSI-Zeitrahmen verwenden, wobei die Schwellenwerte auf 35 für überkaufte und 15 für überverkaufte Situationen festgelegt werden.
- Gleitende Durchschnitte (MA): Um Trends über einen bestimmten Zeitraum zu ermitteln, gleicht der gleitende Durchschnitt die Preisdaten aus. Wir werden im Deus EA einen einfachen gleitenden Durchschnitt (SMA) mit 25 Perioden verwenden, um Handelssignale zu filtern und die allgemeine Richtung des Marktes zu bestimmen.
- Kaufsignal: Wenn der Kurs über dem gleitenden Durchschnitt und der RSI im überverkauften Bereich (unter 15) liegt, weist das auf eine mögliche Aufwärtsbewegung des Kurses hin, und ein Kaufauftrag wird erteilt.
- Verkaufssignal: Wenn der Kurs unter dem gleitenden Durchschnitt und der RSI im überkauften Bereich (über 35) liegt, weist das auf eine mögliche Abwärtstrend des Kurses hin, und ein Verkaufsauftrag wird erteilt.
3. Risikomanagement:
- Stop-Loss und Take-Profit: Unser EA enthält anpassbare Parameter für die Stop-Loss-Ebenen und den Take-Profit, die jeweils auf 50 Punkte festgelegt sind, um das Risikomanagement zu unterstützen und Gewinne zu sichern.
- Trailing-Stop: Wir verwenden einen Trailing-Stop von 25 Punkten, um die Stop-Loss-Niveaus anzupassen, wenn sich der Kurs günstig entwickelt, um Gewinne zu sichern und gleichzeitig zu ermöglichen, dass der Handel offen bleibt, solange sich der Markt in die gewünschte Richtung bewegt.
4. Auftragsverwaltung:
- Position Management: Der EA stellt sicher, dass jeweils nur eine Position geöffnet ist, indem er auf der Grundlage der Handelssignale alle bestehenden Positionen schließt, bevor er eine neue eröffnet.
Der Deus EA verfügt über Funktionen zur Initialisierung, Tick-Verarbeitung, Positionseröffnung und -schließung sowie zur Anpassung des Trailing-Stops. Es ist in MQL5 implementiert, der Skriptsprache, die in MetaTrader5 verwendet wird. Die Programmierung stellt sicher, dass die Richtlinien für das Risikomanagement eingehalten und die Handelssignale effektiv gehandhabt werden.
Der Deus hilft dabei, Handelsabläufe zu automatisieren, emotionale Entscheidungen zu reduzieren und die Handelsergebnisse zu verbessern. Dieser Artikel soll eine Grundlage für das Verständnis der Designideen und der Funktionalität des Deus EA bieten.
Implementation in MQL5
Zunächst müssen wir Handelspositionen eröffnen. Wir beginnen den Prozess durch das Einbinden einer Datei, die der Behandlung von Positionen gewidmet ist.
#include <Trade\Trade.mqh>
CTrade trade; Hier verwenden wir die Include-Datei, um die Handelsbibliothek einzubinden. Dies ermöglicht dem Deus EA den Zugriff auf Funktionen für Handelsoperationen. An dieser Stelle definieren wir auch die Klasse CTrade, die ein hohes Niveau für die Durchführung von Handelsaktivitäten bietet. Der EA kann die CTrade-Klasse zur Verwaltung der Handelsgeschäfte verwenden, da diese Datei enthalten ist. Im Verlauf des EA wird dieses Objekt zur Durchführung verschiedener Handelsaufgaben verwendet, einschließlich des Öffnens, Änderns und Schließens von Positionen.
In diesem Abschnitt befassen wir uns mit den entscheidenden Eingabeparametern des Deus EA. Deus EA ist ein komplexer Handelsalgorithmus, der den gleitenden Durchschnitt und den RSI-Indikator verwendet, um Handelsmöglichkeiten zu finden. Durch die Anpassung dieser Parameter können Händler das Verhalten des EA so gestalten, wie es am besten zu ihrer individuellen Handelstaktik und Risikotoleranz passt.
Die Eingabeparameter lauten wie folgt:
input double Lots = 0.1; // Lot size input double StopLoss = 50; // Stop loss in points input double TakeProfit = 50; // Take profit in points input double TrailingStop = 25; // Trailing stop in points
- Lots (Handelsvolumen)
input double Lots = 0.1; // Lot size
Die Volumensgröße der einzelnen Handelsgeschäfte wird durch die Option Lots festgelegt. Der EA ist in diesem Fall so konfiguriert, dass er in jeder Transaktion 0,1 Lots handelt. Händler können ihr Marktrisiko durch Variation der Losgröße steuern. Eine kleinere Losgröße senkt sowohl die möglichen Risiken als auch die Gewinne, während eine größere Losgröße nicht nur die möglichen Gewinne erhöht, sondern auch die Risiken. Um Risiken und Gewinne auszugleichen, ist die Wahl des richtigen Loses entscheidend.
2. StopLoss(Stop-Loss in Punkten)
input double StopLoss = 50; // Stop loss in points
Der maximal zulässige Verlust pro Handel wird durch die Option StopLoss definiert und ist in unserem Fall auf 50 Punkte festgelegt. Um künftige Verluste zu verhindern, wird die Position automatisch geschlossen, wenn der Markt bei einer Bewegung gegen der Position diesen Punkt berührt oder kreuzt. Dies wird Ihr Handelskonto vor großen Verlusten schützen.
3. TakeProfit(Take-Profit in Punkten)
input double TakeProfit = 50; // Take profit in points
Wir setzen unser Gewinnziel für jede Transaktion über den Parameter TakeProfit auf 50 Punkte. Um Gewinne zu sichern, wird die Position automatisch geschlossen, wenn sich der Markt um diesen Betrag zu Gunsten des Handels bewegt. Dadurch werden die Gewinne vor einer möglichen Umkehrung der Marktbedingungen gesichert und die Rentabilität erhöht.
4. TrailingStop (Punkte, an denen Trailing-Stops gesetzt werden)
input double TrailingStop = 25; // Trailing stop in points
Mit dem Parameter TrailingStop führen wir einen Stop-Loss ein, der sich in Richtung der Position verschiebt. Wenn sich der Markt zu Gunsten des Trades entwickelt, wird der Trailing-Stop, der anfänglich auf 25 Punkte vom Einstiegskurs festgelegt ist, angepasst, um die Gewinne zu sichern. Diese Funktion hilft den Händlern, von längeren Marktschwankungen zu profitieren und gleichzeitig ihre Gewinne zu sichern.
Die Parameter des RSI-Indikators:
input int RSI_Period = 7; // RSI period input double RSI_Overbought = 35.0; // RSI overbought level input double RSI_Oversold = 15.0; // RSI oversold level
5.RSI_Period(RSI-Berechnungszeitraum)
input int RSI_Period = 7; // RSI period
Die Anzahl der Perioden, die für die Generierung des Relative Strength Index (RSI) verwendet werden, wird durch den Parameter RSI_ period festgelegt, in unserem Fall ist er auf 7 eingestellt. Ein Momentum-Oszillator, der die Geschwindigkeit und die Schwankungen der Kursbewegungen misst, ist der RSI. Der RSI reagiert stärker auf die jüngsten Kursbewegungen über einen kurzen Zeitraum, z. B. 7, was hilfreich ist, um überkaufte oder überverkaufte Situationen schnell zu erkennen.
6. RSI_Overbought(RSI überkauftes Niveau)
input double RSI_Overbought = 35.0;
Der Schwellenwert für die Bestimmung des überkauften Zustands wird durch den Parameter RSI_Overbought definiert, der auf 35,0 festgelegt ist. Im Allgemeinen könnte ein überkauftes Niveau bei 70 liegen, aber mit dieser Technik bedeutet 35,0 eine aggressivere Verkaufsposition. Der EA löst eine Verkaufsaktion aus, wenn der RSI über diesem Schwellenwert liegt, was darauf hindeutet, dass eine Marktumkehr nach unten bevorstehen könnte.
7. RSI_Oversold(RSI überverkaufte Niveaus)
input double RSI_Oversold = 15.0; // RSI oversold level
Der Schwellenwert für die Überverkaufsbedingung wird durch den Parameter RSI_Oversold definiert, der einen Wert von 15,0 hat. Obwohl bei diesem Ansatz ein konservativeres Niveau verwendet wird, um mögliche Kaufgelegenheiten anzuzeigen, könnte ein typisches überverkauftes Niveau bei dreißig liegen. Der EA löst eine Kaufaktion aus, wenn der RSI unter diese Schwelle fällt, weil er eine mögliche Marktumkehr nach oben erkennt.
Parameter des gleitenden Durchschnitts
input int MA_Period = 25; // Moving Average period input ENUM_MA_METHOD MA_Method = MODE_SMA; // Moving Average method input ENUM_APPLIED_PRICE MA_Price = PRICE_CLOSE; // Applied price for MA
8. MA_Period(Zeitraum für den gleitenden Durchschnitt)
input int MA_Period = 25; // Moving Average period
Der Berechnungszeitraum des gleitenden Durchschnitts (MA) wird durch den Parameter MA_Period bestimmt, der den Wert 25 hat. Die Preisdaten werden durch den MA geglättet, um Trends zu erkennen. Ein 25-Perioden-Fenster bietet eine abgerundete Perspektive auf Markttrends, da es nicht nur kurzfristige Störungen beseitigt, sondern auch auf bemerkenswerte Preisänderungen reagiert.
9. MA_Methode(Methode des gleitenden Durchschnitts)
Moving Average period input ENUM_MA_METHOD MA_Method = MODE_SMA; // Moving Average method
Der Typ des gleitenden Durchschnitts, der in diesem Fall verwendet wird, der einfache gleitende Durchschnitt (SMA), wird durch die Option MA_Method bestimmt. Der SMA ist ein einfacher Trendindikator, der den Durchschnitt der Schlusskurse in einem bestimmten Zeitraum berechnet. Für unterschiedliche Empfindlichkeiten könnten alternative Techniken wie der Exponential Moving Average (EMA) verwendet werden, aber der einfache gleitende Durchschnitt (SMA) ist ein zuverlässiger und beständiger Trendindikator.
10. MA_Preis(Auf den MA angewandter Preis)
input ENUM_APPLIED_PRICE MA_Price = PRICE_CLOSE; // Applied price for MA
Der Preistyp, der für die Berechnung des gleitenden Durchschnitts verwendet wird, wird durch die Option MA_Price festgelegt, die auf den Preis PRICE_CLOSE gesetzt ist. Dies bedeutet, dass der MA anhand von Schlusskursen ermittelt wird, die häufig verwendet werden, da sie den Schlusskurs einer Handelssitzung darstellen. Durch diese Entscheidung ist gewährleistet, dass der MA einen verlässlichen Hinweis auf die allgemeine Marktentwicklung gibt.
Das Handelsverhalten und das Risikomanagement des Deus EA werden weitgehend durch seine Eingabeparameter bestimmt. Händler können den EA an ihre individuellen Handelsziele und die aktuellen Marktbedingungen anpassen, indem sie diese Parameter wie Handelsvolumen, Risikokontrollen, Indikatorlaufzeiten und Schwellenwerte anpassen. Um den Deus EA im automatischen Handel voll nutzen zu können, ist es wichtig, diese Einstellungen zu verstehen und entsprechend zu ändern.
Anschließend diskutieren wir unsere neuen EA-Variablen, die auf den Indikatoren Gleitender Durchschnitt und RSI basieren. Wenn wir diese Faktoren verstehen, können wir wissen, wie der EA die Handelsausführung handhabt und die Marktdaten analysiert.
//--- Variables double rsiValue; // RSI value double maValue; // Moving Average value double Ask; double Bid; double Close; // Initializing Close array with two elements
Der RSI-Wert:
double rsiValue; // RSI value
Der aktuelle Wert des Relative Strength Index (RSI) wird in der Variablen rsiValue gespeichert. Als Momentum-Oszillator hilft der RSI dabei, festzustellen, ob der Markt überkauft oder überverkauft ist, indem er die Geschwindigkeit und die Schwankungen der Kursänderungen berechnet.
Zur Bestimmung des RSI-Wertes werden der Preistyp und die festgelegte RSI-Periode verwendet. Die nutzerdefinierten Parameter und die aktuellsten Kursdaten werden von Deus EA zur Berechnung des RSI verwendet.
Wenn der RSI-Wert unter den RSI_Oversold-Wert fällt, interpretiert der EA dies als Kaufsignal. Dies deutet darauf hin, dass der Markt überverkauft sein könnte und eine Umkehr nach oben vollziehen könnte.
Steigt der RSI-Wert hingegen über das RSI_Overbought-Niveau, handelt es sich um ein Verkaufssignal. Dies bedeutet, dass der Markt möglicherweise überkauft ist und einen Rückschlag erleiden könnte.
Der Wert des gleitenden Durchschnitts:
double maValue; // Moving Average value
Der aktuelle Wert des gleitenden Durchschnitts (MA) wird in der Variablen maValue gespeichert. Durch die Glättung der Kursdaten über einen vorgegebenen Zeitrahmen erleichtert dieser Indikator die Trenderkennung.
Der gleitende Durchschnitt wird anhand der Technik, des Preistyps und des ausgewählten Zeitraums berechnet. Der Schlusskurs des angegebenen Zeitraums wird zur Berechnung des MA in unserem EA verwendet.
Tendenz: Der derzeitige Markttrend wird durch den MA-Wert unterstützt. Wenn der Kurs über dem MA liegt, glaubt der EA, dass sich der Markt in einem Aufwärtstrend befindet, und wenn er unter dem MA liegt, glaubt er, dass sich der Markt in einem Abwärtstrend befindet.
Eröffnungssignal: Die Erzeugung von Handelssignalen hängt von der Beziehung zwischen dem RSI und den MA-Werten ab. Wenn z. B. der vorherige Schlusskurs über dem MA-Wert lag und der RSI unter dem RSI_Oversold-Level liegt, wird ein Kaufsignal als legitim angesehen. Die RSI- und MA-Werte werden im Deus EA kombiniert, um ihm zu helfen, kluge Handelsentscheidungen zu treffen.
double Ask; Der aktuelle Briefkurs des Vermögenswerts wird in der Variablen ask gespeichert. Dies ist der Kaufpreis des Vermögenswerts für Händler. Sie legt den Einstiegspreis für Kaufaufträge in der Funktion OpenPosition fest. Die Preisvorstellung ist der höchste Preis, der zu diesem Zeitpunkt für den Kauf des Vermögenswertes erzielt werden kann. Die genaue Überwachung dieser Kosten gewährleistet, dass die Bestellungen ordnungsgemäß eingereicht werden.
double Bid; Der aktuelle Geldkurs des Vermögenswerts wird in der Variablen Bid erfasst. Dies ist der Verkaufspreis des Vermögenswerts für Händler. Sie legt den Einstiegspreis für Verkaufsaufträge in der Funktion OpenPosition fest. Der beste Preis, der für den Verkauf des Vermögenswerts erzielt werden kann, spiegelt sich im Geldkurs wider.
double Close[]; Der Schlusskurs des Vermögenswertes für einen bestimmten Zeitraum wird im Array Close gespeichert. Er wird in diesem EA vergrößert, um Werte für die aktuellste Verwendung zu speichern. Das Array wird zur Erzeugung von Handelssignalen und zur Analyse von Kursbewegungen verwendet. Um zu entscheiden, ob es sich um ein Kauf- oder Verkaufssignal handelt, wird der Wert mit den Schlusskursen des letzten (Close[1]) und des aktuellen Balkens (Close[0]) verglichen. Anhand dieses Vergleichs können wir feststellen, ob sich der Preis nach oben oder nach unten bewegt.
void ApplyTrailingStop(); Diese Funktion hilft bei der Implementierung eines Trailing-Stop-Mechanismus. Wenn sich der aktuelle Marktpreis zu Gunsten des Stop-Loss der Position bewegt, durchläuft die Funktion alle offenen Positionen und ändert den Stop-Loss. Diese Funktion stellt sicher, dass der Stop-Loss an der günstigsten Position bleibt, auch wenn sich der Marktpreis gegen den Handel verändert, indem ein Trailing-Stop gesetzt wird.
void OpenPosition(CTrade trade, int orderType);
Je nach Auftragsart ist diese Methode für die Eröffnung neuer Handelspositionen vorgesehen. Die Funktion bestimmt den Take-Profit, den Stop-Loss und den Einstiegskurs auf der Grundlage des Auftragstyps. Die Transaktion wird mit Hilfe von berechneten Parametern unter Verwendung des CTrade-Objekts durchgeführt. Dies wird dem EA helfen, Signale zu generieren, die für die Aufnahme von Handelsgeschäften auf dem Markt von entscheidender Bedeutung sein können.
void ClosePositions(int orderType);
Mit dieser Funktion werden die Handelspositionen einer bestimmten Auftragsart geschlossen. Alle offenen Positionen werden durchlaufen, und diejenigen, die dem angegebenen Auftragstyp entsprechen, werden von der Funktion geschlossen. Dies wird dazu beitragen, Positionen zu eliminieren, die nicht mehr zur Handelsstrategie oder zur Marktlage passen, und somit das Handelsmanagement verbessern.
//--- Function prototypes void ApplyTrailingStop(); void OpenPosition(CTrade trade, int orderType);
Anschließend kombinieren wir diese Funktionsprototypen, um dem EA die Fähigkeit zu verleihen, Handelspositionen effektiv zu verwalten. Die Methode OpenPosition startet die Handelsgeschäfte auf der Grundlage der Marktbedingungen, die ClosePositions-Funktion kontrolliert und schließt sie nach Bedarf, und die ApplyTrailingStop-Funktion verbessert das Handelsmanagement, indem sie die Stop-Losses modifiziert. Alle diese Funktionen zusammen ermöglichen es dem EA, schnell auf Marktveränderungen zu reagieren und Trades effektiv durchzuführen.
Gehen wir nun zur Funktion OnInit über. Der Deus EA verwendet die Funktion OnInit, um den Handel zu starten. Es ist dazu gedacht, den Handel auf der Grundlage der Indikatoren Gleitender Durchschnitt und RSI zu tätigen.
//+------------------------------------------------------------------+ //| Expert initialization function . | //+------------------------------------------------------------------+ int OnInit() { Print("Zeus EA initialized successfully."); return(INIT_SUCCEEDED); }
Wenn das Terminal startet oder der EA in einen Chart geladen wird, wird die OnInit-Funktion einmal aufgerufen. Initialisierung von Variablen, Einrichtung von Indikator-Handles und Durchführung aller anderen Konfigurationsoperationen, die die Verwendung dieser Funktion erfordern. Dann zerlegen wir die Teile wie folgt:
Print("Zeus EA initialized successfully.");
Das Ziel dieser Codezeile ist es, die Meldung über den erfolgreichen Abschluss der Initialisierung in das Protokoll des Expert Advisors (EA) zu drucken. Ein wesentlicher Bestandteil jedes EA ist die Protokollierung. So können wir überprüfen, ob der EA ohne Probleme geladen und initialisiert wurde. Sie ist auch hilfreich bei der Fehlersuche und um sicherzustellen, dass der EA bereit ist, Marktdaten zu verarbeiten und Trades auszuführen.
return(INIT_SUCCEEDED); }
Der Rückgabewert (INIT_SUCCEEDED); die Anweisung dient dazu, der MetaTrader-Plattform mitzuteilen, dass der Initialisierungsprozess abgeschlossen ist. Der EA muss INIT_SUCCEEDED zurückgeben, um zu den nächsten Schritten überzugehen, wie die OnTick-Funktion, in der die Haupt-Handelslogik ausgeführt wird. Wenn die Initialisierung aus irgendeinem Grund fehlgeschlagen ist, kann die Funktion INIT_FAILED zurückgeben, wodurch der Betrieb des EA gestoppt und mögliche Fehler während des Betriebs vermieden werden.
Danach sehen wir uns die Funktion OnDeinit an. Diese Funktion ist entscheidend für die Erhaltung der Zuverlässigkeit und Integrität Ihres EA. Wir werden die Rolle dieser Funktion diskutieren. Wenn ein EA neu kompiliert wird, wird er aus dem Chart entfernt. Diese Aktion aktiviert die Funktion OnDinit und bietet ihr die Möglichkeit, Aufräumarbeiten durchzuführen und sicherzustellen, dass die Ressourcen ordnungsgemäß freigegeben und die letzten Schritte abgeschlossen werden.
//+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { Print("Zeus EA deinitialized. Reason: ", reason); }
Der Grund für die Deinitialisierung wird über den Parameter reason in der Funktion OnDeinit angegeben. Dies kann bei der Fehlersuche helfen und herausfinden, warum der EA deinitialisiert wurde. Wir verwenden die Druckfunktion in Deus EA, um diesen Grund zu protokollieren.
void OnDeinit(const int reason) { Print("Zeus EA deinitialized. Reason: ", reason); }
Anhand dieses einfachen Protokolls, das in der Entwicklungs- und Testphase aufschlussreiche Informationen liefern kann, können Sie feststellen, ob der EA explizit entfernt oder neu kompiliert wurde oder ob er durch das Herunterfahren des Terminals entstanden ist.
Obwohl der Deinitialisierungsgrund der einzige ist, den unsere aktuelle OnDeinit-Implementierung protokolliert, kann diese Funktion auf alle notwendigen Bereinigungsverfahren erweitert werden. So müssen Sie beispielsweise offene Ressourcen schließen, Datei-Handles freigeben oder den aktuellen Zustand speichern. Ressourcenlecks können vermieden werden, und eine saubere Reinitialisierung des EA kann bei ordnungsgemäßer Bereinigung gewährleistet werden. Dies ist beim Echtzeithandel von entscheidender Bedeutung, wenn Zuverlässigkeit und Stabilität entscheidend sind. Die korrekte Handhabung garantiert, dass Leistungsprobleme aus früheren Läufen die Fähigkeit des EA, neu zu laden oder neu zu starten, nicht beeinträchtigen.
Wir gehen nun zur OnTick-Funktion über, die für den Echtzeit-Entscheidungsprozess des EA unerlässlich ist. Jedes Mal, wenn ein neuer Preistick empfangen wird, wird diese Funktion aufgerufen, die dem EA die Möglichkeit gibt, den Zustand des Marktes zu bewerten und Transaktionen mit Hilfe vorher festgelegter Techniken auszuführen. Hier sind die Hauptfunktionen der OnTick-Funktion und wie sie die Strategiekomponenten des Deus EA kombiniert:
- Beschaffung von Marktinformationen;
Wenn die OnTick-Funktion zum ersten Mal startet, hilft sie dabei, die meisten Marktdaten zu erhalten.
Ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK); Bid = SymbolInfoDouble(_Symbol, SYMBOL_BID); ArrayResize(Close, 2); Close[0] = iClose(_Symbol, _Period, 0); Close[1] = iClose(_Symbol, _Period, 1);
Dieser Code speichert die letzten Schlusskurse und ermittelt die Geld- und Briefkurse. Um sicherzustellen, dass das Close-Array genügend Platz zum Speichern des letzten Schlusskurses hat, wird ArrayResize verwendet.
- Berechnung des technischen Indikators;
Der gleitende Durchschnitt und der Index der relativen Stärke werden vom Algorithmus errechnet.
//--- Calculate RSI value rsiValue = iRSI(_Symbol, _Period, RSI_Period, PRICE_CLOSE, 0); if (rsiValue == WRONG_VALUE) { Print("Error calculating RSI"); return; } //--- Calculate Moving Average value maValue = iMA(_Symbol, _Period, MA_Period, 0, MA_Method, MA_Price, 0); if (maValue == WRONG_VALUE) { Print("Error calculating Moving Average"); return; }
Während der MA-Wert bei der Bestimmung der Trendrichtung hilft, zeigt der RSI-Wert die überkauften oder überverkauften Bedingungen an. Vergewissern Sie sich, dass die Zahlen korrekt sind, bevor Sie die Kontrollen fortsetzen.
- Generierung von Handelssignalen: Nach der Berechnung der Indikatoren sucht die Funktion nach Kauf- und Verkaufssignalen:
//--- Check for Buy Signal if(rsiValue < RSI_Oversold && Close[1] > maValue) { if(PositionsTotal() == 0) { ClosePositions(ORDER_TYPE_SELL); OpenPosition(ORDER_TYPE_BUY); } } //--- Check for Sell Signal if(rsiValue > RSI_Overbought && Close[1] < maValue) { if(PositionsTotal() == 0) { ClosePositions(ORDER_TYPE_BUY); OpenPosition(ORDER_TYPE_SELL); } }
Ein Kaufsignal wird ausgegeben, wenn der aktuelle Schlusskurs über dem gleitenden Durchschnitt liegt und der RSI unter dem überverkauften Schwellenwert liegt. Diese Situation deutet auf einen möglichen Umschwung nach oben hin.
Ein Verkaufssignal wird ausgelöst, wenn der Schlusskurs unter dem gleitenden Durchschnitt und der RSI über der überkauften Schwelle liegt. Diese Situation deutet auf eine mögliche Umkehr nach unten hin.
- Anwendung von Trailing-Stop. Um Verluste zu minimieren und Gewinne zu sichern, enthält die OnTick-Funktion die Logik zur Anwendung von Trailing-Stop.
//--- Apply trailing stop if specified if (TrailingStop > 0) { ApplyTrailingStop(); }
Wenn der Parameter des Trailing-Stop eingestellt ist, stellt dieser Abschnitt sicher, dass der Trailing-Mechanismus aktiviert ist. Um Gewinne zu sichern, ändert die Funktion ApplyTrailingStop das Stop-Loss-Niveau, wenn sich der Kurs in die gewünschte Richtung bewegt.
- Öffnen und Schließen von Positionen: Anhand der Eröffnungsposition versucht die Funktion OpenPosition, eine Position zu eröffnen, nachdem der Einstiegskurs, der Stop-Loss und der Take-Profit-Level bestimmt wurden. Abschlussposition; alle Positionen werden von der Funktion ClosePositions durchlaufen, die diejenigen schließt, die der angegebenen Auftragsart entsprechen.
Hier wird erklärt, wie sich der Deus EA dynamisch an Marktsituationen anpasst, indem die OnTick-Funktion erläutert wird. Diese Funktion verwendet den RSI- und den MA-Indikator, um Handelssignale und Trailing-Stops zur Gewinnsicherung zu erzeugen. Mit dieser Strategie ist gewährleistet, dass der EA die Gewinne schützt und auch auf Marktveränderungen reagiert. Nachstehend finden Sie den vollständigen Code der Funktion OnTick:
//+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { Ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK); Bid = SymbolInfoDouble(_Symbol, SYMBOL_BID); ArrayResize(Close, 2); Close[0] = iClose(_Symbol, _Period, 0); Close[1] = iClose(_Symbol, _Period, 1); //--- Calculate RSI value rsiValue = iRSI(_Symbol, _Period, RSI_Period, PRICE_CLOSE, 0); if (rsiValue == WRONG_VALUE) { Print("Error calculating RSI"); return; } //--- Calculate Moving Average value maValue = iMA(_Symbol, _Period, MA_Period, 0, MA_Method, MA_Price, 0); if (maValue == WRONG_VALUE) { Print("Error calculating Moving Average"); return; } //--- Check for Buy Signal if(rsiValue < RSI_Oversold && Close[1] > maValue) { if(PositionsTotal() == 0) { ClosePositions(ORDER_TYPE_SELL); OpenPosition(ORDER_TYPE_BUY); } } //--- Check for Sell Signal if(rsiValue > RSI_Overbought && Close[1] < maValue) { if(PositionsTotal() == 0) { ClosePositions(ORDER_TYPE_BUY); OpenPosition(ORDER_TYPE_SELL); } } //--- Apply trailing stop if specified if (TrailingStop > 0) { ApplyTrailingStop(); }
Da wir mit der OnTick-Funktion fertig sind, können wir uns nun frei mit den Utility-Funktionen unseres EA beschäftigen. Damit der Deus EA einen Handel auf der Grundlage von Signalen der Indikatoren RSI und Gleitender Durchschnitt ausführen kann, ist die Funktion OpenPosition() für das Öffnen unerlässlich. Mit dieser Funktion wird sichergestellt, dass die Kauf- und Verkaufsaufträge unter Berücksichtigung von Risikomanagementfaktoren präzise platziert werden.
void OpenPosition(int orderType)
Die Art des zu erteilenden Auftrags wird durch den einzigen Parameter, den Auftragstyp, bestimmt, den die Funktion OpenPosition akzeptiert. Bei Kauf- und Verkaufsaufträgen kann dies ORDER_TYPE_BUY bzw. ORDER_TYPE_SELL sein. Die Auftragsart bestimmt den Auftragspreis innerhalb der Funktion.
double price = (orderType == ORDER_TYPE_BUY) ? Ask : Bid;
Bei einem Kaufauftrag wird der {Ask}-Preis verwendet, bei einem Verkaufsauftrag der {Bid}-Preis.
Um das Risiko zu kontrollieren und Gewinne zu sichern, werden Stop-Loss (SL) und Take-Profit (TP) Schwellenwerte festgelegt:
double sl = (orderType == ORDER_TYPE_BUY) ? price - StopLoss * _Point : price + StopLoss * _Point; double tp = (orderType == ORDER_TYPE_BUY) ? price + TakeProfit * _Point : price - TakeProfit * _Point;
Bei Kaufaufträgen wird der Take-Profit über den Auftragskurs und der Stop-Loss darunter gesetzt. Der Take-Profit und der Stop-Loss für Verkaufsaufträge werden unterhalb bzw. oberhalb des Auftragskurses platziert. Die Funktion PositionOpen aus der Klasse CTrade wird verwendet, um die echte Position zu öffnen:
bool result = trade.PositionOpen(_Symbol, orderType, Lots, price, sl, tp, "Zeus EA");
Diese Technik erfordert mehrere Parameter:
- -{ Symbol}: Das für den Handel verwendete Symbol, z. B. EURUSD.
- -{ orderType}: Die Art des Auftrags (Verkauf oder Kauf).
- -"Lots": Die Losgröße des Auftrags.
- -{price}: Der Geld- oder Briefkurs des Auftrags.
- -{sI}: Das Niveau der Stop-Loss-Berechnung.
- -{tp}: Die festgelegte Gewinnschwelle.
- -"Deus EA": Eine auftragsbezogene Aussage.
Nach dem Versuch, die Position zu öffnen, überprüft die Funktion das Ergebnis und zeichnet gegebenenfalls eine Meldung auf.
if(result) { Print("Order opened successfully. Type: ", orderType, ", Price: ", price); } else { Print("Failed to open order. Error code: ", GetLastError()); } }
Bei erfolgreicher Eröffnung des Auftrags wird eine Bestätigung ausgedruckt. Wenn der Auftrag nicht geöffnet werden kann, wird mit GetLastError der Problemcode abgerufen, der dann für die Fehlersuche notiert wird.
Der vollständige Code für die Funktion zum Öffnen von Positionen lautet wie folgt:
//+------------------------------------------------------------------+ //| Function to open a position | //+------------------------------------------------------------------+ void OpenPosition(int orderType) { double price = (orderType == ORDER_TYPE_BUY) ? Ask : Bid; double sl = (orderType == ORDER_TYPE_BUY) ? price - StopLoss * _Point : price + StopLoss * _Point; double tp = (orderType == ORDER_TYPE_BUY) ? price + TakeProfit * _Point : price - TakeProfit * _Point; bool result = trade.PositionOpen(_Symbol, orderType, Lots, price, sl, tp, "Zeus EA"); if(result) { Print("Order opened successfully. Type: ", orderType, ", Price: ", price); } else { Print("Failed to open order. Error code: ", GetLastError()); } } )
Wir sind fertig mit einer der Utility-Funktionen und wollen uns nun eine weitere ansehen, die eine Funktion zum Schließen von Positionen ist. Um sicherzustellen, dass unerwünschte Positionen durch Parameter der Handelsstrategie beendet werden, ist die ClosePositions-Funktion des Deus EA unerlässlich. Wenn bestimmte Bedingungen erfüllt sind, soll diese Funktion die Logik für das Schließen von Positionen einer bestimmten Art (Kauf oder Verkauf) verwalten. Untersuchen wir die Arbeitsweise dieser Funktion und ihre Bedeutung für den Gesamtplan.
void OpenPosition(int orderType)
Der Typ der zu schließenden Position wird durch ein einziges Argument orderType angegeben, das von der Funktion Closepositions übernommen wird. ODER_TYPE_SELL oder ORDER_TYPE_BUY sind die möglichen Werte für diesen Parameter. Die Funktion führt eine Schleife über alle zu diesem Zeitpunkt offenen Positionen durch und schließt die entsprechenden Positionen.
for(int i = PositionsTotal() - 1; i >= 0; i--) { if(PositionSelectByIndex(i)) { if(PositionGetInteger(POSITION_TYPE) == orderType) { if(!trade.PositionClose(ticket) { Print("Failed to close position. Error code: ", GetLastError()); } } } }
Die Schleife läuft rückwärts, beginnend mit dem letzten Element. Da das Schließen einer Position die Gesamtzahl der Positionen verringert, kann eine Vorwärts-Iterationsschleife unterbrochen werden, was diese umgekehrte Iteration erforderlich macht. PositionSelectByIndex(!) wird verwendet, um die Position am angegebenen Index {i} zu wählen.
Die Funktion prüft, ob der gewählte Ort mit dem angegebenen {orderType} innerhalb der Schleife übereinstimmt.
if(PositionGetInteger(POSITION_TYPE) == orderType)
Ist {orderType} nicht gleich diesem Wert, sollte die Position nicht geschlossen werden. Die Funktion versucht, die Position zu schließen, wenn der Typ übereinstimmt.
if(!trade.PositionClose(ticket) { Print("Failed to close position. Error code: ", GetLastError()); } } } }
Eine Position wird geschlossen, indem versucht wird, sie anhand ihrer Ticketnummer {trade.PositionClose(ticket)}) zu identifizieren. Wenn die Position nicht geschlossen werden kann, wird eine Fehlermeldung mit dem durch GetLastError() erhaltenen Fehlercode ausgegeben. Dies hilft, die Ursache für die Unfähigkeit, die Position zu schließen, zu identifizieren und erleichtert die Fehlerbehebung.
Der Deus EA kann Gewinne festschreiben, indem er gewinnbringende Positionen schließt, wenn sie eine angegebene Gewinnschwelle erreichen. Dies wird erreicht, indem sichergestellt wird, dass ausgewählte Positionen unter bestimmten Bedingungen geschlossen werden.
Der vollständige Code für die Funktion zum Schließen der Position lautet wie folgt:
//+------------------------------------------------------------------+ //| Function to close positions | //+------------------------------------------------------------------+ void ClosePositions(int orderType) { for(int i = PositionsTotal() - 1; i >= 0; i--) { if(PositionSelectByIndex(i)) { if(PositionGetInteger(POSITION_TYPE) == orderType) { if(!trade.PositionClose(ticket) { Print("Failed to close position. Error code: ", GetLastError()); } } } }
Kommen wir nun zu unserer letzten Hilfsfunktion, einer Funktion zur Anwendung des Trailing-Stops. Sie können weitere Verluste durch das Schließen von Verlustgeschäften verhindern. Durch Befolgung der Leitlinien, wie z. B. Verzicht auf gleichzeitige Kauf- und Verkaufspositionen und Absicherung. Der Trailing-Stop ändert die Stop-Loss-Niveaus, wenn sich der Marktpreis zu Gunsten einer offenen Position verschiebt. Die Methode ApplyTrailingStop im Deus EA sorgt dafür, dass diese Funktion effektiv angewendet wird. Der Trailing-Stop begrenzt potenzielle Verluste und sichert Gewinne, indem er Marktschwankungen verfolgt. Lassen Sie uns besprechen, wie die Funktion funktioniert.
void ApplyTrailingStop() Da dies für alle offenen Positionen des aktuellen Symbols gilt, benötigt die Methode ApplyTrailingStop keine Parameter. Wie die Funktion ClosePositions beginnt die Funktion mit einer Iteration durch alle offenen Positionen:
for (int i = PositionsTotal() - 1; i >= 0; i--) { if (PositionSelectByIndex(i) && PositionGetSymbol() == _Symbol)
Die Schleife läuft rückwärts, beginnend an der letzten Position.
-{PositionSelectByIndex(i)}: Diese Funktion wählt den Eintrag bei index{i}. Sie überprüft, ob die Position mit dem aktiven Handelssymbol verbunden ist, indem {PositionGetSymbol()==_Symbol} verwendet wird.
Die Funktion verwendet den Trailing-Stop-Abstand und den aktuellen Marktpreis, um das neue Stop-Niveau zu bestimmen:
double price = (PositionGetInteger(POSITION_TYPE) == ORDER_TYPE_BUY) ? Bid : Ask; double sl = (PositionGetInteger(POSITION_TYPE) == ORDER_TYPE_BUY) ? price - TrailingStop * _Point : price + TrailingStop * _Point;
Der Trailing-Stop für Kaufpositionen wird unter dem {Bid}-Kurs gesetzt. Der Trailing-Stop wird bei Verkaufsgeschäften über dem {Ask}-Kurs positioniert. Die Funktion verwendet dann PositionModify, um das neue Stop-Loss-Niveau anzuwenden, nachdem sie festgestellt hat, ob es angemessen ist:
if (PositionGetInteger(POSITION_TYPE) == ORDER_TYPE_BUY && PositionGetDouble(POSITION_SL) < sl) { if (!trade.PositionModify(PositionGetInteger(POSITION_TICKET), sl, PositionGetDouble(POSITION_TP))) { Print("Failed to modify position. Error code: ", GetLastError()); } } else if (PositionGetInteger(POSITION_TYPE) == ORDER_TYPE_SELL && PositionGetDouble(POSITION_SL) > sl) { if (!trade.PositionModify(PositionGetInteger(POSITION_TICKET), sl, PositionGetDouble(POSITION_TP))) { Print("Failed to modify position. Error code: ", GetLastError()); } } }
Nur wenn das neue Stop-Loss-Niveau ({sI)} den bestehenden Stop-Loss übersteigt, wird der Stop-Loss für Ihre Positionen geändert. Auch wenn das neue Stop-Loss-Niveau niedriger ist als das bestehende Stop-Loss-Niveau, wird es für Verkaufspositionen aktualisiert.
Wenn die Positionsänderung nicht erfolgreich war, wird eine Fehlermeldung mit dem Fehlercode gedruckt. Dies hilft bei der Fehlersuche und klärt auch den Grund, warum der Trailing-Stop nicht verwendet wurde.
Der vollständige Code für die Funktion zur Anwendung des Trailing-Stops lautet wie folgt:
//+------------------------------------------------------------------+ //| Function to apply trailing stop | //+------------------------------------------------------------------+ void ApplyTrailingStop() { for (int i = PositionsTotal() - 1; i >= 0; i--) { if (PositionSelectByIndex(i) && PositionGetSymbol() == _Symbol) { double price = (PositionGetInteger(POSITION_TYPE) == ORDER_TYPE_BUY) ? Bid : Ask; double sl = (PositionGetInteger(POSITION_TYPE) == ORDER_TYPE_BUY) ? price - TrailingStop * _Point : price + TrailingStop * _Point; if (PositionGetInteger(POSITION_TYPE) == ORDER_TYPE_BUY && PositionGetDouble(POSITION_SL) < sl) { if (!trade.PositionModify(PositionGetInteger(POSITION_TICKET), sl, PositionGetDouble(POSITION_TP))) { Print("Failed to modify position. Error code: ", GetLastError()); } } else if (PositionGetInteger(POSITION_TYPE) == ORDER_TYPE_SELL && PositionGetDouble(POSITION_SL) > sl) { if (!trade.PositionModify(PositionGetInteger(POSITION_TICKET), sl, PositionGetDouble(POSITION_TP))) { Print("Failed to modify position. Error code: ", GetLastError()); } } }
Der vollständige Code für den Artikel lautet wie folgt:
//+------------------------------------------------------------------+ //| Zeus EA | //| Copyright 2024, MetaQuotes Ltd. | //| https://www.mql5.com | //+------------------------------------------------------------------+ #include <Trade\Trade.mqh> CTrade trade; //--- Input parameters input double Lots = 0.1; // Lot size input double StopLoss = 50; // Stop loss in points input double TakeProfit = 50; // Take profit in points input double TrailingStop = 25; // Trailing stop in points //--- RSI parameters input int RSI_Period = 7; // RSI period input double RSI_Overbought = 35.0; // RSI overbought level input double RSI_Oversold = 15.0; // RSI oversold level //--- Moving Average parameters input int MA_Period = 25; // Moving Average period input ENUM_MA_METHOD MA_Method = MODE_SMA; // Moving Average method input ENUM_APPLIED_PRICE MA_Price = PRICE_CLOSE; // Applied price for MA //--- Variables double rsiValue; // RSI value double maValue; // Moving Average value double Ask; double Bid; double Close[2]; // Initializing Close array with two elements //--- Function prototypes void ApplyTrailingStop(); void OpenPosition(CTrade &trade, int orderType); // Pass CTrade by reference void ClosePositions(int orderType); // pass orderType directly //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { Print("Zeus EA initialized successfully."); return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { Print("Zeus EA deinitialized. Reason: ", reason); } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { //--- Update current prices Ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK); Bid = SymbolInfoDouble(_Symbol, SYMBOL_BID); ArrayResize(Close, 2); Close[0] = iClose(_Symbol, Period(), 0); Close[1] = iClose(_Symbol, Period(), 1); //--- Calculate RSI value rsiValue = iRSI(_Symbol, _Period, RSI_Period, PRICE_CLOSE, 0); if (rsiValue == WRONG_VALUE) { Print("Error calculating RSI"); return; //--- Calculate Moving Average value maValue = iMA(_Symbol, _Period, MA_Period, 0, MA_Method, MA_Price, 0); if (maValue == WRONG_VALUE) { Print("Error calculating Moving Average"); return; } //--- Check for Buy Signal if(rsiValue < RSI_Oversold && Close[1] > maValue) { if(PositionsTotal() == 0) { ClosePositions(ORDER_TYPE_SELL); OpenPosition(ORDER_TYPE_BUY); } } //--- Check for Sell Signal if(rsiValue > RSI_Overbought && Close[1] < maValue) { if(PositionsTotal() == 0) { ClosePositions(ORDER_TYPE_BUY); OpenPosition(ORDER_TYPE_SELL); } } //--- Apply trailing stop if specified if(TrailingStop > 0) { ApplyTrailingStop(); } } //+------------------------------------------------------------------+ //| Function to open a position | //+------------------------------------------------------------------+ void OpenPosition(int orderType) { //--- Determine price stop loss, and take profit levels double price = (orderType == ORDER_TYPE_BUY) ? Ask : Bid; double sl = (orderType == ORDER_TYPE_BUY) ? price - StopLoss * _Point : price + StopLoss * _Point; double tp = (orderType == ORDER_TYPE_BUY) ? price + TakeProfit * _Point : price - TakeProfit * _Point; bool result = trade.PositionOpen(_Symbol, orderType, Lots, price, sl, tp, "Zeus EA"); if(result) { Print("Order opened successfully. Type: ", orderType, ", Price: ", price); } else { Print("Failed to open order. Error code: ", GetLastError()); } } //+------------------------------------------------------------------+ //| Function to close positions | //+------------------------------------------------------------------+ void ClosePositions(int orderType) { for(int i = PositionsTotal() - 1; i >= 0; i--) { if(PositionSelectByIndex(i)) { //--- Check if the positions type matches the order type to be closed if(PositionGetInteger(POSITION_TYPE) == orderType) { ulong ticket = PositionGetInteger(POSITION_TICKET); if(!trade.PositionClose(ticket) { Print("Failed to close position. Error code: ", GetLastError()); } } } } } //+------------------------------------------------------------------+ //| Function to apply trailing stop | //+------------------------------------------------------------------+ void ApplyTrailingStop() { for (int i = PositionsTotal() - 1; i >= 0; i--) { if (PositionSelectByIndex(i) && PositionGetSymbol() == _Symbol) { double price = (PositionGetInteger(POSITION_TYPE) == ORDER_TYPE_BUY) ? Bid : Ask; double sl = (PositionGetInteger(POSITION_TYPE) == ORDER_TYPE_BUY) ? price - TrailingStop * _Point : price + TrailingStop * _Point; //--- Trailing stop logic for buy positions if (PositionGetInteger(POSITION_TYPE) == ORDER_TYPE_BUY && PositionGetDouble(POSITION_SL) < sl) { if (!trade.PositionModify(PositionGetInteger(POSITION_TICKET), sl, PositionGetDouble(POSITION_TP))) { Print("Failed to modify position. Error code: ", GetLastError()); } } //--- Trailing stop logic for sell positions else if (PositionGetInteger(POSITION_TYPE) == ORDER_TYPE_SELL && PositionGetDouble(POSITION_SL) > sl) { if (!trade.PositionModify(PositionGetInteger(POSITION_TICKET), sl, PositionGetDouble(POSITION_TP))) { Print("Failed to modify position. Error code: ", GetLastError()); } } } }
Herzlichen Glückwunsch an uns! Bis zu diesem Punkt haben wir unseren Deus EA zur Automatisierung des Handels eingesetzt.
Hier sind die Ergebnisse unseres Tests;
Erzielte Ergebnisse:
Der Test war USDJYP und der Backtest ist von 2024.07.10 bis 2024.08.06 auf dem 1H-Chart. Modellierung, jede. Die verwendeten Parameter sind die, die wir für die Untersuchung der Umsetzung verwendet haben.
Diese Art von Strategie ist am besten in EUR/USD und USD/JPY, aber nur für diejenigen, die keine hohe Gewinnrate benötigen. Nachfolgend finden Sie die Parameter, die wir zur Durchführung des Tests für unseren EA verwendet haben:
Schlussfolgerung
Der Deus EA verwendet gleitende Durchschnitte und den Relative-Stärke-Index (RSI), um Handelssignale zu generieren, und stellt eine fortschrittliche Handelsstrategie vor, die technische Indikatoren integriert, um Marktchancen zu verwalten und zu nutzen. In diesem Leitfaden werden die Handelslogik, die Risikokontrolle und der MQL5-Code, der dem EA zugrunde liegt, detailliert beschrieben. Dieser automatisiert Handelsentscheidungen, um die Konsistenz zu verbessern und emotionale Verzerrungen zu reduzieren.
Aus dem Chart können wir lernen, dass kleine Parameter für die Optimierung nicht nur das Risiko verringern, sondern auch den Verlust erhöhen. Daher sind vor dem Einsatz eines EA im Live-Handel gründliche Tests und Optimierungen in verschiedenen Symbolen entscheidend. Dadurch wird sichergestellt, dass es unter verschiedenen Marktbedingungen gut funktioniert und mit spezifischen Handelszielen übereinstimmt.
Regelmäßige Überwachung und Anpassungen sind notwendig, um die Wirksamkeit von Deus EA und ähnlichen automatisierten Systemen zu erhalten. Dieser Artikel liefert die wesentlichen Erkenntnisse und Werkzeuge, die für eine effektive Implementierung und Optimierung des Deus EA für den Handel erforderlich sind. Wenn Sie zusätzliche Unterstützung benötigen, können Sie diese von MQL5 aus in Anspruch nehmen.
Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/15431
Erstellen eines integrierten MQL5-Telegram Expert Advisors (Teil 1): Senden von Nachrichten von MQL5 an Telegram
Datenwissenschaft und ML (Teil 28): Vorhersage mehrerer Futures für EURUSD mithilfe von KI
Eine alternative Log-datei mit der Verwendung der HTML und CSS
Abstimmung von LLMs mit Ihren eigenen personalisierten Daten und Integration in EA (Teil 5): Entwicklung und Test von Handelsstrategien mit einer Feinabstimmung von LLMs(I)
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.