Einführung in MQL5 (Teil 8): Leitfaden für Einsteiger zur Erstellung von Expert Advisors (II)

Einführung

Nachdem Sie sich bereits mit den Grundlagen von MQL5 beschäftigt haben, sind Sie nun bereit, eine der wichtigsten Aufgaben im Zusammenhang mit dem algorithmischen Handel in Angriff zu nehmen: die Erstellung eines funktionierenden Expert Advisors. Wie ich bereits im letzten Artikel angedeutet habe, werden wir in dieser Reihe einen projektbasierten Ansatz verwenden. Diese Methode hilft sowohl dabei, abstrakte Ideen zu verstehen als auch zu erkennen, wie sie in praktischen Situationen angewendet werden. Wenn Sie diesen Leitfaden beendet haben, werden Sie wissen, wie Sie Handelsentscheidungen auf der Grundlage von Kerzenmustern und vorher festgelegten Bedingungen automatisieren können. 

Viele Anfänger stellen häufig Fragen im Forum, und obwohl die großartigen Community-Mitglieder mit großartigen Ratschlägen antworten, finden es einige Autodidakten schwierig, diese Antworten in ihre Programme zu integrieren. Während die Antwort auf eine bestimmte Frage gegeben wird, ist es häufig nicht möglich, den gesamten Code ausführlich zu erläutern. Auch wenn die Codeschnipsel und Tipps hilfreich sein können, ist es für Sie als Autodidakt vielleicht schwierig, alles zusammenzufügen. Mit einem projektbezogenen Ansatz versucht dieser Artikel, diese häufig gestellten Fragen zu beantworten, und garantiert, dass die Lösungen von jedem EA angewendet werden können.

In diesem Artikel werden wir uns auf die Entwicklung eines EA konzentrieren, der die Kerzen-Analyse des Vortages zur Bestimmung der Handelsrichtung verwendet. Der EA wird sich darauf konzentrieren, für den Tag zu verkaufen, wenn die letzte Tageskerze bärisch ist, und zu kaufen, wenn sie bullisch ist. Der EA verifiziert seine Handelssignale auch anhand des Schlusskurses der ersten 1-Stunden-Kerze des Tages. Es wird nicht mehr als eine offene Position zu einem bestimmten Zeitpunkt geben, und das tägliche Maximum von zwei Trades wird durchgesetzt. Sie wird unter strengen Handelsbeschränkungen arbeiten. Darüber hinaus wird der Betrieb auf die ausgewiesenen Handelszeiten von Montag bis Mittwoch beschränkt sein.

Im Laufe dieses Projekts werden wir einige häufige Fragen behandeln, die Anfänger oft haben, insbesondere solche, die häufig in MQL5-Foren gestellt werden. Zu diesen Fragen gehören unter anderem:

• Wie kauft und verkauft man in MQL5?
  
• Wie erhält man die Eröffnungs- und Schlusskurse der Kerzen?
  
• Wie kann man vermeiden, bei jedem Tick zu handeln?
  
• Wie kann ich einen EA so einschränken, dass er nur einen Handel zur gleichen Zeit abschließt?
  
• Wie legt man den Handelszeitraum für einen EA fest?
  
• Wie kann man die Wochentage festlegen, an denen ein EA handeln kann?
  
• Wie legt man Gewinn- und Verlustlimits für den Handel fest?
  

Mit diesem projektbasierten Ansatz möchte ich klare, praktische Antworten auf diese Fragen geben, sodass Sie die Lösungen direkt in Ihrem Expert Advisor umsetzen können. Diese praktische Methode hilft nicht nur dabei, theoretische Konzepte zu verstehen, sondern auch, ihre Anwendung in realen Szenarien zu sehen. Lassen Sie uns in die Welt von MQL5 eintauchen und mit dem Aufbau Ihrer Handelswerkzeuge beginnen!

1. Das Projekt einrichten

1.1. Pseudocode

Es ist wichtig, die Logik unseres Expert Advisors mit Pseudocode zu beschreiben, bevor wir mit dem Schreiben von Code beginnen. Die Bedeutung von Pseudocode wurde im vorigen Artikel behandelt, wobei hervorgehoben wurde, dass er eine klare Planung und Organisation Ihrer Ideen erleichtert, was den eigentlichen Codierungsprozess beschleunigt. Um MQL5 zu lernen, sollten Sie daran denken, dass projektbasiertes Lernen besser ist, als alles auf einmal zu lernen. Man wird besser, je mehr Projekte man bearbeitet. Dies ist der grundlegende Pseudocode unseres EAs: 

1. Initialisieren Sie den EA:

• Legen Sie die magische Zahl für die Handelsidentifikation fest.
• Legen Sie Start- und Endzeiten für den Handel fest.
• Initialisieren Sie Variablen für die Speicherung von Preisen.

2. Auf Schritt und Tritt:

• Vergewissern Sie sich, dass die Uhrzeit innerhalb der Handelszeiten liegt, indem Sie die aktuelle Uhrzeit überprüfen.
• Ermitteln Sie die Eröffnungs- und Schlusskurse des Vortages.
• Verkaufen Sie, wenn der Schlusskurs des Vortages unter dem Eröffnungskurs lag (fallend).
• Kaufen Sie, wenn der Schlusskurs des Vortages höher war als der Eröffnungskurs (steigend).
• Achten Sie darauf, dass jeweils nur eine Position geöffnet ist.
• Handel nur von Montag bis Donnerstag.
• Sicherstellen, dass maximal eine Position offen ist
• Tägliches Limit von zwei Handelsgeschäften pro Tag.
• Tägliches Gewinnlimit.
• Schließen Sie die Handelsgeschäfte am Ende des Handelszeitraums ab.

1.2. Erforderliche Bibliotheken einbinden

Bibliotheken sind Sätze von vorgefertigten Klassen und Funktionen in MQL5, die das Programmieren erleichtern. Sie ermöglichen, sich auf die besonderen Merkmale Ihres Expert Advisors (EA) zu konzentrieren, anstatt allgemeine Funktionen neu schreiben zu müssen. In einem unserer früheren Artikel haben wir die Idee der Einbindung von Dateien erörtert. Machen Sie sich keine Sorgen, wenn Sie Include-Dateien nicht vollständig verstehen; Sie können diesem Artikel trotzdem folgen. Sie müssen nicht alles auf einmal wissen, um MQL5 nutzen zu können; das Lernen durch projektbasiertes Lernen ermöglicht es Ihnen, schrittweise Fortschritte zu machen. Sie können die Codeschnipsel und Erklärungen effektiv in Ihren Programmen verwenden, wenn Sie einfach die Anweisungen befolgen.

Analogie

Betrachten Sie die Arbeit, die Sie als Programmierer verrichten, als ein riesiges, verwunschenes Bücherregal. Dieses Bücherregal enthält zahlreiche Bücher. Jedes Buch enthält einzigartige Richtlinien und Erzählungen, die Ihnen helfen, verschiedene Ziele zu erreichen. Ähnlich wie diese seltenen Bücher in Ihrem verwunschenen Bücherregal sind MQL5-Bibliotheken. Die vorformulierten Geschichten (oder der Code) in diesen Büchern können zum Aufbau Ihres Handelsroboters verwendet werden. Sie können einfach das entsprechende Buch in die Hand nehmen und sich von den darin enthaltenen Geschichten leiten lassen, sodass Sie nicht jedes Mal wieder von vorne anfangen müssen. 

