MetaTrader 5 herunterladen

Drei Aspekte der Manuellen Trading Automatisierung. Teil 1: Trading

29 April 2016, 14:05
Sergey Kravchuk
0
672

Einführung

Über die Jahre der Arbeit an Entwicklungen für die MetaTrader 4 Handelsplattform, habe ich versucht eine Menge Modelle und Ansätze eines automatisierten Arbeitsplatzes für Trader zu erstellen. Die allererste, naheliegende Lösung wurde umgesetzt mit einem Satz an Mouse Only Trader Skripten, was allgemein recht erfolgreich war. Nachdem es mit Risiko-Management-Berechnungen und Money-Management Funktionen erweitert wurde, kam ich zu einem ziemlich funktionalen Werkzeug, genannt die Trading Mouse.

von den Entwicklern in erster Linie als Mittel zum Erstellen vollständig automatisierter Handelsroboter angekündigt, schienen das MetaTrader 4 Trading-Terminal und seine Ergonomie absolut unzureichend für Menschen zu sein, die einen komfortablen Arbeitsplatz benötigen. Also begann ich mit einer grafischen Benutzeroberfläche zu experimentieren, während ich nach Möglichkeiten der Verwendung von Maus und Tastatur direkt auf einem Trading-Chart suchte. Das Ergebnis wurde dargestellt von zwei sehr fein ausgestatteten Produkten: Trading Console und Buy/Sell.

Leider gab es eine Kehrseite zu all deren großartigen Features und der Benutzerfreundlichkeit - die Expert Advisors zeigten wenig Reaktion auf schnell bewegende Kursänderungen und Handelsbefehlsausführung. Das Terminal verbrachte mehr Zeit mit dem Zeichnen der Features der Oberfläche, als mit Trading. Alle Versuche mit dieser scheinbar benutzerfreundlichen Oberfläche zu handeln beinhalteten eine Menge an Aufwand (insbesondere bei Pipsing und Scalping).

Interface variants

Fig. 1. Oberfläche-Varianten.

Deshalb habe ich, nach dem ich die Anforderungen an den Expert Advisor in Anbetracht dieser Tatsachen neu überdacht habe, einen Scalper erstellt, der maximale Effizienz bei minimaler Attraktivität für das Auge bieten konnte. Leider hatte er weiterhin alte Fehler, in Form von Maus-Befehlsverarbeitung oder es musste ein Sensorbildschirm eines Tablets verwendet werden. Als Ergebnis stellte es sich vollständiges Nischenprodukt heraus, vor allem zur Arbeit mit Tablets. Ich schaffe es nur im Simple Trader praktisch alle Problemchen loszuwerden, der die Grundlage für den Expert Advisor bereitstellte, den ich in diesem Artikel vorstellen möchte.

Ich habe bewusst die Entwicklungsgeschichte meiner Produkte beschrieben, um Ihnen zu helfen zu verstehen, dass die Umsetzung von allem in dem Artikel dargelegten sich nicht aus der Tatsache ableitet, dass der Autor es nicht anders konnte. Es ist nur, dass ich nach einer Menge Versuchen und Fehlern, über die einfachste und zuverlässigste Lösung abgewickelt habe, die ich mit Ihnen teilen möchte.



Ein Bild sagt mehr als tausend Worte

Bevor wir anfangen, lassen Sie uns zuerst einen Blick auf den Expert Advisor werfen, der im Folgenden betrachtet wird. Das Video gibt Ihnen eine Idee des Vorgangs, der während des Tradings im Terminal stattfindet. Als Ergebnis wird der Artikel viel einfacher zu verstehen sein (etwas wie: "ah, so wird das also umgesetzt!").

Zum besseren Verständnis des Videos, ist es ausreichend zu verstehen, dass es dort einen Expert Advisor gibt, der in dem Terminal arbeitet und über in das Terminalfenster gezogene Skripte gesteuert wird. Der Expert Advisor selbst tradet nicht. Er kann nur Stop-Ebenen ziehen (Stop Loss und Take Profit), nach dem Empfang eines entsprechenden Befehls durch den Trader. Die Skriptnamen entsprechen eindeutig ihren jeweiligen Handlungen, während ihre Verwendung in Tooltips erklärt wird.

Jetzt, da wir eine allgemeine Vorstellung von dem Thema des Artikels haben, lassen Sie es uns näher ansehen.



Grundlegende Prinzipien der Manuellen Trading Automatisierung

Zunächst möchte ich sagen, dass ich zu ungeduldig bin, um auf Tages-, Wochen- oder Monats-Charts zu handeln. Ich kann eine Position nur in dem Fall länger als einen Tag offen halten, wenn es sich um einen absolut stabilen und deutlich starken Trend handelt. Meine Arbeitsperiode beträgt 5 und 15 Minuten. Es gibt zu viel Rauschen auf Minuten-Charts, während Stunden-Charts meine Geduld töten. Viele von Ihnen werden sofort an 2 MAs, Alligator, Elders Bildschirme, usw. - wie können wir es ohne höhere Zeitrahmen machen?! Verwenden wir sie nicht um kurzfristige Trends und Einstiegspunkte in den Markt zu ermitteln? Ich nutze sie nicht in einer eindeutigen Form. Stattdessen komme ich ganz gut zurecht mit einer Kombination aus ZigZag und Pont & Figure Chart, die ich basieren auf den aktuellen 5 und 15 Minuten zeichne. Dies ist allerdings jetzt nicht der Punkt. Wir sprechen über Intraday Trader. Was sie machen ist praktisch ein klassisches Scalping. Man muss sehr sorgfältig den aktuellen Kurs überwachen und sofort auf Marktimpulse reagieren!

Dieses Intraday-Bewusstsein ermöglichte es mir, die Anforderungen an das Handelssystem drastisch zu vereinfachen. Es verwendet nur eine Order für jedes Symbol! Keine Verzögerungen: Wenn Sie sehen, dass der Kurs gegen Sie läuft, schließen Sie die Position mit dem minimalen Verlust, und entweder öffnen Sie in die entgegengesetzte Richtung oder Sie warten auf bessere Bedingungen für einen Einstieg in die gleiche Richtung. Kein Festsetzen oder Raster. Wenn Sie nicht sicher sind, in welche Richtung Sie eine Position öffnen sollen, öffnen Sie sie einfach nicht! Diese Aussage kann wahrscheinlich kontrovers erscheinen, aber das ist wie ich handle, und diesem Ansatz wurde in dem in diesem Artikel beschriebenen Expert Advisor gefolgt.

Die Entscheidung nur eine Order pro Symbol zu verwenden, hat auf einen Schlag alle Probleme gelöst, in Bezug auf die interaktive Auswahl einer arbeitenden Order zu Zwecken der Änderung oder des Schließens. Als Ergebnis wurde der Code mehrfach reduziert, da Fehler im Code waren. Unter seinen automatischen Funktionen sind Schnell- Öffnen / Ändern / Schließen einer Order und die Umsetzung des klassischen Trading-Grundsatzes "Lasse deine Gewinne laufen" in Form einer automatischen Ausführung des Trailing Stop. Jedoch im Gegensatz zum in dem Terminal integrierten Standard-Trailing Stop, wird der in diesem Expert Advisor eingesetzte Trailing Stop vollständig durch den Trader gesteuert und kann jederzeit einfach entsprechend der sich schnell ändernden Marktbedingungen angepasst werden.