Sie müssen also bei der Entwicklung Ihres Expert Advisors nicht jedes einzelne Detail selbst schreiben. Diese Bücher enthalten Anleitungen, die Sie zur Vereinfachung Ihrer Codierung verwenden können. So können Sie sich auf die besonderen und interessanten Aspekte Ihres Handelsroboters konzentrieren, anstatt sich in banalen Details zu verzetteln.

1.2.1. Die Fachbibliothek einbeziehen

Sie müssen die Handelsbibliothek in Ihren EA einbinden, um die Handelsoperationen zu verwalten. Diese Bibliothek bietet eine Sammlung von Klassen und Funktionen für ein effektives Handelsmanagement. Der folgende Code dient zum Einbinden der Bibliothek:

Analogie

Stellen Sie sich vor, Sie besitzen ein riesiges Bücherregal voller Bände. Jedes Buch fungiert als eine Art Werkzeugkasten, der Hilfestellung in verschiedenen Bereichen bietet. Um etwas Einzigartiges zu bauen, z. B. einen genialen Handelsroboter, zieht man das entsprechende Buch aus dem Regal. Es ist, als ob ein spezielles Buch aus dem Regal genommen wurde, um die Handelsbibliothek aufzunehmen. In diesem Buch finden Sie alle notwendigen Werkzeuge für die Verwaltung von Handelsgeschäften. In diesem Buch sind bereits alle Anleitungen enthalten, sodass Sie es nicht selbst machen müssen!

Sie binden dieses spezielle Buch mit der folgenden Codezeile in Ihr Projekt ein:

#include <Trade/Trade.mqh> // Include the trade library for trading functions

Ihr Handelsroboter wird aus dieser Zeile lernen, „das Buch mit dem Namen Trade.mqh aus dem Regal zu holen“. Dieses Buch enthält alle möglichen nützlichen Instrumente, die den Prozess der Eröffnung, Änderung und Schließung von Handelsgeschäften rationalisieren. Es sorgt für einen reibungslosen Ablauf und spart Ihnen eine Menge Zeit.

Beispiel:

#include <Trade/Trade.mqh> // Include the trade library for trading functions

// Create an instance of the CTrade class for trading operations
CTrade trade;
//magic number
int MagicNumber = 103432;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
// Set the magic number for the EA's trades
   trade.SetExpertMagicNumber(MagicNumber);

// Return initialization success
   return(INIT_SUCCEEDED);
  }

1.2.2.1. Erstellen einer Instanz der Klasse CTrade

Die Klasse CTrade, die Teil der Trade-Bibliothek ist, kapselt Methoden zur Ausführung von Handelsoperationen. Wenn Sie eine Instanz dieser Klasse erstellen, können Sie ihre Funktionen zur Verwaltung Ihrer Geschäfte nutzen.

Analogie

Stellen Sie sich noch einmal Ihr Bücherregal vor. Sie haben bereits das spezielle Buch (Trade.mqh) herausgesucht, das alle Anweisungen für den Handel enthält. Stellen Sie sich die Klasse CTrade als eine besondere Figur in diesem Buch vor, wie einen Superhelden, der alles über den Handel weiß. Um diesen Superhelden zu nutzen, müssen Sie ihn in Ihre Geschichte einbauen. Dazu erstellen Sie eine Instanz der Klasse CTrade. Es ist, als ob man einen Superhelden einlädt, einem bei seinem Projekt zu helfen.

Hier sehen Sie, wie Sie den Superhelden mit einer einfachen Codezeile einladen:

CTrade trade;

In diesem Code ist CTrade der Superheld, und der Handel ist Ihre Einladung. Indem Sie diese Instanz namens „Trade“ erstellen, sagen Sie: „Superheld CTrade, bitte tritt meinem Projekt bei und hilf mir bei der Verwaltung von Trades!“ 

Wann immer Sie nun einen Handel platzieren oder verwalten müssen, können Sie Ihren Superheldenhandel bitten, dies für Sie zu tun. Das erleichtert Ihnen die Arbeit und sorgt dafür, dass alles richtig gemacht wird.

1.2.2.2. Einrichten der magischen Zahl

Eine magische Zahl ist eine eindeutige Kennung, die jedem von Ihrem EA platzierten Handel zugewiesen wird. Diese Kennung hilft Ihnen bei der Verfolgung und Verwaltung der Handelsgeschäfte und stellt sicher, dass Ihr EA seine eigenen Handelsgeschäfte von denen unterscheiden kann, die manuell oder von anderen EAs platziert wurden. Betrachten Sie jedes Buch in Ihrem Regal als ein Handelsgeschäft. Manchmal haben Sie vielleicht mehrere Bücher (Handelsgeschäfte), die ähnlich aussehen, aber jedes hat einen speziellen Aufkleber mit einer eindeutigen Nummer. Dieser Aufkleber hilft Ihnen, Ihre Bücher schnell zu finden und zu verwalten, ohne dabei durcheinander zu kommen.

Dieser einzigartige Aufkleber ist in Ihrem Expert Advisor (EA) als magische Zahl bekannt. Es ist eine nachvollziehbare und handhabbare Methode, um jeden Handel, den Ihr EA tätigt, zu identifizieren und sicherzustellen, dass er sich von manuellen oder von anderen EAs getätigten Geschäften unterscheiden kann.

Beispiel:

int MagicNumber = 103432;

Im Kontext der Klasse CTrade setzen Sie die magische Zahl wie folgt:

trade.SetExpertMagicNumber(MagicNumber);

Diese Zeile stellt sicher, dass jedes Geschäft, das von der Handelsinstanz platziert wird, die angegebene magische Zahl hat, sodass es leicht zu identifizieren und zu verwalten ist.

Um vorgefertigten Code zu verwenden, der komplexe Aufgaben rationalisiert, müssen Sie die erforderlichen Bibliotheken in MQL5 importieren. Bibliotheken sind vergleichbar mit Werkzeugkästen, die mit zeit- und arbeitssparenden Elementen bestückt sind. Die Verwendung dieser Bibliotheken ermöglicht es Ihnen, sich auf die besonderen Merkmale Ihres Expert Advisors (EA) zu konzentrieren, anstatt den gesamten Code von Grund auf neu schreiben zu müssen.

2. Abrufen und Analysieren von Kerzen-Daten

Es ist wichtig, die Eröffnungs- und Schlusskurse von Kerzen abzurufen und zu analysieren. Diese Informationen helfen uns, Markttrends zu verstehen und zu entscheiden, ob wir kaufen oder verkaufen sollen. Wir müssen auf die Eröffnungs- und Schlusskurse der Kerzen zugreifen, um uns ein klares Bild von den Marktbewegungen zu machen. Mit Funktionen wie CopyOpen und CopyClose können wir diese Daten effizient abrufen. Damit können wir erkennen, ob eine Kerze auf- oder abwärts ist, indem wir den Eröffnungs- und den Schlusskurs vergleichen.

2.1. CopyClose und CopyOpen Funktionen in MQL5

Um die Schluss- und Eröffnungskurse von Kerzen für ein bestimmtes Symbol und einen bestimmten Zeitrahmen zu erhalten, verwenden Sie die Funktionen CopyClose und CopyOpen von MQL5. Diese Funktionen bieten mehrere Möglichkeiten, Daten je nach Bedarf zu kopieren.

2.1.1. Aufruf durch die erste Position und Anzahl der erforderlichen Elemente

Analogie

Betrachten Sie das Bücherregal als Ihre Quelle für Kursdaten, wobei jedes Buch als Kerzen dient, der die Eröffnungs- und Schlusskurse darstellt. Sie zählten die Bücher von links und wählten den Startpunkt aus, wenn Sie mit dem Kopieren von Büchern an einer bestimmten Stelle im Regal beginnen wollten. Sie können z. B. mit dem dritten Buch beginnen, wenn Sie damit anfangen möchten.

Als Nächstes wählen Sie die Anzahl der Bücher aus, die Sie übernehmen möchten, wenn Sie eine bestimmte Anzahl von Büchern ab dieser Position kopieren möchten. Wenn Sie sich zum Beispiel für fünf Bücher entscheiden und mit dem dritten Buch beginnen, haben Sie am Ende insgesamt fünf Bücher in der Hand. Ähnlich wie bei der Wahl eines Anfangsbuches im Regal und der Festlegung, wie viele Bücher von diesem Punkt aus genommen werden sollen, können Sie bei dieser Methode mit der Funktion CopyClose eine Startposition in den Kursdaten und die Anzahl der zu kopierenden Elemente (Kerzen) angeben.

Syntax:

CopyClose(symbol_name, timeframe,  start_pos, count, close_array);
CopyOpen(symbol_name, timeframe,  start_pos, count, open_array);

Beispiel:

double close_prices[];
double open_prices[]; 
CopyClose(_Symbol, PERIOD_D1, 2, 5, close_prices); // Copy the close prices of 5 daily candlesticks starting from the 3rd candlestick
CopyOpen(_Symbol, PERIOD_D1, 2, 5, open_prices); // Copy the open prices of 5 daily candlesticks starting from the 3rd candlestick

Die Preisdaten für ein bestimmtes Symbol und einen bestimmten Zeitrahmen werden in dieser Analogie durch das Bücherregal dargestellt, das durch den Symbol_namen und den Zeitrahmen symbolisiert wird. Die Entscheidung, fünf Bücher von der Ausgangsposition (Zählung) zu nehmen, entspricht der Auswahl des dritten Buches im Regal. Die Ausgangsposition (start_pos) ist ähnlich wie diese Entscheidung. Als hielte man die ausgewählten Bücher in den Händen, speichert man die kopierten Daten im Ziel-Array (close_array).

2.1.2. Aufruf nach dem Startdatum und der Anzahl der erforderlichen Elemente

Analogie

Betrachten Sie Ihr Bücherregal als Ihre Kursdaten, wobei ein einziges Buch einem Tageswert an Kerzen-Werten entspricht. Um mit dem Kopieren der Schlusskurse eines bestimmten Datums zu beginnen, suchen Sie das Buch im Regal, das diesem Datum entspricht. Das Datum „1. Juni“ zum Beispiel ist der Zeitpunkt, an dem Sie beginnen sollten, wenn Sie zu diesem Zeitpunkt beginnen möchten.

Anschließend wählen Sie die Anzahl der Bücher aus, die Sie mitnehmen möchten, wenn Sie eine bestimmte Anzahl von Schlusskursen ab diesem Datum duplizieren möchten. Nimmt man zum Beispiel die Schlusskurse von fünf Büchern, die mit „1. Juni“ beginnen, so erhält man die Schlusskurse dieser fünf Bücher. Bei dieser Methode, die der Auswahl eines Anfangsbuchs im Regal und der Bestimmung der Anzahl der Bücher ab diesem Punkt ähnelt, wird die Funktion CopyClose verwendet, mit der Sie ein Anfangsdatum in den Kursdaten und die Anzahl der zu kopierenden Elemente (Kerzen) angeben können.

In gleicher Weise würden Sie die Funktion CopyOpen verwenden, um die offenen Kurse zu erhalten. Sie wählen das Buch aus, das einem bestimmten Datum entspricht, und wählen die Anzahl der Bücher, die Sie mitnehmen möchten, um die offenen Preise zu erhalten.

 Syntax:

CopyClose(symbol_name, timeframe,  timeframe, count, close_array[]);
CopyOpen(symbol_name, timeframe,  timeframe, count, open_array[]);

Beispiel:

close_prices[];
double open_prices[];
datetime start_date = D'2023.06.01 00:00';  // Starting from June 1st, 2023
// Copy the close prices of 5 daily candlesticks starting from June 1st, 2023
CopyClose(_Symbol, PERIOD_D1, start_date, 5, close_prices);
// Copy the open prices of 5 daily candlesticks starting from June 1st, 2023 CopyOpen(_Symbol, PERIOD_D1, start_date, 5, open_prices);

Die Preisdaten für ein bestimmtes Symbol und einen bestimmten Zeitrahmen werden in dieser Analogie durch das Bücherregal dargestellt, das durch den Symbol_namen und den Zeitrahmen symbolisiert wird. Die Auswahl des Buches im Regal, das dem „1. Juni“ entspricht, entspricht dem Startdatum (start_time), und die Auswahl von fünf Büchern ab diesem Startdatum entspricht der Anzahl der Elemente (count). Als ob Sie die ausgewählten Bücher in den Händen hielten, speichern Sie die kopierten Daten in den Ziel-Arrays (close_array und open_array).

Anhand dieser Analogie können Sie sehen, wie die Funktionen CopyClose und CopyOpen den organisierten und intuitiven Abruf bestimmter Daten aus Ihrem Preisdatenregal auf der Grundlage eines Anfangsdatums erleichtern.

2.1.3. Aufruf durch das Start- und Enddatum eines gewünschten Zeitintervalls

Analogie

Stellen Sie sich vor, dass jedes Buch in Ihrem Bücherregal eine Kerze ist, der die Eröffnungs- und Schlusskurse eines bestimmten Zeitraums anzeigt. Sie würden nach Büchern suchen, die den gesamten Zeitraum abdecken, wenn Sie die Schlusskurse für einen bestimmten Zeitraum abrufen wollten.

Zur Veranschaulichung: Nehmen wir an, Sie möchten die Schlusskurse für den 1. bis 5. Juni duplizieren. Sie würden das Buch finden, das Ihrem Anfangspunkt am 1. Juni und Ihrem Endpunkt am 5. Juni entspricht. Die Schlusspreise für diesen Zeitraum erhält man, indem man jedes Buch auswählt, das zwischen diesen beiden Daten veröffentlicht wurde.

Ähnlich wie bei der Auswahl eines Anfangs- und eines Endbuchs, um einen bestimmten Bereich im Regal abzudecken, können Sie bei dieser Methode sowohl ein Anfangs- als auch ein Enddatum angeben. Auf die gleiche Weise können Sie die Funktion CopyOpen verwenden, um die offenen Kurse zu erhalten.

Syntax:

CopyClose( symbol_name, timeframe, start_time, stop_time, close_array[]);
CopyOpen(symbol_name, timeframe, start_time, stop_time, open_array[]);

Beispiel:

double close_prices[];
double open_prices[];
datetime start_date = D'2023.06.01 00:00'; // Starting from June 1st, 2023
datetime end_date = D'2023.06.05 00:00'; // Ending on June 5th, 2023
// Copy the close prices from June 1st to June 5th
CopyClose(_Symbol, PERIOD_D1, start_date, end_date, close_prices);
// Copy the open prices from June 1st to June 5th
CopyOpen(_Symbol, PERIOD_D1, start_date, end_date, open_prices);

Die Preisdaten für ein bestimmtes Symbol und einen bestimmten Zeitrahmen werden in dieser Analogie durch das Bücherregal dargestellt, das durch den Symbol_namen und den Zeitrahmen symbolisiert wird. Das Startdatum (start_time) entspricht der Auswahl des Buches, das dem „1. Juni“ im Regal entspricht, und das Enddatum (stop_time) entspricht der Suche nach dem Buch, das dem „5. Juni“ entspricht. Als ob Sie die ausgewählten Bücher in den Händen hielten, speichern Sie die kopierten Daten in den Ziel-Arrays (close_array und open_array).

Wenn Sie diese Analogie verstehen, können Sie sehen, wie die Funktionen CopyClose und CopyOpen Ihnen helfen, bestimmte Daten auf der Grundlage eines Start- und Enddatums aus Ihrem Preisdatenbuch abzurufen, wodurch der Datenabrufprozess intuitiv und organisiert wird.

Ein Zeichenkette in einen Zeitwert umwandeln

Bei der Arbeit mit Expert Advisors, die innerhalb eines bestimmten Zeitfensters während des Tages arbeiten, kann es schwierig sein, die Methode des Aufrufs durch das Start- und Enddatum eines gewünschten Zeitintervalls zu verwenden. Das Hauptproblem ist, dass sich die Daten ändern, die Zeit aber nicht. Wir automatisieren unsere Expert Advisors, daher ist es nicht möglich, das Datum jeden Tag manuell einzugeben.

Analogie

Stellen Sie sich eine Bibliothek vor, in der die Regale nach Datum und Tageszeit geordnet sind. Sie müssen den Tag und die Uhrzeit kennen, wenn Sie zu einer bestimmten Tageszeit Bücher lesen (oder Daten abrufen) wollen. Es kann mühsam sein, das Datum jeden Tag zu aktualisieren, um die entsprechenden Bücher aus den Regalen zu holen.  Betrachten Sie die Zeitstrings als Etiketten, die Sie den einzelnen Stunden, die Sie lesen möchten, zuordnen, um diesen Prozess (Abrufen von Daten) zu rationalisieren.

Beispiel:

// Declaring time strings
string start_time_str = "00:00";  // Start time
string end_time_str = "20:00";    // End time

//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {

// Converting time strings to datetime values
   datetime start_time = StringToTime(start_time_str);
   datetime end_time = StringToTime(end_time_str);

   Print("start_time: ", start_time,"\nend_time: ",end_time);

  }

Erläuterung:

// Deklaration von Zeitstrings: start_time_str = „00:00“; // Startzeit, end_time_str = „20:00“; // Endzeit

• Betrachten Sie die Zeitstrings als Etiketten, die Sie den einzelnen Stunden, die Sie lesen möchten, zuordnen, um diesen Prozess (Abrufen von Daten) zu rationalisieren.

// Umwandlung von Zeitstrings in Zeitwerte: datetime start_time = StringToTime(start_time_str); datetime end_time = StringToTime(end_time_str);

• Wenn Sie die Funktion StringToTime verwenden, ist es so, als hätten Sie ein magisches Lesezeichen, das an jedem beliebigen Tag genau weiß, auf welches Regal es zeigen muss. Dies gilt unabhängig vom Datum. Auf diese Weise müssen Sie sich nicht mehr darum kümmern, das Datum jeden Tag zu ändern. Durch die Garantie, dass sich start_time und end_time stets auf die aktuelle Zeit im Regal beziehen, ist es einfach, die entsprechenden Bücher (Daten) abzurufen, ohne dass manuelle Aktualisierungen erforderlich sind.

Ausgabe:

Umsetzung im EA

Beispiel:

#include <Trade/Trade.mqh>

// Create an instance of the CTrade class for trading operations
CTrade trade;

// Unique identifier for the EA's trades
int MagicNumber = 103432;

// Arrays to store the previous day's open and close prices
double daily_close[];
double daily_open[];

// Arrays to store the first H1 bar's open and close prices of the day
double first_h1_price_close[];

// Arrays to store H1 bars' open and close prices
double H1_price_close[];
double H1_price_open[];

// Strings to define the trading start and end times and the first trade time
string start = "00:00";
string end = "20:00";
string firsttrade  = "02:00";

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   trade.SetExpertMagicNumber(MagicNumber);
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
// Convert time strings to datetime format
   datetime start_time = StringToTime(start); // Convert start time string to datetime
   datetime end_time = StringToTime(end); // Convert end time string to datetime
   datetime current_time = TimeCurrent(); // Get the current time
   datetime first_tradetime = StringToTime(firsttrade); // Convert first trade time string to datetime

// Copy daily close and open prices
   CopyClose(_Symbol, PERIOD_D1, 1, 1, daily_close); // Copy the close price of the previous day
   CopyOpen(_Symbol, PERIOD_D1, 1, 1, daily_open); // Copy the open price of the previous day


// Set the arrays to be copied from right to left (latest to oldest)
   ArraySetAsSeries(daily_close, true); // Set daily_close array as series
   ArraySetAsSeries(daily_open, true); // Set daily_open array as series

// Copy close and open prices for the first H1 bar of the day
   CopyClose(_Symbol, PERIOD_H1, start_time, 1, first_h1_price_close); // Copy the close price of the first H1 bar

// Copy close prices for the latest 5 H1 bars
   CopyClose(_Symbol, PERIOD_H1, 0, 5, H1_price_close); // Copy the close prices of the latest 5 H1 bars
   CopyOpen(_Symbol, PERIOD_H1, 0, 5, H1_price_open); // Copy the open prices of the latest 5 H1 bars

// Set the arrays to be copied from right to left (latest to oldest)
   ArraySetAsSeries(H1_price_close, true); // Set H1_price_close array as series
   ArraySetAsSeries(H1_price_open, true); // Set H1_price_open array as series

// If the last daily bar is bearish
   if(daily_close[0] < daily_open[0])
     {
      // Check specific conditions for a sell trade
      if(H1_price_close[2] >= first_h1_price_close[0] && H1_price_close[1] < first_h1_price_close[0] && current_time >= first_tradetime)
        {

         Comment("Its a sell");

        }

     }

// If the last daily bar is bullish
   if(daily_close[0] > daily_open[0])
     {
      // Check specific conditions for a buy trade
      if(H1_price_close[2] <= first_h1_price_close[0] && H1_price_close[1] > first_h1_price_close[0] && current_time >= first_tradetime)
        {
         Comment("Its a buy");
        }
     }

  }

Erläuterung:

Zunächst importieren wir die erforderliche Handelsbibliothek mit #include <Trade/Trade.mqh>, damit wir handelsbezogene Funktionen verwenden können. Als Nächstes erstellen wir eine Instanz der Klasse CTrade, CTrade trade, die unsere Handelsoperationen erleichtern wird. Wir definieren auch einen eindeutigen Bezeichner für die Trades unseres EAs mit int MagicNumber = 103432;.