Der Hauptunterschied zu dem Standard-Trailing Stop ist aber, die Möglichkeit einen Auslöser-Kurs einzustellen. Direkt nach dem Öffnen, können Sie einen Kurs einstellen, bei dessen Erreichen der Expert Advisor beginnt den dem angefallenen Gewinn zu folgen. Dies wird häufig der Kurs sein, an dem der Take Profit gesetzt wurde. Es kommt die Frage auf: Warum den Gewinn auf dieser Ebene beschneiden, wenn er weiter steigt? Da wir es tatsächlich nicht wissen können, fangen wir in diesem Moment an Gewinne zu realisieren, während wir ihn mit dem integrierten automatischen Trailing Stop laufen lassen.



Bekanntes Know-How

Ich denke nicht, dass ich neuen Boden betrete, wenn ich sage, dass der einzige Weg einen Handelsbefehl manuell auszuführen das Ausführen eines bestimmten Skripts ist. Seine Handlungen werden in dem Moment durchgeführt, in dem das Skript in das Chart gezogen wird. Anders als das Skript, muss der Expert Advisor auf den nächsten Tick warten, um den Start auszulösen. Aber bei einem neuen Tick kann der Kurs sich sehr von dem unterscheiden, was Sie erwartet haben. Es ist wahrscheinlich nicht so wichtig, wenn man auf längeren Zeitrahmen tradet, aber in aggressivem Intraday Trading sind solche Verzögerungen inakzeptabel

Sie können jedoch in einem Fenster nur ein Skript gleichzeitig ausführen. Sobald Sie beginnen ein neues Skript auszuführen, wird das vorherige Skript seine Arbeit einstellen. Die Funktionalität des Skripts ist zugegebenermaßen per se viel schlechter als die Fähigkeiten eines Expert Advisors. Also habe ich entschieden den Betrieb des Expert Advisors in zwei Stufen zu unterteilen: Erzeugen von Handelsbefehlen und die Ausführung. Als Ergebnis haben wir einen Satz an Skripten, die keine spezifischen Handlungen ausführen, sondern lediglich an den Expert Advisor die Einzelheiten übergeben, was er zu tun hat.

Um diesen Befehlsmechanismus zu vereinheitlichen, entschied ich nicht alle bedeutungsvollen Handelsaktionen in Skripts einzuschließen. Jedes Skript ist verbunden mit einem bestimmten Befehl (zum Öffnen einer Order, Stop Loss/Take Profit ändern, eine Order schließen) der einen einzigartigen nummerischen Index hat. Wenn also das Skript auf das Chart gezogen wird wissen wir, welchen Befehl wir ausführen möchten. Der Kurs und, wenn erforderlich, die Zeit für die Befehlsausführung kann mit den Fallpunkt-Koordinaten eingestellt werden. Wir müssen nur sehen, wie wir die auf das Fallenlassen des Skripts bezogenen Daten an den Expert Advisor übergeben können.

Bei der Entwicklung von vorherigen Versionen von automatisierten Händlern, habe ich fast alle adäquaten Methoden der Programm-zu-Programm Kommunikation mit Software auf Betriebssystem-Ebene und Win32API versucht:

  • Schreiben/Lesen über Festplatten-Dateien oder über FileMapping im Speicher,
  • Interaktion mit HTTP Protokollen,
  • Verwendung von E-Mail Slots, usw.

Sie hatten coole Funktionen (z.B. Mirror Trading auf mehreren Konten in unterschiedlichen Terminals oder die Fernsteuerung eines Expert Advisors im VPS-Betrieb) aber, leider, waren alle sehr aufwändig in der Umsetzung und Support und den Ärger nicht wert. Ich schafft es das Unnötige durch Erfahrung loszuwerden, nur die richtige Auswahl belassend - die Verwendung der globalen Variablen des Terminals. Die Interaktion von Skript und Expert Advisor ist in ihrer endgültigen Form eingekocht auf das Folgende:

Wenn es auf dem Chart abgelegt wird, erzeugt das Skript verschiedene globale Variablen und simuliert einen neuen Tick in dem Terminal, so dass der der Expert Advisor sofort den Befehl ausführt, die Werte aus den globalen Variablen zu lesen.


Vorteile und Merkmale des Globalen Skriptbefehl Mechanismus

Der erste klare Vorteil ist die Verwendung von Standard-Plattform-Mechanismen, die eine zuverlässige Interaktion gewährleisten. Der Quellcode wird deutlich reduziert und der Code des Expert Advisors wird von überschüssigen .ex4 und .dll Bibliotheken befreit, was es einfacher macht ihn zu modifizieren und zu warten.

Aber dasbemerkenswerteste Merkmaldieses Mechanismus, ist die Möglichkeit des ordnungsgemäßen Betriebs im visuellen Modus des Strategietesters. Es ermöglicht Ihnen einfach Ihren Trading-Fähigkeiten zu schärfen und Ihre Handelstaktiken im beschleunigten "Markt-Wiedergabe" Modus zu verbessern! Sie können jede geeignete Geschwindigkeit der Wiedergabe von Kursen einstellen und weiter üben... Im Gegensatz zu einem Demokonto, das den Betrieb zusammen mit dem Markt bietet, zur Live-Markt Geschwindigkeit, ist der Visualisierer jederzeit verfügbar (sogar an Wochenenden oder wenn keine Internetverbindung verfügbar ist). Sie können zu jeder Zeit pausieren (für eine Kaffeepause oder um eine komplexe Analyse der aktuellen Situation durchzuführen) und bestimmen die Effektivität Ihrer Handelsmethoden, die mehrere Monate der Historie in nur wenigen Minuten durchlaufen haben, mit der Steuerung der Wiedergabegeschwindigkeit.

Ebenso wichtig, ist die Möglichkeit mit diesem Expert Advisor die Signale von praktisch jedem Indikator traden zu können, der nicht eigenständig handeln kann. Auf einem Chart, können solche Indikatoren in der Regel einfach bestimmte grafische Objekte anzeigen, d.h. ein Signal zum Eintritt in den Markt oder zum Schließen einer Order. Leider ist das alles was sie machen können. Es ist in der Regel unmöglich zu traden oder den Indikator in dem Strategietester auszuführen. Aber wenn sie den Quellcode des Indikators haben, müssen Sie ihn nur ändern durch das Hinzufügen eines Blocks zum Erstellen der erforderlichen globalen Variablen (was nur ein paar Zeilen des Quellcodes sind) und es an dem Punkt aufrufen, an dem ser Indikator sein Signal setzt. Sie müssen sich auch keine Sorgen machen über die Wiederholung des Signals bei jedem Tick! Da der Expert Advisor nur eine Order je Symbol öffnen kann, wird ein wiederholter Befehl zum Öffnen, den Expert Advisor nicht endlos neue Positionen öffnen lassen. Mit einem solchen Befehl-Indikator zur Hand sind Sie in der Lage, Handelssignale des Indikators einfach in dem Strategietester zu testen: Starten Sie einfach den Test des Expert Advisor , hängen Sie Ihren Indikator an das entsprechende Chart und beobachten Sie, wie der Expert Advisor auf Basis der Indikator-Signale handelt.

Aber genug mit theoretischen Informationen. Es ist Zeit mit der praktischen Umsetzung der Idee fortzufahren.



Parameter der Steuerbefehle

Jedes Steuerung-Skript erzeugt mehrere globale Variablen mit denen die folgenden Parameter an den Expert Advisor übergeben werden:

  • #Trader-Chart - Identifikator des Fensters, auf dem das Skript abgelegt wurde. Wir benötigen es um den Betrieb mehrerer verschiedener Expert Advisors in einem Terminal zu ermöglichen (z.B. für unterschiedliche Symbole oder auf verschiedenen Zeitrahmen). Wenn es auf einem bestimmten Fenster abgelegt wird, erhält das Skript seinen Identifikator. Dieser Befehl wird von dem Expert Advisor bearbeitet, der an dasselbe Fenster angehangen ist. So werden verschiedene Expert Advisors nur ihre entsprechenden Befehle verarbeiten, den Rest von ihnen ignorieren. Der Identifikator verwendet die WindowHandle() Funktion.

  • #Trader-Command - Befehlscode. Leider ermöglicht uns das Terminal nur Zahlen als globale Variablen zu speichern, wodurch sie als nummerische Codes zugewiesen werden müssen, anstelle von deutlichen String Werten. Um die Synchronisation zwischen den Werten des Expert Advisors und Skripten zu gewährleisten, verwenden wir die allgemeine Eingabe #Trader-commands.mqh Datei mit den folgenden Definitionen:

    #define   COMMAND_NOACTION  0
    #define   COMMAND_OPEN      1
    #define   COMMAND_MODIFY    2
    #define   COMMAND_CLOSE     3
    #define   COMMAND_TRALSTART 4
    #define   COMMAND_TRALSTOP  5
    #define   COMMAND_TRALSTART0LOSS 6
    #define   COMMAND_TRALSTART50PROFIT 7
    

    Wenn Sie Ihren eigenen neuen Befehl hinzufügen müssen, fügen Sie einfach seinen Code "COMMAND_MYNEWCOMMAND" hinzu und weisen ihm einen einzigartigen Code zu. Dies erlaubt Ihnen die praktisch unendliche Skalierung der Funktionalität Ihrer Version des Expert Advisor.

  • #Trader-Price - Kurs an dem Skript-Ablagepunkt. Normalerweise ist dies ein neuer Order Eröffnungskurs, Stop Loss oder Take Profit Änderungskurs oder Automatischer Trailing Stop Auslöser-Kurs.

  • #Trader-Time - Handelsbefehl Erzeugungszeit. Es ist ein wirklich sehr wichtiger Parameter. Er wird em Expert Advisor nicht ermöglichen einen alten Befehl zu bearbeiten, der sich aus irgendwelchen Gründen im Terminal befindet. Zu diesem Zweck gibt es einen speziellen Parameter in dem Expert Advisor - ExecDelaySec. Der Expert Advisor prüft die aktuelle Terminalzeit bevor er einen Befehl ausführt, und wenn die im Skript gespeicherte Zeit größer als die aktuelle Zeit in ExecDelaySec Sekunden ist, wird der Befehl nicht ausgeführt und seine Details werden einfach gelöscht.



Quellcodes der Steuerskripte

In den obigen Ausführungen scheint es, dass die Codes von allen Skripten fas identisch sind, mit dem Befehlscode als einzigem Unterschied. Daher wurde der gesamte gemeinsame Teil als eine separate .mqh Datei angeordnet, um in alle Steuerskripte eingefügt zu werden.

Es bietet nur minimale mit der Handelsverfügbarkeit verbundene Steuerfunktionen. Alles andere sollte in dem Terminal durchgeführt werden.

#property link      "http://forextools.com.ua"
#include <stderror.mqh>
#include <WinUser32.mqh>
 
#import "user32.dll"
 int RegisterWindowMessageA(string lpstring);
 int PostMessageA(int hWnd,int Msg,int wParam,int lParam);
#import
 
void start()
{
  if ( !IsExpertEnabled() )   
  { MessageBox("Experts disabled. Action canceled.","SimpleTrader ERROR", MB_ICONERROR); return; }
  if ( !IsTradeAllowed() )    
  { MessageBox("Trade disabled. Action canceled.","SimpleTrader ERROR", MB_ICONERROR); return; }
  if ( IsTradeContextBusy() ) 
  { MessageBox("Trade context is busy. Action canceled.","SimpleTrader ERROR", MB_ICONERROR); return; }
 
  GlobalVariableDel ( "#Trader-Chart" );
  GlobalVariableDel ( "#Trader-Command" );
  GlobalVariableDel ( "#Trader-Price" );
  GlobalVariableDel ( "#Trader-Time" );
 
  // to allow several EAs handle scripts dropped onto THE RELEVANT windows only
  GlobalVariableSet ( "#Trader-Chart", WindowHandle( Symbol(), Period()) ); 
  GlobalVariableSet ( "#Trader-Command", COMMAND_ID );
  GlobalVariableSet ( "#Trader-Price", NormalizeDouble ( WindowPriceOnDropped(), Digits ) );
  GlobalVariableSet ( "#Trader-Time", TimeCurrent() );
 
  // emulation of the incoming tick to launch the Expert Advisor
  int hwnd = WindowHandle(Symbol(), Period());
  int MT4InternalMsg = RegisterWindowMessageA("MetaTrader4_Internal_Message");
  PostMessageA(hwnd, MT4InternalMsg, 2, 1);  
}

Der Skriptcode selbst besteht aus wenigen Zeilen:

#property copyright "Open buy or sell according to the dropped price of the Stop Loss level"
#include  "#Trader-commands.mqh"
int COMMAND_ID = COMMAND_OPEN;
#include  "#Trader-common.mqh"  

#property copyright wird verwendet um den Tooltip-Text im Terminal zu erstellen. Während dieser Text für einfacher Befehle offensichtlich sein kann, für Ihre eigenen Befehle, sollte Sie entscheiden diese zu dem Expert Advisor hinzuzufügen, erfordern eine gute Beschreibung, zusätzlich zu einem aussagekräftigen Namen, und das ist genau der richtige Ort dafür.

Diese Zeile wird von Befehlscodes von der allgemeinen Datei gefolgt. Der ein paar Zeilen weiter oben bereitgestellte allgemeine ausführbare Code kommt als nächstes, nach dem Setzen eines Befehlscodes für ein bestimmtes Skript.

Hier beenden wir die Arbeit mit den Steuerskripten und fahren fort mit dem Betrieb des Expert Advisor



Logik des Expert Advisor für Manuelle Trading Automatisierung

Ursprünglich wollte ich den operativen Algorithmus des Expert Advisor in Form eines Ablaufdiagramms darstellen. Er stellte sich aber als derart einfach und unkompliziert heraus, dass Klartext ausreicht.

Den Befehl erhalten -> Prüfen und Berechnen der Parameter -> Ausführen des Befehls -> Anzeigen der Ergebnisse

Die Eingabeparameter der Expert Advisor sind so minimalistisch wie die zugrunde liegende Logik. Was von jedem einzelnen gesteuert wird, wird später beschrieben, da wir mit der Beschreibung der entsprechenden Blöcke des Expert Advisor Quellcode fortfahren.

#property copyright "Copyright © 2006-2013, Sergey Kravchuk. http://forextools.com.ua"
#property link      "http://forextools.com.ua"

#include <stdlib.mqh>
#include "scripts\#Trader-commands.mqh"