Anschließend werden Arrays deklariert, um die Eröffnungs- und Schlusskurse des Vortags, die Eröffnungs- und Schlusskurse des ersten H1-Balkens des Tages und die Eröffnungs- und Schlusskurse der H1-Balken zu speichern. Diese Arrays enthalten die abgerufenen Kursdaten, die wir analysieren werden, um Handelsentscheidungen zu treffen. Die Start- und Endzeiten des Handels und die erste Handelszeit werden als Strings definiert, die wir später in das Datumsformat konvertieren. In der Funktion OnInit setzen wir die magische Zahl des Experten zur Identifizierung unserer Trades, in der Funktion OnTick konvertieren wir die Zeitstrings in das Datetime-Format und rufen die aktuelle Zeit ab. Anschließend verwenden wir die Funktionen CopyClose und CopyOpen, um die Tages- und H1-Kerzen-Daten in die entsprechenden Arrays zu kopieren. Die Funktion ArraySetAsSeries stellt die Arrays so ein, dass sie von rechts nach links kopiert werden, wobei sichergestellt wird, dass die neuesten Daten bei Index 0 stehen.

Schließlich analysieren wir die abgerufenen Kerzen-Daten, um die Marktstimmung zu ermitteln. Wenn der letzte Tagesbalken fällt, prüfen wir bestimmte Bedingungen, um uns für einen Verkauf zu entscheiden. Wenn der letzte Tagesbalken aufwärts zeigt, prüfen wir die Bedingungen für einen Kauf. Die Kommentarfunktion zeigt die Handelsentscheidung im Chart an. Dieser Beispielcode richtet die Struktur ein, um die Eröffnungs- und Schlusskurse von Tages- und 1-Stunden-Kerzen abzurufen und zu analysieren, und verwendet diese Analyse dann zur Bestimmung der Handelsrichtung.

3. Implementierung der Handelsausführung

3.1 Wie man in MQL5 kauft und verkauft

In diesem Abschnitt werden die grundlegenden Schritte behandelt, die für die Ausführung von Kauf- und Verkaufsaufträgen in MQL5 erforderlich sind, einschließlich der Bestimmung der Stop-Loss und Take-Profit. Es wird die Klasse CTrade aus der Bibliothek Trade.mqh verwendet, die grundlegende Methoden zur Durchführung von Trades bietet.

Platzierung von Kauf- und Verkaufsaufträgen:

Wir verwenden die Methoden Buy und Sell der Klasse CTrade, um Kauf- und Verkaufsaufträge zu erteilen. Dank dieser Techniken können wir mit wenig Code Handel treiben. Betrachten Sie die Klasse CTrade als ein spezielles, auf Handelsfunktionen ausgerichtetes Regal in einer Bibliothek. Wir brauchen nur das gewünschte Buch (Methode) aus dem Regal zu nehmen und es anzuwenden, wenn wir einen Handel durchführen wollen.

Festlegen von Stop-Loss (SL) und Take-Profit (TP):

TP- und SL sind für das Risikomanagement entscheidend. Während TP den gewünschten Gewinn angibt, gibt SL den maximalen Verlust an, den Sie zu akzeptieren bereit sind. Für beide werden Preispunkte in Bezug auf den aktuellen Marktpreis angegeben. Betrachten Sie SL und TP als Lesezeichen in einem Buch, die angeben, wo Sie aufhören (SL), wenn etwas schief geht, und wo Sie Ihre Belohnung (TP) nehmen, wenn alles gut läuft.

Beispiel:

#include <Trade/Trade.mqh> // Include the trade library for trading functions

// Create an instance of the CTrade class for trading operations
CTrade trade;

// Unique identifier for the EA's trades
int MagicNumber = 103432;

// Arrays to store the previous day's open and close prices
double daily_close[];
double daily_open[];

// Arrays to store the first H1 bar's open and close prices of the day
double first_h1_price_close[];

// Arrays to store H1 bars' open and close prices
double H1_price_close[];
double H1_price_open[];

// Strings to define the trading start and end times and the first trade time
string start = "00:00";
string end = "20:00";
string firsttrade  = "02:00";

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   trade.SetExpertMagicNumber(MagicNumber);
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
// Convert time strings to datetime format
   datetime start_time = StringToTime(start); // Convert start time string to datetime
   datetime end_time = StringToTime(end); // Convert end time string to datetime
   datetime current_time = TimeCurrent(); // Get the current time
   datetime first_tradetime = StringToTime(firsttrade); // Convert first trade time string to datetime

// Copy daily close and open prices
   CopyClose(_Symbol, PERIOD_D1, 1, 1, daily_close); // Copy the close price of the previous day
   CopyOpen(_Symbol, PERIOD_D1, 1, 1, daily_open); // Copy the open price of the previous day

// Set the arrays to be copied from right to left (latest to oldest)
   ArraySetAsSeries(daily_close, true); // Set daily_close array as series
   ArraySetAsSeries(daily_open, true); // Set daily_open array as series

// Copy close and open prices for the first H1 bar of the day
   CopyClose(_Symbol, PERIOD_H1, start_time, 1, first_h1_price_close); // Copy the close price of the first H1 bar

// Copy close prices for the latest 5 H1 bars
   CopyClose(_Symbol, PERIOD_H1, 0, 5, H1_price_close); // Copy the close prices of the latest 5 H1 bars
   CopyOpen(_Symbol, PERIOD_H1, 0, 5, H1_price_open); // Copy the open prices of the latest 5 H1 bars

// Set the arrays to be copied from right to left (latest to oldest)
   ArraySetAsSeries(H1_price_close, true); // Set H1_price_close array as series
   ArraySetAsSeries(H1_price_open, true); // Set H1_price_open array as series

// Get the symbol point size
   double symbol_point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);

// Get the current Bid price
   double Bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);

// Calculate the stop loss and take profit prices for sell
   double tp_sell = Bid - 400 * symbol_point;
   double sl_sell = Bid + 100 * symbol_point;

// Get the current Ask price
   double Ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);

// Calculate the stop loss and take profit prices for buy
   double tp_buy = Ask + 400 * symbol_point;
   double sl_buy = Ask - 100 * symbol_point;

// If the last daily bar is bearish
   if(daily_close[0] < daily_open[0])
     {
      // Check specific conditions for a sell trade
      if(H1_price_close[2] >= first_h1_price_close[0] && H1_price_close[1] < first_h1_price_close[0] && current_time >= first_tradetime)
        {
         // Execute the sell trade
         trade.Sell(1.0, _Symbol, Bid, sl_sell, tp_sell); // Replace with your lot size
         Comment("It's a sell");
        }
     }

// If the last daily bar is bullish
   if(daily_close[0] > daily_open[0])
     {
      // Check specific conditions for a buy trade
      if(H1_price_close[2] <= first_h1_price_close[0] && H1_price_close[1] > first_h1_price_close[0] && current_time >= first_tradetime)
        {
         // Execute the buy trade
         trade.Buy(1.0, _Symbol, Ask, sl_buy, tp_buy); // Replace with your lot size
         Comment("It's a buy");
        }
     }
  }

Erläuterung:

• Mit #include binden wir die Handelsbibliothek ein.
• Wir konstruieren eine Handelsinstanz der Klasse CTrade.
• Auf der Grundlage der aktuellen Geld- und Briefkurse sowie der Punktgröße des Symbols bestimmen wir SL und TP.
• Wir verwenden die Kauf- und Verkaufsmethoden, um Aufträge mit den angegebenen SL- und TP zu platzieren.