extern int    MaxAllowedRisk = 2// maximum permissible percentage of losses 
extern int    OpenSlippage   = 2// distance from the current price for placing an order to open a position
extern int    CloseSlippage  = 10; // maximum permissible slippage when closing an order
extern int    ExecDelaySec   = 10; // maximum permissible delay as of the START of command execution

extern int    ShowClosedCnt  = 5// number of closed market orders for the history display

extern int    TralStep       = 5// price change step in trailing
extern color  TralStartColor = BlueViolet;
extern color  Tral0LossStartColor = LimeGreen;
extern int    Tral0LossGap   = 10; // offset from the opening price to the breakeven point in trailing

// arrow colors for order opening and closing
extern color  MarkBuyColor    = Blue;
extern color  MarkSellColor   = Red;
extern color  MarkModifyColor = Magenta;
extern color  MarkCloseColor  = Gray;

extern int    MessageShowSec  = 30; // time of displaying the last message on the screen in seconds

extern bool   ShowComment     = true;
extern bool   WriteGadgetFile = true;

Der Expert Advisor erhält zuerst die Parameter des Terminals für aktuelle Kursberechnung (je nachdem, ob er er im Visualisierer oder einem Live-Konto arbeitet), gibt es eine offene Order auf dem arbeitenden Chart-Symbol, wird sie sofort von dem OrderSelect() Operator ausgewählt.

// get dynamic parameters
Spread      = MarketInfo ( Symbol(), MODE_SPREAD );
StopLevel   = MarketInfo ( Symbol(), MODE_STOPLEVEL );

// update prices (instead of Ask and Bid, the Strategy Tester uses Close[0])
if ( IsTesting() ) { CurBid = Close[0]; CurAsk = Close[0]+Spread*Point; } 
else { CurAsk = Ask; CurBid = Bid; }

// Select ANY open order (for possible modifications), including Limit orders 
// e.g. to be able to set Take Profit
SelectedOrder = 0; for ( i = 0; i < OrdersTotal() && SelectedOrder <= 0; i++ )
{
  OrderSelect ( i, SELECT_BY_POS, MODE_TRADES );
  if ( OrderSymbol() == Symbol() && OrderMagicNumber() == MAGIC ) SelectedOrder = OrderTicket();
}

Für den Fall, dass es eine offene Order für das aktuelle Symbol gibt, ziehen wir den Trailing Stop. Die Angemessenheit und Leistung dieser Handlung werden durch das Verfahren festgelegt, das den einzigen Parameter erhält - TralStep. Wenn es keine offene Order gibt, werden die Trailing-Parameter zurückgesetzt. Dies ist notwendig, weil die Order durch den Stop Loss geschlossen werden kann, und der Expert Advisor, im Gegensatz zu manuellem Schließen, nicht weiß, dass diese Parameter zurückgesetzt werden müssen.

//trailing trigger price exists as long as there is an open order!!!
if ( SelectedOrder <= 0 ) { ZeroLossTral = false; HalfProfitTral = false; PrevPrice = 0; TralStart = 0; } 
// trailing (checking and performing - within the TrailingStop)
else TrailingStop ( TralStep );

Ferner prüfen wir, ob der Steuerbefehl für unser Fenster gedacht ist. Wenn dies der Befehl eines anderen Skripts ist, wird der Expert Advisor einfach aktualisierte Informationen auf dem Konto und offenen Ordern anzeigen. Wenn es ein relevanter Befehl ist, wird der Expert Advisor seine Parameter lesen und sofort den Befehl globale Variablen löschen (z.B. um nicht unbeabsichtigt mehrere Orden zu öffnen).

// if the script is intended for another window, only update the information.
if ( GlobalVariableGet ( "#Trader-Chart" ) != WindowHandle( Symbol(), Period()) ) { ShowInfo(); return; }
// if it is intended for the right window, execute the commands
// get the code and price of the command from the global variables and immediately delete them
if ( GlobalVariableCheck( "#Trader-Command" ) == false ) { CmdID = 0; CmdPrice = 0; ShowInfo(); return; } 
// there is a command, so we execute it
CmdTime  = GlobalVariableGet ( "#Trader-Time" );
CmdID    = GlobalVariableGet ( "#Trader-Command" );
CmdPrice = NormalizeDouble ( GlobalVariableGet ( "#Trader-Price" ), PriceDigits );
GlobalVariableDel ( "#Trader-Command" );
GlobalVariableDel ( "#Trader-Price" );
GlobalVariableDel ( "#Trader-Time" );
// if the command was generated earlier than the permissible execution delay, do not do anything!
if ( CmdTime+ExecDelaySec*60 < TimeCurrent() )
{
  SetError("Igore command from " + TimeToStr(CmdTime,TIME_DATE+TIME_SECONDS) 
         + " delayed > " + ExecDelaySec + "sec");
  ShowInfo();
  return;
}

Dies wird gefolgt von der Befehlsausführung und der Anzeige der Ausführungsergebnisse. Der Quellcode des Expert Advisor wird zusammen mit Kommentaren bereitgestellt, dort wo es notwendig ist, und Sie sollten nicht mit Schwierigkeiten beim Lesen und Verstehen konfrontiert werden. Es gibt jedoch einige Punkte, die einer weiteren Klärung bedürfen.



Bitte beachten Sie:

  1. Wir können nicht ohne Stop-Ebenen handeln.

    Eine Order wird immer mit einer voreingestellten Stop-Ebene geöffnet. Die gewählte Lot-Größe berücksichtigt die Stop-Ebene, so dass Verluste (wenn er ausgelöst wird) den voreingestellten Prozentsatz der zum Trading verfügbaren Mittel nicht übersteigen. Diese Regel wird außerdem geprüft, wenn die Stop-Ebene geändert wird. So werden Sie nicht in der Lage sein mit einem niedrigen Risiko zu öffnen, und dann die Stop-Ebene auf eine Art zu verschieben, dass Sie den Rest Ihrer Einlage verlieren. Diese Regel führt indirekt zu einer weiteren.

  2. Wir öffnen nur Limit Ordern.

    Einige Handelszentren erlauben das Öffnen von Markt-Ordern nicht mit voreingestelltem Stop Loss und Take Profit, mit der Begründung, dass eine Order mit Slippage öffnen kann und es ist (theoretisch) möglich, dass z.B. im Fall einer Buy-Position Ihre Stop-Ebene sich als viel höher herausstellt als der Eröffnungskurs. Diese Situation ist in einem volatilen Markt und bei einer sehr niedrigen Stop-Ebene in der Tat sehr wahrscheinlich. Um diese Einschränkung zu vermeiden, öffnen wir eine Limit-Order mit einem kleinen Versatz von dem aktuellen Preis (der oben erwähnte Slippage). Es ermöglicht uns eine Order genau dort zu platzieren, wo sie benötigt wird, wo die Stop-Ebene den angegeben Risiko-Prozentsatz nicht überschreitet. Wenn der Markt sich in unsere Richtung bewegt, wird die Order nach nur ein paar Ticks geöffnet. Wenn der Markt gegen uns läuft, haben wir die Möglichkeit die ungenutzte Limit-Order ohne Verluste zu schließen oder sie zu einem besseren Punkt zu verschieben.



Öffnen einer Order

Nachdem die aktuelle Situation analysiert und die Handelsrichtung ausgewählt wurde, entscheiden Sie über die Stop-Ebene der zu öffnenden Order und ziehen das #OPEN Skript auf den Stop Loss Punkt. Seine Position wird außerdem verwendet um die Handelsrichtung zu bestimmen. Ein Stop Loss für eine Buy-Order sollte immer unterhalb der Eröffnungskurses und wenn Sie, durch absetzen des Skripts, den Stop-Ebene Kurs unter dem aktuellen Kurs angeben, bedeutet dies, dass Sie kaufen werden. Ähnlich wird ein Stop Loss oberhalb des aktuellen Kurses auf das Öffnen einer Sell-Order hindeuten. Die einzige Ausnahme von dieser Regel ist ein Stop Loss innerhalb des Spread. In der Regel wird dies jedoch durch die Handelsrichtlinien des Handelszenters nicht erlaubt sein, wodurch Sie einen Stop Loss nicht näher setzen können, als es in dem StopLevel Parameter festgelegt ist.

Trotz einer Menge die Regeln des Öffnens beschreibenden Text, ist der entsprechende Code nur drei Zeilen lang:

// get dynamic parameters
Spread      = MarketInfo ( Symbol(), MODE_SPREAD );
StopLevel   = MarketInfo ( Symbol(), MODE_STOPLEVEL );
// update prices (instead of Ask and Bid, the Strategy Tester uses Close[0])
if ( IsTesting() ) { CurBid = Close[0]; CurAsk = Close[0]+Spread*Point; } 
else { CurAsk = Ask; CurBid = Bid; }
…
// determine the trading direction
if ( CurBid <= CmdPrice && CmdPrice <= CurAsk ) 
{ SetError("Stop inside spread. Undefined trade direction."); ShowInfo(); return; }
if ( CmdPrice < CurBid ) 
{ 
  Operation = OP_BUYSTOP;  
  PriceForOrder = CurAsk+(StopLevel+OpenSlippage)*Point; 
  MarkOpenColor = MarkBuyColor; 
}
if ( CmdPrice > CurAsk ) 
{ 
  Operation = OP_SELLSTOP; 
  PriceForOrder = CurBid-(StopLevel+OpenSlippage)*Point; 
  MarkOpenColor = MarkSellColor; 
}

Beim Öffnen einer Order gibt es noch einen weiteren Mechanismus, der es Ihnen ermöglicht den Handelsprozess zu beschleunigen - die Möglichkeit eine Position "automatisch" umzukehren. Wenn Sie eine Bux-Order offen haben und sehen, dass der Markt bearish wird, müssen Sie die Buy-Order schließen und eine Sell-Order öffnen. Sie können das alles alleine durch das Absetzen des Öffnung-Skripts machen. Der Expert Advisor wird die Situation analysieren und im Falle einer Positionsumkehr, wird er zuerst die offene Order schließen(vorausgesetzt sie war offen) und dann die gegenteilige öffnen.

// if this is the opening in the opposite direction, we first close the current order (if it exists)
if ( SelectedOrder > 0 )
{
  if ( ( Operation == OP_BUYSTOP  && ( OrderType() == OP_BUY  || OrderType() == OP_BUYSTOP  ) ) ||
       ( Operation == OP_SELLSTOP && ( OrderType() == OP_SELL || OrderType() == OP_SELLSTOP ) ) )
  {
    SetError("Only one order per symbol is allowed"); 
    ShowInfo();
    return;
  }
  // if orders are differently directed, close the previous one
  {
    if ( OrderType() == OP_BUY || OrderType() == OP_SELL )
    {
      // update with the current prices. in the Strategy Tester, Close[0] is used instead of Ask and Bid
      if ( IsTesting() ) { CurBid = Close[0]; CurAsk = Close[0]+Spread*Point; }   else { CurAsk = Ask; CurBid = Bid; }
      if ( OrderType() == OP_BUY ) PriceForOrder = CurBid; else PriceForOrder = CurAsk;
      OK = OrderClose ( OrderTicket(), OrderLots(), PriceForOrder, CloseSlippage, MarkCloseColor );
    }
    else 
    {
      OK = OrderDelete ( OrderTicket(), MarkCloseColor );      
      // clear lines and arrows of deleted Limit orders (not to overload the screen with information)
      for(i = ObjectsTotal()-1; i >= 0 ; i--)   if ( StringFind(ObjectName(i),"#"+SelectedOrder) == 0 ) ObjectDelete(ObjectName(i)); 
    }
    if ( OK == false) { SetLastError("Close on reverse"); return; } // failed to delete - do not do anything else 
  } 
}


Money-Management und Zulässiger Risiko-Prozentsatz

Nach dem Bestimmen der Handelsrichtung, müssen wir das Handelsvolumen bestimmen. Das Lot für eine zu öffnende Position wird durch den Expert Advisor so berechnet, dass der zulässige Prozentsatz an Verlusten nicht überschritten wird. Der Berechnungsalgorithmus ist sehr einfach: Er bestimmt den Punktwert für ein Standard-Lot, der weiter verwendet wird um Verluste zu berechnen, die an der durch das Skript bestimmten Stop Ebene anfallen. Der Weiteren wird nach der Pro-Rata Regel die Lot-Größe so weit verringert, wie der Wert des Standard-Lot den maximal zulässigen Prozentsatz des Risikos, in Bezug auf die verfügbaren Mittel überschreitet.

// calculate the required lot based on the specified losses at the given Stop level
Loss = AccountBalance() * MaxAllowedRisk / 100.0; // amount of permissible losses expressed as a percentage of the balance
PriceInPoint = MathAbs ( PriceForOrder - CmdPrice ) / Point;
SL1lot = PriceInPoint * TickValue;   // Stop level size expressed in monetary value for a single lot transaction.
Lot = Loss / SL1lot;         // permissible risk / SL1lot
Lot = NormalizeDouble ( MathFloor ( Lot / LotStep ) * LotStep, LotDigits );

Wird die Stop Ebene zu hoch festgelegt, während der Risiko-Prozentsatz niedrig ist, kann die erforderliche Lot-Größe kleiner sein, als der minimal zulässige Wert. Es kann leicht überprüft werden, nachdem die Unmöglichkeit des Öffnens und der maximale Stop Loss Wert festgestellt wurden.

if ( Lot < MinLot )
{
  OnePipCost = TickValue * MinLot; // recalculate the point value for the minimum possible lot
  SetError("Stoploss "+DoubleToStr(PriceInPoint,0)
          +" > max available "+DoubleToStr(MathAbs (Loss / OnePipCost),0));
  ShowInfo();
  return;
}

Wenn das Lot die maximal zulässige Lot-Größe überschreitet (wenn Sie den Stop Loss sehr eng setzen, während Sie einen sehr hohen Prrozentsatz des Risikos angegeben haben), wird die entsprechende Warnmeldung ausgegeben::

if ( MaxLot < Lot )
{
  OnePipCost = TickValue * MaxLot; // recalculate the point value for the maximum possible lot
  SetError("Stoploss "+DoubleToStr(PriceInPoint,0)
          +" < min available "+DoubleToStr(MathAbs (Loss / OnePipCost),0));
  ShowInfo();
  return;
}  


Order Modifizierung