Parameter von trade.Buy und trade.Sell:

• Losgröße: Das Volumen des Handels.
• _Symbol: Das Symbol, für das der Handel ausgeführt wird (z. B. EURUSD).
• Fragen/Bieten: Der aktuelle Ask-Kurs für Kaufgeschäfte oder Bid-Kurs für Verkaufsgeschäfte.
• sl: Das Stop-Loss-Kursniveau.
• tp: Das Preisniveau für die Gewinnmitnahme.

In diesem Artikel haben wir besprochen, wie man bestimmte Kerzen-Daten wie den Eröffnungs- und Schlusskurs erhält und wie man Kauf- und Verkaufsaufträge erteilt. Diese Progression ist für Sie als Anfänger von entscheidender Bedeutung, da sie die Grundlagen für die Einbeziehung von Handelsgeschäften in Ihr Programm erläutert. Die Aufträge können jedoch aufgrund von OnTick weiterhin bei jedem Tick gesendet werden.

Es ist wichtig, den Expert Advisor (EA) auf jeweils einen Handel zu beschränken, um das Risiko zu kontrollieren und ein Überhandeln zu verhindern. Zu diesem Zweck muss eine Logik implementiert werden, die feststellt, ob offene Positionen bestehen, bevor ein neuer Abschluss getätigt wird. Diese Strategie trägt dazu bei, übermäßiges Handeln zu verhindern, indem sie sicherstellt, dass Geschäfte nur bei Bedarf ausgeführt werden.

Verhinderung von neuen Positionen bei jedem Tick:

Die Ereignisbehandlung durch OnTick könnte bei jedem Tick zu neuen Position führen. Wir stellen sicher, dass nur dann gehandelt wird, wenn es notwendig ist, indem wir eine Kontrolle für neue Bars und offene Positionen einrichten. Betrachten Sie jeden neuen Balken als ein Buch, das zu unserer Sammlung hinzugefügt wurde. Wir stellen sicher, dass im Moment kein anderes Buch (Handel) gelesen wird und wählen nur dann „lesen“ (Handel), wenn ein neues Buch (Bar) hinzugefügt wird.

Beispiel:

// Flag to indicate a new bar has formed
bool newBar;

// Variable to store the time of the last bar
datetime lastBarTime;

// Array to store bar data (OHLC)
MqlRates bar[];

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {

// Check for a new bar
   CopyRates(_Symbol, PERIOD_H1, 0, 3, bar); // Copy the latest 3 H1 bars
   if(bar[0].time > lastBarTime)  // Check if the latest bar time is greater than the last recorded bar time
     {
      newBar = true; // Set the newBar flag to true
      lastBarTime = bar[0].time; // Update the last bar time
     }
   else
     {
      newBar = false; // Set the newBar flag to false
     }

// If a new bar has formed
   if(newBar == true)
     {
      // If the last daily bar is bearish
      if(daily_close[0] < daily_open[0])
        {
         // Check specific conditions for a sell trade
         if(H1_price_close[2] >= first_h1_price_close[0] && H1_price_close[1] < first_h1_price_close[0] && current_time >= first_tradetime)
           {
            // Execute the sell trade
            trade.Sell(1.0, _Symbol, Bid, sl_sell, tp_sell); // Replace with your lot size
            Comment("It's a sell");
           }
        }

      // If the last daily bar is bullish
      if(daily_close[0] > daily_open[0])
        {
         // Check specific conditions for a buy trade
         if(H1_price_close[2] <= first_h1_price_close[0] && H1_price_close[1] > first_h1_price_close[0] && current_time >= first_tradetime)
           {
            // Execute the buy trade
            trade.Buy(1.0, _Symbol, Ask, sl_buy, tp_buy); // Replace with your lot size
            Comment("It's a buy");
           }
        }

     }

  }

Erläuterung:

bool newBar;

• Um anzuzeigen, ob sich ein neuer Balken (Kerzen) gebildet hat, wird in dieser Zeile eine boolesche Variable namens newBar deklariert.

datetime lastBarTime;

• Um den Zeitpunkt des letzten verarbeiteten Taktes zu speichern, wird in dieser Zeile eine Variable namens lastBarTime vom Typ datetime deklariert.

MqlRates bar[];

• Diese Zeile deklariert ein Array bar vom Typ MqlRates. In diesem Array werden Bar-Daten wie Open, High, Low und Close (OHLC) Preise gespeichert.

CopyRates(_Symbol, PERIOD_H1, 0, 3, bar); // Kopieren der letzten 3 H1-Balken

• Die letzten drei Stunden-Balken (H1) für das aktuelle Symbol (_Symbol) werden mit der Funktion CopyRates in dieser Zeile in das Balken-Array kopiert.

if (bar[0].time > lastBarTime)

• In dieser Zeile wird ermittelt, ob die Zeit des letzten Balkens (bar[0].time) die Zeit des vorherigen Balkens überschreitet. Wenn das stimmt, ist eine neue Bar entstanden.

newBar = true;

• Das newBar-Flag wird auf true gesetzt, wenn sich ein neuer Balken gebildet hat.

lastBarTime = bar[0].time;

• Der Zeitpunkt des letzten Balkens wird in der Variablen lastBarTime aktualisiert.

sonst {

newBar = false;

        }

• Wenn der Zeitpunkt des letzten Balkens nicht größer ist als lastBarTime, wird das newBar-Flag auf false gesetzt.

if (newBar == true)

{

 // mach das

}

• Wenn sich ein neuer Balken gebildet hat, „mach das“.

Dieser Code stellt sicher, dass der Code innerhalb der if-Anweisung nur dann ausgeführt wird, wenn sich ein neuer Balken bildet, und nicht bei jedem Tick. Dazu wird ermittelt, ob die Zeit des letzten Taktes länger ist als die zuletzt aufgezeichnete Taktzeit. Auf dieser Grundlage können wir feststellen, wann ein neuer Balken gebildet wird, und das newBar-Flag entsprechend setzen. Dadurch wird vermieden, dass der Code innerhalb des „if (newBar == true)“-Blocks bei jedem Tick wiederholt ausgeführt wird, was die Leistung des Expert Advisors verbessert und unnötige Aktionen vermeidet.

3.2 Begrenzung des EA auf eine offene Position zur gleichen Zeit

Da die Handelsausführung jetzt erst bei der Bildung eines neuen Balkens eingeleitet wird, können wir unseren EA noch weiter verbessern, indem wir die Anzahl der offenen Positionen begrenzen. Auf diese Weise wird der EA nur dann einen neuen Handel einleiten, wenn keine anderen Geschäfte anstehen.

Das ist die Logik:

• Suche nach offenen Positionen: Wir prüfen, ob es noch offene Positionen gibt, bevor wir einen neuen Handel eingehen. Der EA wird einen Handel platzieren, wenn es keine offenen Positionen gibt.
• Keine neuen Positionen bei jedem Tick: Wir stellen sicher, dass nur dann gehandelt wird, wenn es unbedingt notwendig ist, indem wir eine Prüfung auf neue Balken und offene Positionen hinzufügen.