Wenn Sie den Take Profit einstellen müssen oder den Stop Loss auf eine andere Kurs-Ebene verschieben, setzen Sie das #MODIFY Skript auf dem entsprechenden Kurs-Punkt in dem Chart ab. Der Expert Advisor wird herausfinden was genau geändert werden soll (Stop Loss oder Take Profit)und die Order entsprechend ändern. Hier verwenden wir die gleiche Technik wie beim Öffnen einer Order: Wenn der geänderte Kurs weniger ist, als der aktuelle Kurs für eine Buy-Position, bedeutet es eine Änderung des Stop Loss. Ein höher geänderter Kurs ist verbunden mit einer Änderung des Take Profit.

// determine what needs to be modified
if ( ( (OrderType() == OP_BUY  || OrderType() == OP_BUYSTOP)  && CmdPrice >= CurAsk ) ||
     ( (OrderType() == OP_SELL || OrderType() == OP_SELLSTOP) && CmdPrice <= CurBid ) ) TP = CmdPrice;
else // modify the Stop Loss
{
  SL = CmdPrice;

Da Verluste streng gesteuert werden, sind Sie nicht in der Lagen den Stop Loss höher einzustellen, als bei der Öffnung der Position, und unvernünftige Risiken werden somit vermieden.

  // Stop Loss and risk percentage control! 
  Loss = AccountBalance() * MaxAllowedRisk / 100.0; // losses set as a percentage of the balance
  OnePipCost = TickValue * OrderLots(); // recalculate the point value for the order lot
  if ( OrderType() == OP_BUY  ) NewLoss = ( OrderOpenPrice() - SL ) / Point * OnePipCost;
  if ( OrderType() == OP_SELL ) NewLoss = ( SL - OrderOpenPrice() ) / Point * OnePipCost;
  if ( NewLoss > Loss ) 
  { 
    SetError("Stoploss "+DoubleToStr(NewLoss/OnePipCost,0)
            +" > max available "+DoubleToStr(Loss/OnePipCost,0)); 
    ShowInfo(); return; 
  }
}


Schließen einer Order

Wenn Sie sich entscheiden die aktuelle Order zu schließen, setzen Sie das #CLOSE Skript an einem beliebigen Kurs-Punkt in dem Chart ab, da er beim Schließen nicht wichtig ist. Nach dieser Handlung wird die Order geschlossen.



Trailing Stop

Genau wie der Standard Trailing Stop Mechanismus, verfolgt auch der in den Expert Advisor integrierte Trailing Stop Algorithmus den Kurs in einem von Ihnen angegebenen Abstand wenn der Kurs in die "richtige" Richtung läuft. Aber anders als der Standard Mechanismus, hat er eine flexiblere Betriebssteuerung.

In erster Linie ermöglicht er Ihnen den Kurs einzustellen, bei dem Sie mit dem Trailing anfangen möchten. Sie können es direkt nach dem Öffnen einer Order machen, durch Absetzen des #TRAL-START Skripts auf dem Kurs, an dem das Trailing aktiviert werden soll. Der Expert Advisor wird sich an diesen Wert "erinnern", und sobald der Kurs das entsprechende Niveau durchbricht, wird der Trailing Stop Mechanismus eintreten, der Expert Advisor wird den den Trailing Stop hinter dem sich bewegenden Kurs nachziehen. Um zu häufiges Ändern der Oder zu vermeiden, hat der Expert Advisor einen Discretness Parameter -TralStep. Ein neuer Trailing Stop wird nur gesetzt, wenn der Kurs sich mindestens um den Abstand der TralStep Punkte in die "richtige" Richtung bewegt.

Der zweite Unterschied von dem Standard Trailing Stop ist, dass Sie die Trailing Stop Größe zum gleichen Zeitpunkt eingeben können, an dem Sie seinen Ausgangspunkt festlegen. Das #TRAL-START0LOSS Skript wird den anfänglichen Trailing-Punkt angeben, und sobald er ausgelöst wurde, wird er den Stop Loss automatisch auf den Break-Even Punkt verschieben, in dem Abstand von Tral0LossGap Punkten von dem Order Eröffnungskurs. Eine weitere Modifikation desselben Skripts, #TRAL-START50PROFIT, wird die Stop-Ebene am Anfang des Trailing-Prozesses zu der Mittellinie zwischen dem Auslöser-Kurs und dem Eröffnungskurs bewegen, was automatisch mindestens 50% des angefallenen Gewinns beim Trailing-Start sichern wird.

Trailing Stop Einstellungsbefehle übergeben die Parameter des künftigen Trailing Stop an den Expert Advisor.

//——— TRALSTART

// set the trailing trigger price. 
// before the triggering TralStart < 0 as a sign that it is still inactive
if ( CmdID == COMMAND_TRALSTART && CmdPrice > 0) 
{ 
  ZeroLossTral = false; HalfProfitTral = false; TralStart = CmdPrice; PrevPrice = 0; ShowInfo();   return; 
}
//——— TRALSTART0LOSS
// set the trailing trigger price. and simultaneously move the Stop level to the breakeven point
if ( CmdID == COMMAND_TRALSTART0LOSS && CmdPrice > 0) 
{ 
  ZeroLossTral = true; HalfProfitTral = false; TralStart = CmdPrice; PrevPrice = 0; ShowInfo();   return; 
}
//——— TRALSTART50PROFIT
// set the trailing trigger price. and simultaneously move the Stop level to 50% of the earned profit
if ( CmdID == COMMAND_TRALSTART50PROFIT && CmdPrice > 0) 
{ 
  ZeroLossTral = false; HalfProfitTral = true; TralStart = CmdPrice; PrevPrice = 0; ShowInfo();   return; 
}
//——— TRALSTOP
// zero out, which means that trailing stops
if ( CmdID == COMMAND_TRALSTOP ) 
{ 
  ZeroLossTral = false; HalfProfitTral = false; PrevPrice = 0; TralStart = 0; ShowInfo();   return; 
}

Dieser Mechanismus ermöglicht es Ihnen des Stress des Intraday Trading zu reduzieren und kann ein Trading garantieren, das zumindest dann Verlustfrei ist, wenn der Kurs den Trailing-Auslösepunkt erreicht. Da alles obige automatisch durch den Expert Advisor gemacht wird, müssen Sie nicht ständig den aktuellen Kurs überwachen und warten um den Trailing Stop einzusetzen.

Während des Betriebs des Expert Advisors im Trailing Modus, kann die Position jederzeit durch einen Standard-Modifizierungsbefehl mit dem #MODIFY Skript geändert werden. Nach dem Verschieben der Stop Ebene auf ein anderes Niveau, wird der aktive Trailing Stop Mechanismus diesen Abstand weiter beibehalten. Da alles im Chart gemacht wird und visuell angesprochen werden kann, ist es viel einfacher und komfortabler als der Standard-Trailing-Mechanismus, der Werte in Punkten erfordert. Genau wie Änderungen im Standard-Stop-Loss, bietet auch der Trailing Stop die Kontrolle über zulässige Verluste, die nicht erlauben, dass Sie mehr verlieren als angegeben:

void TrailingStop(int Step)
{
  double OnePipCost, NewLoss, SL=0;
  
  if ( OrderSelect ( SelectedOrder, SELECT_BY_TICKET ) == false ) return; 
  if ( OrderCloseTime() > 0 ) return; // the order has already been closed - there is nothing to trail
  
  // check if the data is valid
  if ( TralStart <= 0 || Step < 1 ) return(-1); 

  // Get the data for the Stop level size and risk percentage control!  
  Loss = AccountBalance() * MaxAllowedRisk / 100.0; // losses are set as a percentage of the balance
  OnePipCost = TickValue * OrderLots(); // recalculate the point value for the order lot

  if ( OrderType() == OP_BUY && CurBid >= TralStart ) 
  {
    if ( PrevPrice <= 0 ) 
    { 
      if ( ZeroLossTral   ) SL = NormalizeDouble(OrderOpenPrice() + Tral0LossGap*Point, Digits); 
      if ( HalfProfitTral ) SL = NormalizeDouble(OrderOpenPrice() + (CurBid - OrderOpenPrice())/2.0, Digits); 
      else                  SL = NormalizeDouble(OrderStopLoss(), Digits);
    }
    else SL = NormalizeDouble(OrderStopLoss() + (CurBid - PrevPrice), Digits);
    if ( SL < OrderStopLoss() ) return;
    NewLoss = ( OrderOpenPrice() - SL ) / Point * OnePipCost;
  }
  if ( OrderType() == OP_SELL && CurAsk <= TralStart )  
  {
    if ( PrevPrice <= 0 ) 
    { 
      if ( ZeroLossTral   ) SL = NormalizeDouble(OrderOpenPrice() - Tral0LossGap*Point, Digits); 
      if ( HalfProfitTral ) SL = NormalizeDouble(OrderOpenPrice() - (OrderOpenPrice() - CurAsk)/2.0, Digits); 
      else                  SL = NormalizeDouble(OrderStopLoss(), Digits);
    }
    else SL = NormalizeDouble(OrderStopLoss() - (PrevPrice - CurAsk), Digits);
    if ( SL > OrderStopLoss() ) return;
    NewLoss = ( SL - OrderOpenPrice() ) / Point * OnePipCost;
  }
  if ( SL <= 0 ) return; // the price has not yet crossed the trailing trigger level
  
  if ( NewLoss > Loss ) 
  { 
    SetError("Trailing Stoploss "+DoubleToStr(NewLoss/OnePipCost,0)
            +" > max available "+DoubleToStr(Loss/OnePipCost,0)); 
    ShowInfo(); 

return; 
  }

  if ( ( OrderType() == OP_BUY && SL - OrderStopLoss() >= Step*Point ) || 
      ( OrderType() == OP_SELL && OrderStopLoss() - SL >= Step*Point ) )
  {
    TXT = "• Tralingstop order. Please wait..."; 
    bool OK = OrderModify(OrderTicket(),OrderOpenPrice(),SL,OrderTakeProfit(),OrderExpiration(),Blue);
    if ( OK ) SetWarning("Traling stop moved to " + DoubleToStr(SL, Digits) 
                        +" at " + TimeToStr(TimeLocal(),TIME_SECONDS)); 
    else SetLastError("Tralingstop");
  }
  if ( PrevPrice <= 0 || OK )
  {  
    // only if we have moved the Trailing Stop, store the prices for the Trailing Stop on the next tick
    if ( OrderType() == OP_BUY  ) PrevPrice = CurBid;
    if ( OrderType() == OP_SELL ) PrevPrice = CurAsk;
  }
}


Anzeigen von Informationen zur Aktuellen Situation

Im Rahmen dieses Artikels haben wir nur die Fragen in Bezug auf das Trading als solches betrachtet. Im Verlauf des Betriebs des Expert Advisors, zeigt der in diesem Artikel bereitgestellte Code einfach einen kurzen Kommentar mit den Daten des aktuellen Status von Ordern und des Handelskontos an. Das alles könnte sicherlich auf eine feinere und informativere Art gemacht werden. In der tat ist es das, wie ich es gemacht habe. Meine Arbeitsversion des Systems gibt sehr detaillierte visuelle Informationen aus, in Bezug auf den Betrieb des Standard-Widget-Fensters des Windows 7 Betriebssystems. Dies wird der Schwerpunkt meines zweiten Artikels sein, da ich die Absicht habe über Dinge zu sprechen, die nicht direkt mit dem Trading verbunden sind. Aber ihre Verwendung macht den Vorgang der Handelsüberwachung komfortabler. Angenommen Sie haben eine offene Order, die Trailing Stop Position berechnet und warten nun einfach auf das Auslösen. Während Sie warten, müssen Sie Ihr Terminal-Fenster nicht geöffnet halten. Ein kleines Widget-Fenster, das immer oben steht, wird die aktuelle Situation ständig überwachen, während Sie andere Dinge tuin, und es hin und wieder überprüfen.

Aber auch ohne das Widget ist der Expert Advisor voll funktionsfähig und bereit für die echte Arbeit. Was auch immer fehlt, kann leicht zu dem Code zur Anzeige der aktuellen Informationen hinzugefügt werden.

Die einzige erwähnenswerte Sache, wenn über ddiesen Block des Expert Advisor gesprochen wird, ist der zugrunde liegende Mechanismus der Fehlermeldungen und dem normalen Betrieb des Expert Advisor. Jeder Ausnahmefall und jeder Fehler wird gespeichert in der speziellen String Variable - LastMsgTxt. Dieser Text wird auf dem Bildschirm für bis zu MessageShowSec Sekunden angezeigt, die in den Indikator-Parametern eingestellt werden.



Auf Externen Signalen basiertes Trading

Der Expert Advisor handelt basieren auf externen Befehlen. Und die Quelle dieser Befehle hat für den Expert Advisor absolut keine Bedeutung. Alles oben genannte kann auf den Fall angewendet werden, wenn der Expert Advisor durch eine Person gesteuert wird. Aber globale Variablen können in dem Terminal nicht nur von einer Person gesetzt werden. Es kann durch einen an das gleiche Fenster angehangenen Indikator gemacht werden. Sehen wir uns an wie das umgesetzt werden kann, mit dem Standard-RSI-Indikator als Beispiel.

Wir werden den Quellcode der Indikator-Berechnung ändern, durch Hinzufügen eines "analytischen Blocks" zur Steuerung des Expert Advisor am Ende des Codes, nachdem alle Indikator Pufferdaten berechnet sind. Dieses Beispiel implementiert die folgende Order-Eröffnungsregeln: eine neue Order wird geöffnet, wenn der RSI das Niveau 52 abwärts kreuzt oder das Niveau 48 aufwärts kreuzt.

Es wird zeigen, dass wir uns nicht darum sorgen müssen Ordern erzwungen zu schließen, aufgrund des integrierten Blockier-Mechanismus, der mehrere Öffnungen verhindert und Positionen automatisch schließt, im Falle einer Positionsumkehr. Der automatische Trailing-Mechanismus mit Bezug auf 50% Gewinn tritt ein bei dem Schnittpunkt der Ebenen 45 und 55. Dieses System kann sicher nicht rentabel genannt werden. Es wird hier nur zu Demonstrationszwecken verwendet, um zu zeigen was und wie in dem Code des Indikators getan wird, zum Trainieren der Steuerung des Expert Advisors

// addition to #Trader ======================================================================
double DefaultStop = 150 * Point; // shifting the Stop level when opening an order

// the Buy condition
if( RSIBuffer[3] <= 50 && RSIBuffer[2] <= 52 && RSIBuffer[1] > 52 )
{
   GlobalVariableSet ( "#Trader-Chart", WindowHandle( Symbol(), Period()) ); 
   GlobalVariableSet ( "#Trader-Command", 1 );
   GlobalVariableSet ( "#Trader-Price", NormalizeDouble ( Close[0] - DefaultStop, Digits ) );
   GlobalVariableSet ( "#Trader-Time", TimeCurrent() );
}

// the Sell condition
if( RSIBuffer[3] >= 50 && RSIBuffer[2] >= 48 && RSIBuffer[1] < 48 ) 
{
   GlobalVariableSet ( "#Trader-Chart", WindowHandle( Symbol(), Period()) ); 
   GlobalVariableSet ( "#Trader-Command", 1 );
   GlobalVariableSet ( "#Trader-Price", NormalizeDouble ( Close[0] + DefaultStop, Digits ) );
   GlobalVariableSet ( "#Trader-Time", TimeCurrent() );
}

// 50% trailing start
if( ( RSIBuffer[2] >= 45 && RSIBuffer[1] < 45 ) || ( RSIBuffer[2] <= 55 && RSIBuffer[1] > 55 ) ) 
{
   GlobalVariableSet ( "#Trader-Chart", WindowHandle( Symbol(), Period()) );
   GlobalVariableSet ( "#Trader-Command", 7 );
   GlobalVariableSet ( "#Trader-Price", NormalizeDouble ( Close[0], Digits ) );
   GlobalVariableSet ( "#Trader-Time", TimeCurrent() );
}
// addition to #Trader ======================================================================

Wichtiger Hinweis: Solche Indikatoren können nur in dem visuellen Modus getestet werden und können nicht optimiert werden. Unten ist ein Fragment des RSI Tests, wo Öffnungen und Schließungen in Reaktion auf die Befehle des Indikators durchgeführt wurden!

Eine andere interessante Möglichkeit, die sich eröffnet wenn Trading auf externen Signalen basiert, ist die Möglichkeit der Umsetzung von Mirror Trading auf mehreren Terminals auf verschiedenen Handelskonten. Fragen der programmübergreifenden Interaktion liegen außerhalb des Rahmens dieser Artikelreihe. Allerdings ist der Gedanke hinter einer solchen Umsetzung ziemlich offensichtlich: Durch die Handhabung des Befehls oder seiner Erzeugung in dem Skript, sollte eines der Terminals, das aktuell in den Handel involviert ist, die erhaltenen Parameter an ein anderes Terminal übergeben, wo diese von einem anderen Expert Advisor oder Indikator empfangen werden. Die gleiche Steuerung globaler Variablen wird dann in einem anderen Terminal erstellt und der entsprechende Expert Advisor von dem zweiten wird diese in der gleichen ausführen, wie der Expert Advisor von dem ersten Terminal.



Zusammenfassung

Lassen Sie uns nun die wichtigsten Punkte zusammenfassen, die in dem vorgeschlagenen Ansatz zur manuellen Trading-Automatisierung umgesetzt werden:

  • Befehls- und Ausführungskomponenten des Handelssystems sind in zwei Tele aufgegliedert: Steuerskripts geben Befehle und setzen Ihre Parameter basierend auf dem Expert Advisor, auf dem sie arbeiten. Es ermöglicht die Funktionalität durch Hinzufügen neuer Features einfach zu erweitern. Um dies zu machen, müssen Sie einen neuen Betriebscode hinzufügen, ein Skript, das diesen Code an den Expert Advisor übergibt und die entsprechende Handhabung in dem Expert Advisor organisieren.
  • Ein und derselbe Befehl wird sowohl für das Festlegen der Parameter zur Order-Handhabung als auch zum Bestimmen des auszuführenden Handlungstyps verwendet. Der Kurs der Stop Ebene bei der Öffnung bestimmt die Handelsrichtung, und in Fällen, in denen Modifizierung erforderlich ist, bestimmt es, ob es auf Stop Loss oder Take Profit angewendet werden soll.
  • Der verantwortliche Mechanismus zum Öffnen und Ändern von Ordern, sowie in den Expert Advisor integrierte Money-Management Verfahren, bewahren Sie davor mehr zu verlieren als den angegebenen Wert des Risikos, ausgedrückt als ein Prozentsatz des verfügbaren Kontostands
  • Anstelle des Standard-Take-Profit-Mechanismus, der Gewinne beschneidet, setzt der Expert Advisor Algorithmus "Lasse deine Gewinne laufen" um, wobei anstatt eine gewinnende Order am Take Profit Niveau zu schließen, er den wachsenden Gewinnen folgt.
  • Die Verwendung der globalen Standard-Terminal-Variablen für den Datenaustausch zwischen Skripten und dem Expert Advisor, ermöglicht Ihnen die einfache Verwendung von ein und demselben Code zur Arbeit auf Live-Konten, sowie zum Üben im visuellen Modus des Strategietester.
  • Handelsbefehle können nicht nur durch Befehlsskripte an den Expert Advisor übergeben werden, sondern auch durch jeden Indikator, dessen Quellcode geändert werden kann durch das Hinzufügen eines Blocks zum Erstellen von Befehls globaler Variablen an dem Punkt der Indikator-Signalerzeugung. Auf solchen Indikator-Signalen basierendes Trading kann auch in dem Standard-Tester des Terminals getestet werden. Dies kann sehr nützlich sein zum Ermitteln von quasi-rentablen nachzeichnenden Indikatoren.

Das angehangene Archiv enthält die Quellcodes für den #Trader Expert Advisor, zusammen mit Steuerskripten und dem RSI-indikator Beispiel mit dem integrierten Mechanismus, der verantwortlich ist für die Übergabe von Steuerbefehlen an den Expert Advisor.

Übersetzt aus dem Russischen von MetaQuotes Software Corp.
Originalartikel: https://www.mql5.com/ru/articles/1363

Beigefügte Dateien |
experts.zip (40.86 KB)
MetaTrader 4 Expert Advisor tauscht Informationen mit der Außenwelt aus MetaTrader 4 Expert Advisor tauscht Informationen mit der Außenwelt aus

Eine einfache, universelle und zuverlässige Lösung für den Informationsaustausch zwischen MetaTrader 4 Expert Advisor und der Außenwelt. Lieferanten und Konsumenten der Informationen können sich auf verschiedenen Computern befinden, die Verbindung wird über die globalen IP-Adressen hergestellt.

Die Random Sandbox Die Random Sandbox

Der Artikel enthält eine interaktive "Sandbox" als Excel-Datei, die randomisierte Expert Advoisor Backtest-Daten simuliert. Leser können diese verwenden um die Metriken der EA-Leistungen, die standardmäßig von MetaTrader angeboten werden, zu erkunden und tiefer zu verstehen. Der Test dieses Artikels wurde entworfen um Nutzer durch diese Erfahrung zu führen.

Mechanisches Handelssystem "Chuvashov's Dreieck" Mechanisches Handelssystem "Chuvashov's Dreieck"

Lassen Sie mich Ihnen einen Überblick und den Programmcode des mechanischen Handelssystems bieten, basierend auf Ideen von Stanislav Chuvashov. Die Konstruktion von Dreiecken basiert auf den Schnittpunkten von zwei Trendlinien, aufgebaut durch die oberen und unteren Fractale.

LibMatrix: Bibliothek der Matrix Algebra (Teil Eins) LibMatrix: Bibliothek der Matrix Algebra (Teil Eins)

Der Autor macht die Leser vertraut mit einer einfachen Bibliothek der Matrix Algebra und stellt Beschreibungen und Besonderheiten der wichtigsten Funktionen bereit.