Betrachten Sie jeden neuen Balken als ein neues Buch, das unserer Bibliothek hinzugefügt wurde. Wir entscheiden uns erst dann für „Lesen“ (Handel), wenn ein neues Buch (Balken) hinzugefügt wird, nachdem wir uns vergewissert haben, dass kein anderes Buch (Handel) gerade gelesen wird.

Beispiel:

// Initialize the total number of positions being held
int totalPositions = 0;
for(int i = 0; i < PositionsTotal(); i++)
  {
// Get the ticket number for the position
   ulong ticket = PositionGetTicket(i);

// Check if the position's magic number matches
   if(PositionGetInteger(POSITION_MAGIC) == MagicNumber)
     {
      // Increment the total positions count
      totalPositions++;
     }
  }

Erläuterung:

int totalPositions = 0;

• In dieser Zeile wird die Integer-Variable totalPositions deklariert und auf Null gesetzt. Die Anzahl der offenen Positionen, die der Expert Advisor (EA) derzeit hält, wird über diese Variable gezählt.

for (int i = 0; i < PositionsTotal(); i++)

• In dieser for-Schleife wird jede offene Position iterativ durchlaufen. Die Gesamtzahl der offenen Positionen im Handelsterminal wird von der Funktion PositionsTotal() zurückgegeben.
• i: Ein iterativer Schleifenzähler, der bei 0 beginnt und sich jedes Mal um 1 erhöht. Solange i kleiner ist als PositionsTotal(), wird die Schleife fortgesetzt.

  ulong ticket = PositionGetTicket(i);

• In dieser Zeile wird die Ticketnummer für die Position am Index i abgefragt. Die Ticketnummer für die Position mit dem angegebenen Index wird von der Funktion PositionGetTicket(i) zurückgegeben.
• Ticket: Eine Variable vom Typ ulong (unsigned long), die die Ticketnummer der aktuell untersuchten Position speichert.

if (PositionGetInteger(POSITION_MAGIC) == MagicNumber)

• Diese if-Anweisung ermittelt, ob die dem EA zugewiesene magische Zahl (MagicNumber) und die magische Zahl der aktuellen Position übereinstimmen
• PositionGetInteger(POSITION_MAGIC): Eine Funktion, die den Ganzzahlwert der angegebenen Eigenschaft (in diesem Fall die magische Zahl) für die aktuelle Position abruft.
• Magische Zahl: eine vorher festgelegte Konstante, die als eindeutige Handelskennung für diesen EA dient. Sie garantiert, dass nur Positionen gezählt werden, die der EA eröffnet hat.

totalPositions++;

• Diese Zeile erhöht den Zähler totalPositions um 1, wenn die magische Zahl der aktuellen Position mit MagicNumber übereinstimmt. Im Wesentlichen handelt es sich dabei um die Anzahl der Positionen, die dieser bestimmte EA eröffnet hat.

  Dieser Codeblock wird verwendet, um die Anzahl der Positionen zu zählen, die derzeit vom EA gehalten werden. Sie tut dies durch:

• Initialisierung eines Zählers (totalPositions) auf Null.
• Schleifenbildung durch alle offenen Positionen mit einer for-Schleife.
• Für jede Position wird die entsprechende Ticketnummer ermittelt.
• Prüfen, ob die magische Zahl der Position mit der magischen Zahl des EA übereinstimmt.
• Wenn es eine Übereinstimmung gibt, wird der Zähler totalPositions erhöht.

3.3 Begrenzung des EA auf maximal zwei Positionen pro Tag

Wir werden sicherstellen, dass der EA nur maximal zwei Positionen pro Tag eröffnet, um eine Überbeanspruchung zu verhindern, da der EA nun bei jedem neuen Balken Trades basierend auf bestimmten Bedingungen ausführt.

Details zur Umsetzung

Dieser Abschnitt des Codes filtert den Handelsverlauf für den aktuellen Tag mithilfe der Funktion HistorySelect. Als Nächstes verwenden wir die eindeutige magische Zahl des EA, um eine Schleife durch den gewählten Handelsverlauf zu ziehen und die Anzahl der vom Algorithmus getätigten Geschäfte zu zählen. Wir zählen nur die Einstiegsgeschäfte, indem wir die Art der einzelnen Geschäfte überprüfen. Der EA eröffnet für den Rest des Tages keine neuen Trades mehr, wenn insgesamt zwei Entry Trades vorhanden sind.

Betrachten Sie es so, als ob Sie ein Bücherregal beaufsichtigen, in dem jedes Buch einen Beruf darstellt. Es gibt nur Platz für zwei neue Bücher pro Tag. Erst am nächsten Tag, nachdem Sie diese beiden Bücher ins Regal gestellt haben, stellen Sie weitere Bücher in das Regal. Auf diese Weise erhalten Sie eine geordnete und überschaubare Sammlung, die Unordnung verhindert (Over-Trading) und für Ordnung sorgt (Risikomanagement).

Beispiel:

// Select the trading history within the specified time range
bool success = HistorySelect(start_time, end_time); // Select the trading history

// Initialize the total number of trades for the day
int totalDeal = 0;
if(success)
  {
   for(int i = 0; i < HistoryDealsTotal(); i++)
     {
      // Get the ticket number for the deal
      ulong ticket = HistoryDealGetTicket(i);

      // Check if the deal's magic number matches
      if(HistoryDealGetInteger(ticket, DEAL_MAGIC) == MagicNumber)
        {
         // Check if the deal was an entry
         if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_IN)
           {
            // Increment the total deal count
            totalDeal++;
           }
        }
     }
  }

Erläuterung:

• HistorySelect: filtere den Handelsverlauf des Tages.
• totalDeal: Zähler für die Erfassung des Handelsvolumens.
• Schleife durch den Handelsverlauf: Um die Positionen zu zählen, durchlaufen Sie den Handelsverlauf.
• Überprüfen der magische Zahl: Überprüfe, ob die Position zu unserm EA gehört.
• Neue Positionen werden gezählt, indem der Zähler erhöht wird.

Dieser Code stellt sicher, dass der EA nur bis zu zwei Mal pro Tag handelt, um einen disziplinierten Handelsansatz beizubehalten und das Risiko einer Überbeanspruchung des Handels zu verringern.

3.4 Begrenzung des Gewinns oder Verlusts für den Tag

In diesem Abschnitt stellen wir sicher, dass der Expert Advisor den täglichen Gesamtgewinn oder -verlust nicht überschreitet.

// Initialize the total profit
double totalProfit = 0;
long dealsMagic = 0;
double profit = 0;
if(success)
  {
   for(int i = 0; i < HistoryDealsTotal(); i++)
     {
      // Get the ticket number for the deal
      ulong ticket = HistoryDealGetTicket(i);

      // Check if the deal was an entry
      if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_IN)
        {
         // Get the magic number of the deal
         dealsMagic = HistoryDealGetInteger(ticket, DEAL_MAGIC);
        }

      // Check if the deal was an exit
      if(HistoryDealGetInteger(ticket, DEAL_ENTRY) == DEAL_ENTRY_OUT)
        {
         // Get the profit of the deal
         profit = HistoryDealGetDouble(ticket, DEAL_PROFIT);

         // Check if the magic number matches
         if(MagicNumber == dealsMagic)
           {
            // Add the profit to the total profit
            totalProfit += profit;
           }
        }
     }
  }

Erläuterung:

• HistorySelect: filtere den Handelsverlauf des Tages.
• totalProfit: Zähler, um den Gesamtgewinn oder -verlust für den Tag zu verfolgen.
• Iteriert den Handelsverlauf in einer Schleife, um die Gewinne und Verluste zu summieren.
• Überprüfung der Eröffnungen der Deals: Ermittelt die magische Zahl für jede Transaktion.
• Überprüfung das Deal-Ausstiegs indem der Gewinn für jeden abgeschlossenen Handel berechnet wird.
• Zum Gesamtgewinn hinzufügen: Kumuliert den Gewinn oder Verlust für Geschäfte mit der entsprechenden magischen Zahl.

Diese Strategie reduziert das Risiko, indem sie zusätzliche Geschäfte stoppt, nachdem eine vorher festgelegte Gewinn- oder Verlustschwelle für den Tag erreicht wurde. Das garantiert einen kontrollierten Handel und hilft, einen überbordenden Handel zu vermeiden, der das Risiko erhöht.

3.5 Schließen aller offenen Positionen zu einem bestimmten Zeitpunkt

Dieser Abschnitt behandelt die Verwendung des MQL5-Frameworks zur Implementierung einer solchen Funktion. Infolgedessen ist die Wahrscheinlichkeit unvorhergesehener Marktschwankungen geringer, da nachts oder außerhalb der Haupthandelszeiten keine Handelsgeschäfte offen gelassen werden. Betrachten Sie dies als das Ende der Öffnungszeiten der Bibliothek. Wir stellen sicher, dass alle Positionen zum vorgesehenen Zeitpunkt geschlossen werden, so wie ein Bibliothekar sicherstellt, dass alle Bücher (Trades) am Ende des Tages zurückgegeben und abgerechnet werden.

// Close trades at the specified end time
for(int i = 0; i < PositionsTotal(); i++)
  {
// Get the ticket number for the position
   ulong ticket = PositionGetTicket(i);

// Check if the position's magic number matches and if it's the end time
   if(PositionGetInteger(POSITION_MAGIC) == MagicNumber && current_time == end_time)
     {
      // Close the position
      trade.PositionClose(ticket);
     }
  }

Erläuterung:

Dieser Teil ruft die eindeutige Ticketnummer für jede offene Position ab, indem er sie alle durchläuft. Anschließend wird überprüft, ob die magische Zahl der Position mit der magischen Zahl des EA übereinstimmt und ob die aktuelle Zeit innerhalb der angegebenen Endzeit liegt. Die Funktion PositionClose der Klasse CTrade wird verwendet, um die Position zu schließen, wenn diese Anforderungen erfüllt sind.

3.6 Festlegen der Wochentage, an denen ein EA handeln kann

Der aktuelle Wochentag muss ermittelt und mit unseren Handelsregeln verglichen werden, um zu gewährleisten, dass unser Expert Advisor (EA) nur an bestimmten Wochentagen handelt.

Beispiel:

//getting the day of week and month
MqlDateTime day; //Declare an MqlDateTime structure to hold the current time and date
TimeCurrent(day); // Get the current time and fill the MqlDateTime structure
int week_day = day.day_of_week; //Extract the day of the week (0 = Sunday, 1 = Monday, ..., 6 = Saturday)

//getting the current month
MqlDateTime month; //Declare a structure to hold current month information
TimeCurrent(month); //Get the current date and time
int year_month = month.mon; //Extract the month component (1 for January, 2 for February, ..., 12 for December)

if(week_day == 5)
  {
   Comment("No trades on fridays", "\nday of week: ",week_day);
  }
else
   if(week_day == 4)
     {
      Comment("No trades on Thursdays", "\nday of week: ",week_day);
     }
   else
     {
      Comment(week_day);
     }

Erläuterung:

Wir müssen den aktuellen Wochentag ermitteln und ihn mit vorgegebenen Richtlinien vergleichen, um die Tage zu bestimmen, an denen ein Expert Advisor (EA) handeln darf. Um das aktuelle Datum und die Uhrzeit zu speichern, deklarieren wir zunächst eine MqlDateTime-Struktur. Zunächst füllen wir diese Struktur mit dem aktuellen Monat und Wochentag mit Hilfe der Funktion TimeCurrent().

Als Nächstes wird der Wochentag mit Hilfe von bedingten Anweisungen überprüft. Der Code zeigt eine Meldung an, die besagt, dass freitags kein Handel erlaubt sind, wenn der aktuelle Tag ein Freitag ist (angezeigt durch den Wert 5). In ähnlicher Weise bedeutet Donnerstag (Wert 4), dass donnerstags kein Handel erlaubt ist. Der Code zeigt an, dass der Handel an allen anderen Tagen erlaubt ist, indem er einfach den aktuellen Wochentag anzeigt.

Analogie

Betrachten Sie jeden Tag der Woche als eine andere Art von Buch, das in einer Bibliothek zu finden ist.

• Freitag (5): Der Code verbietet den Handel an Freitagen, ebenso wie er die Ausleihe von Kriminalromanen an Freitagen verbietet.
• Donnerstag (4): Der Code wird donnerstags nicht mehr gehandelt, so wie Science-Fiction-Romane donnerstags nicht ausgeliehen werden können.
• Andere Tage: Der Code erlaubt den Handel für alle anderen Genres (Tage), genauso wie für Buchgenres.

Schlussfolgerung

Wir haben in diesem Artikel eine projektbasierte Lernmethodik verwendet, um es jedem leicht zu machen, die Grundlagen des algorithmischen Handels mit MQL5 zu verstehen, auch völligen Anfängern. Sie haben gelernt, wie man grundlegende Aufgaben wie das Kaufen und Verkaufen in MQL5 durchführt, wie man die Eröffnungs- und Schlusskurse von Kerzen ermittelt und wie man Strategien einsetzt, um den Handel bei jedem Tick zu verhindern. Sie haben auch gelernt, wie Sie wichtige Aspekte des automatisierten Handels steuern können, z. B. die Beschränkung eines EA auf jeweils einen Handel, die Festlegung von Handelstagen und -zeiträumen sowie die Festlegung von Gewinn- und Verlustgrenzen.

Wenn Sie Fragen zu den in diesem Artikel behandelten Themen haben, können Sie diese gerne stellen, während Sie Ihre Reise fortsetzen. Ich bin hier, um Ihnen zu helfen, sei es beim Verständnis bestimmter Code-Implementierungen oder bei der Klärung der Frage, wie sich diese Konzepte auf verschiedene Handelsstrategien beziehen. Setzen Sie sich mit uns in Verbindung, und wir besprechen gemeinsam, wie Sie Ihr Verständnis und Ihre Nutzung des algorithmischen Handels mit MQL5 verbessern können. Erinnern Sie sich daran, dass die Beherrschung jeder Programmiersprache, einschließlich MQL5, ein Weg zum algorithmischen Handel ist. Natürlich kann man nicht alles auf einmal verstehen. Sie werden Ihre Kenntnisse und Fähigkeiten schrittweise durch projektbasiertes Lernen erweitern, bei dem Sie Konzepte auf reale Projekte anwenden, die den von uns untersuchten ähnlich sind. Jedes Projekt dient als Sprungbrett, das Ihre Fähigkeiten und Ihr Selbstvertrauen schrittweise steigert.