Entwicklung des Swing Entries Monitoring (EA)

MetaTrader 5 — Beispiele | 29 April 2025, 08:03

123

Clemence Benjamin

Inhalt:

Einführung

BTCUSD ist eines der herausragenden Handelspaare mit einem bedeutenden langfristigen Ausblick. Heute haben wir sie als Beispiel ausgewählt, um unseren Entwicklungsprozess anzuleiten.

Der Bitcoin-Kurs ist durch eine hohe Volatilität gekennzeichnet, die von der Marktstimmung, makroökonomischen Faktoren und der sich entwickelnden Regulierungslandschaft bestimmt wird. Die Identifizierung profitabler Einstiegsniveaus inmitten dieser Schwankungen ist eine schwierige Aufgabe, insbesondere für Händler, die sich ausschließlich auf manuelle Analysen verlassen. So schwankte der BTC-Kurs in den letzten zwei Jahren zwischen Tiefstständen um 16.000 US-Dollar und seinem Allzeithoch von 99.645,39 US-Dollar im November 2024. In diesem Zeitraum ergaben sich mehrere wichtige Einstiegsmöglichkeiten rund um den EMA 100, die wertvolle Erkenntnisse für langfristige Handelsstrategien bieten.

Die Lösung für die obige Herausforderung ist die Entwicklung eines MQL5-Überwachungs-EAs für langfristige Handelseinstiegssignale. Dieser EA wird:

die Kursbewegungen eines bestimmten Paares kontinuierlich beobachten,
den EMA 100 als dynamisches Unterstützungs- oder Widerstandsniveau verwenden, um potenzielle Einstiegsmöglichkeiten zu erkennen,
den Händler benachrichtigen, wenn bestimmte Bedingungen erfüllt sind, z. B. wenn der Kurs am EMA 100 abprallt.

Dieses Tool wird die Analyse automatisieren und es den Händlern ermöglichen, sich auf die Entscheidungsfindung zu konzentrieren, anstatt ständig zu überwachen.

Die folgende Abbildung zeigt die wichtigsten Unterstützungsniveaus für BTC, die mit dem 100-Tage-EMA übereinstimmen.

BTC - PREISABPRALL VOM 100-TAGE MA

BTCUSD, H4: Bitcoin gegen US Dollar: Abprallen des Kurses vom EMA 100

Ein kurzer Rückblick auf BTCUSD von 2021 bis 2024

Zwischen 2021 und 2024 erlebte der Bitcoin dramatische Preisveränderungen. Nach einem steilen Rückgang im Jahr 2022, der aufgrund steigender Zinssätze und Marktabschwünge unter 20.000 $ endete, erholte es sich 2023 wieder, begann bei 16.530 $ und endete bei 42.258 $. Im Jahr 2024 stieg Bitcoin nach der Zulassung von Bitcoin Spot ETFs und einer Zinssenkung der US-Notenbank stark an und erreichte im November einen Höchststand von 99.645,39 $.

Zum Zeitpunkt der Erstellung dieses Artikels wird das Paar bei etwa 97.300 $ gehandelt, was einen deutlichen Anstieg von 146,5 % im Vergleich zum Preis vor einem Jahr bedeutet. Sein Allzeithoch wurde laut CoinGecko Anfang Dezember 2024 mit 99.645,39 $ verzeichnet.

BTC-TAGESCHART

BTCUSD Tages-Chart Preisansicht 2021-2024

Entwicklung des Swing Entry Monitoring (EA)

Ich habe den Entwicklungsprozess in drei Schritte unterteilt, um unseren Fortschritt auf dem Weg zu einem voll funktionsfähigen Expert Advisor zu rationalisieren. Der erste Schritt besteht darin, den von uns verwendeten gleitenden Durchschnitt zu verstehen, der die Grundlage für die Entwicklung unseres nutzerdefinierten Indikators bildet. Dieser Indikator wird als eigenständiges Instrument dienen und auch die Grundlage für den Aufbau unseres Monitoring Expert Advisors in den nachfolgenden Schritten bilden.

Schritt 1: Verstehen der Strategie eines EMA 100

Der Exponential Moving Average (EMA) ist ein weit verbreiteter Indikator, der den jüngsten Daten mehr Gewicht verleiht. Insbesondere der EMA 100 ist ein kritisches Niveau im Paarhandel, das oft als starker Unterstützungs- oder Widerstandspunkt dient. Viele profitable Bitcoin-Einstiegsmöglichkeiten haben sich in der Vergangenheit ergeben, wenn der Kurs am EMA 100 abgeprallt ist, insbesondere in volatilen Phasen.

Schritt 2: Indikator für die Überwachung

Da wir mit dem Exponential Moving Average (EMA) arbeiten, einer integrierte Funktion des MetaTrader 5 Terminals, habe ich beschlossen, zunächst einen Überwachungsindikator zu entwickeln, der diese integrierte Instrumente nutzt. Dieser Ansatz vereinfacht den Prozess der Identifizierung von Schlüsselbereichen, die während der Preisentwicklung von Interesse sind. Meiner Erfahrung nach ist der Indikator in der Lage, Warnungen über Terminalbenachrichtigungen, Push-Benachrichtigungen und sogar per E-Mail zu senden.

Es fehlt jedoch die Fähigkeit, Webanfragen für fortgeschrittene Alarmierungsdienste zu verarbeiten, wie z. B. die Integration mit beliebten sozialen Netzwerken. Um diese Einschränkung zu überwinden, gehen wir zu Schritt 3 über, wo der Indikator zu einem Expert Advisor (EA) erweitert wird. Diese Umstellung wird robustere Funktionen ermöglichen, einschließlich einer nahtlosen Kommunikation über Telegram, die ein umfassendes und effizientes Überwachungssystem gewährleistet.

Hier ist die Aufschlüsselung der Entwicklung unseres Indikators Monitoring;

Eigenschaften und Metadaten:

In diesem Abschnitt werden wesentliche Metadaten für den Expert Advisor (EA) definiert, darunter der Urheberrechtsinhaber, ein Link zum Profil des Autors, die Versionsnummer und eine kurze Beschreibung des Zwecks des Indikators. Diese Informationen sind für die Dokumentation von entscheidender Bedeutung, da sie den Nutzern helfen, den Ersteller und die beabsichtigte Funktionalität auf einen Blick zu verstehen.

#property copyright "Clemence Benjamin"
#property link      "https://www.mql5.com/de/users/billionaire2024/seller"
#property version   "1.0"
#property description "EMA 100 Monitoring Indicator"

Indikator-Einstellungen:

In diesem Teil konfigurieren wir die visuellen Darstellungen, die auf dem Handelschart erscheinen werden. Die Direktive #property indicator_chart_window bewirkt, dass der EA im Hauptchartfenster arbeitet. Durch die Definition von zwei Indikatorpuffern (indicator_buffers 2) bereiten wir die Anzeige von zwei unterschiedlichen Signalen vor. Die Eigenschaften indicator_type1 und indicator_type2 legen fest, dass beide Indikatoren als Pfeile mit unterschiedlichen Farben (orange und blau) und der Beschriftung „Look for EMA 100 bounce“ dargestellt werden. Dieses Setup erhöht die Klarheit für Händler, indem es sofortige visuelle Hinweise auf potenzielle Handelsmöglichkeiten auf der Grundlage der Interaktion des Kurses mit dem Exponential Moving Average (EMA) liefert.

///Properties and Settings

#property indicator_chart_window
#property indicator_buffers 2
#property indicator_plots 2

#property indicator_type1 DRAW_ARROW
#property indicator_width1 5
#property indicator_color1 0xFFAA00
#property indicator_label1 "Look for EMA 100 bounce "

#property indicator_type2 DRAW_ARROW
#property indicator_width2 5
#property indicator_color2 0x0000FF
#property indicator_label2 "Look for EMA 100 bounce "

Puffer-Definitionen

In diesem Abschnitt werden die Indikatorpuffer definiert, die Werte für die vom EA erzeugten Signale enthalten. Puffer1 und Puffer2 werden als Arrays des Typs „double“ deklariert, in denen die Daten für die beiden Signaltypen in Bezug auf die Kursbewegungen und den EMA gespeichert werden. Die Konstanten PLOT_MAXIMUM_BARS_BACK und OMIT_OLDEST_BARS werden gesetzt, um zu steuern, wie viele historische Balken verarbeitet werden, damit das Programm effizient läuft, ohne das System mit veralteten Daten zu überlasten. Diese Designentscheidung trägt dazu bei, die Leistung zu erhalten und dem Nutzer gleichzeitig relevante und zeitnahe Informationen zu liefern.

#define PLOT_MAXIMUM_BARS_BACK 5000
#define OMIT_OLDEST_BARS 50

//--- indicator buffers
double Buffer1[];
double Buffer2[];

Eingabeparameter:

In diesem Teil definieren wir nutzerkonfigurierbare Eingabeparameter, die die Flexibilität des EAs erhöhen. Die Eingabe int EMA_Period = 100; ermöglicht es dem Nutzer, den Zeitraum für die Berechnung des Exponential Moving Average festzulegen, wodurch der EA an verschiedene Handelsstrategien angepasst werden kann. Darüber hinaus sind Flags wie Audible_Alerts und Push_Notifications standardmäßig auf true gesetzt, sodass Echtzeit-Warnungen und -Benachrichtigungen bei wichtigen Marktereignissen möglich sind. Es werden auch andere Variablen wie Low, High und MA_handle deklariert, die Preisdaten speichern und Berechnungen des gleitenden Durchschnitts durchführen, die eine entscheidende Rolle bei den Operationen des EA spielen.

input int EMA_Period = 100;
datetime time_alert; //used when sending alert
bool Audible_Alerts = true;
bool Push_Notifications = true;
double myPoint; //initialized in OnInit
double Low[];
int MA_handle;
double MA[];
double High[];

Alert-Funktion:

Die Funktion myAlert dient dazu, das Alarmmanagement innerhalb des EA zu zentralisieren. Er benötigt zwei Parameter: „type“, der die Art der Meldung angibt (z. B. „print“, „error“, „indicator“), und die Nachricht, die den Meldungstext enthält. Je nach Typ gibt die Funktion entweder Meldungen zur Fehlersuche aus oder sendet Warnungen bei Marktveränderungen. Dieser Ansatz verbessert die Organisation und Lesbarkeit des Codes und erleichtert die Wartung. Durch die Bereitstellung von akustischen Alarmen und Push-Benachrichtigungen stellt diese Funktion sicher, dass die Nutzer über wichtige Marktbewegungen informiert bleiben, was für rechtzeitige Handelsentscheidungen entscheidend ist.

void myAlert(string type, string message)
  {
   if(type == "print")
      Print(message);
   else if(type == "error")
     {
      Print(type+" | EMA 100 Monitor @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
     }
   else if(type == "order")
     {
     }
   else if(type == "modify")
     {
     }
   else if(type == "indicator")
     {
      Print(type+" | EMA 100 Monitor @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
      if(Audible_Alerts) Alert(type+" | EMA 100 Monitor @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
      if(Push_Notifications) SendNotification(type+" | EMA 100 Monitor @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
     }
  }

Initialisierungsfunktion:

Die Funktion OnInit ist der Einstiegspunkt, wenn der EA geladen wird. Sie initialisiert die Indikatorpuffer und richtet die Berechnungen für den Exponential Moving Average ein. Die Verwendung von SetIndexBuffer verknüpft die definierten Puffer mit den Indikatorplots und stellt sicher, dass die Werte auf dem Chart angezeigt werden können. Die Funktion prüft auch die erfolgreiche Erstellung des Handles für den gleitenden Durchschnitt (MA_handle) und bietet eine Fehlerbehandlung, die die Robustheit erhöht. Treten während der Initialisierung Probleme auf, werden eindeutige Fehlermeldungen ausgegeben, sodass der Nutzer eine effektive Fehlersuche durchführen kann. Diese gründliche Einrichtung ist wichtig, damit der EA von Anfang an richtig funktioniert.

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {   
   SetIndexBuffer(0, Buffer1);
   PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(0, PLOT_ARROW, 233);
   SetIndexBuffer(1, Buffer2);
   PlotIndexSetDouble(1, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(1, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(1, PLOT_ARROW, 234);
   //initialize myPoint
   myPoint = Point();
   if(Digits() == 5 || Digits() == 3)
     {
      myPoint *= 10;
     }
   MA_handle = iMA(NULL, PERIOD_CURRENT, EMA_Period, 0, MODE_SMA, PRICE_CLOSE);
   if(MA_handle < 0)
     {
      Print("The creation of iMA has failed: MA_handle=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   return(INIT_SUCCEEDED);
  }

Berechnungsfunktion:

Die Funktion OnCalculate ist das Herzstück des EA, in dem sich die Logik zur Berechnung der Indikatorwerte befindet. Es verarbeitet eingehende Marktdaten, ruft Kursinformationen ab und berechnet den gleitenden Durchschnitt. Die Funktion beginnt mit der Ermittlung der Anzahl der zu bearbeitenden Tarife auf der Grundlage der Gesamtsumme und der zuvor berechneten Tarife. Anschließend werden die Puffer initialisiert und die erforderlichen Daten, wie z. B. die Höchst- und Tiefstpreise, abgerufen, bevor die Hauptschleife beginnt. Diese Schleife durchläuft die Preisdaten und prüft die Bedingungen für die Erzeugung von Handelssignalen auf der Grundlage der Beziehung zwischen dem Preis und dem EMA. Die Effizienz dieser Funktion ist entscheidend, da sie es dem EA ermöglicht, dynamisch und in Echtzeit auf Marktveränderungen zu reagieren.

int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime& time[],
                const double& open[],
                const double& high[],
                const double& low[],
                const double& close[],
                const long& tick_volume[],
                const long& volume[],
                const int& spread[])
  {
   int limit = rates_total - prev_calculated;
   //--- counting from 0 to rates_total
   ArraySetAsSeries(Buffer1, true);
   ArraySetAsSeries(Buffer2, true);
   //--- initial zero
   if(prev_calculated < 1)
     {
      ArrayInitialize(Buffer1, EMPTY_VALUE);
      ArrayInitialize(Buffer2, EMPTY_VALUE);
     }
   else
      limit++;
   datetime Time[];
   
   if(CopyLow(Symbol(), PERIOD_CURRENT, 0, rates_total, Low) <= 0) return(rates_total);
   ArraySetAsSeries(Low, true);
   if(BarsCalculated(MA_handle) <= 0) 
      return(0);
   if(CopyBuffer(MA_handle, 0, 0, rates_total, MA) <= 0) return(rates_total);
   ArraySetAsSeries(MA, true);
   if(CopyHigh(Symbol(), PERIOD_CURRENT, 0, rates_total, High) <= 0) return(rates_total);
   ArraySetAsSeries(High, true);
   if(CopyTime(Symbol(), Period(), 0, rates_total, Time) <= 0) return(rates_total);
   ArraySetAsSeries(Time, true);

Hauptlogik:

Innerhalb der Funktion OnCalculate analysiert die Hauptlogikschleife die Kursbewegungen in Bezug auf den EMA. Es wird auf bestimmte Bedingungen geprüft, z. B. wenn der Tiefstkurs unter dem EMA liegt oder der Höchstkurs darüber. Wenn diese Bedingungen erfüllt sind, werden die entsprechenden Puffer (Buffer1 für eine Unterschreitung des EMA und Buffer2 für eine Überschreitung) mit den aktuellen Tiefs bzw. Hochs gefüllt, und es werden Warnmeldungen für den Nutzer ausgelöst. Dieser Mechanismus ist von grundlegender Bedeutung für die Bereitstellung umsetzbarer Handelssignale, die es den Händlern ermöglichen, fundierte Entscheidungen auf der Grundlage technischer Analysen zu treffen. Der klare und strukturierte Ansatz bei der Festlegung von Indikatorwerten gewährleistet, dass die Nutzer zeitnahe und relevante Informationen über potenzielle Handelsmöglichkeiten erhalten.

//--- main loop
   for(int i = limit-1; i >= 0; i--)
     {
      if (i >= MathMin(PLOT_MAXIMUM_BARS_BACK-1, rates_total-1-OMIT_OLDEST_BARS)) continue; //omit some old rates to prevent "Array out of range" or slow calculation   
      
      //Indicator Buffer 1
      if(Low[i] < MA[i]
      && Low[i+1] > MA[i+1] //Candlestick Low crosses below Moving Average
      )
        {
         Buffer1[i] = Low[i]; //Set indicator value at Candlestick Low
         if(i == 1 && Time[1] != time_alert) myAlert("indicator", "Look for EMA 100 bounce "); //Alert on next bar open
         time_alert = Time[1];
        }
      else
        {
         Buffer1[i] = EMPTY_VALUE;
        }
      //Indicator Buffer 2
      if(High[i] > MA[i]
      && High[i+1] < MA[i+1] //Candlestick High crosses above Moving Average
      )
        {
         Buffer2[i] = High[i]; //Set indicator value at Candlestick High
         if(i == 1 && Time[1] != time_alert) myAlert("indicator", "Look for EMA 100 bounce "); //Alert on next bar open
         time_alert = Time[1];
        }
      else
        {
         Buffer2[i] = EMPTY_VALUE;
        }
     }
   return(rates_total);
  }
//+------------------------------------------------------------------+

Der vollständige Code für die Indikatoren ist hier zu finden, ohne Fehler:

#property copyright "Clemence Benjamin"
#property link      "https://www.mql5.com/en/users/billionaire2024/seller"
#property version   "1.0"
#property description "EMA 100 Monitoring Indicator"

//--- indicator settings
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_plots 2

#property indicator_type1 DRAW_ARROW
#property indicator_width1 5
#property indicator_color1 0xFFAA00
#property indicator_label1 "Look for EMA 100 bounce "

#property indicator_type2 DRAW_ARROW
#property indicator_width2 5
#property indicator_color2 0x0000FF
#property indicator_label2 "Look for EMA 100 bounce "

#define PLOT_MAXIMUM_BARS_BACK 5000
#define OMIT_OLDEST_BARS 50

//--- indicator buffers
double Buffer1[];
double Buffer2[];

input int EMA_Period = 100;
datetime time_alert; //used when sending alert
bool Audible_Alerts = true;
bool Push_Notifications = true;
double myPoint; //initialized in OnInit
double Low[];
int MA_handle;
double MA[];
double High[];

void myAlert(string type, string message)
  {
   if(type == "print")
      Print(message);
   else if(type == "error")
     {
      Print(type+" | EMA 100 Monitor @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
     }
   else if(type == "order")
     {
     }
   else if(type == "modify")
     {
     }
   else if(type == "indicator")
     {
      Print(type+" | EMA 100 Monitor @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
      if(Audible_Alerts) Alert(type+" | EMA 100 Monitor @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
      if(Push_Notifications) SendNotification(type+" | EMA 100 Monitor @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
     }
  }

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {   
   SetIndexBuffer(0, Buffer1);
   PlotIndexSetDouble(0, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(0, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(0, PLOT_ARROW, 233);
   SetIndexBuffer(1, Buffer2);
   PlotIndexSetDouble(1, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(1, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(1, PLOT_ARROW, 234);
   //initialize myPoint
   myPoint = Point();
   if(Digits() == 5 || Digits() == 3)
     {
      myPoint *= 10;
     }
   MA_handle = iMA(NULL, PERIOD_CURRENT, EMA_Period, 0, MODE_SMA, PRICE_CLOSE);
   if(MA_handle < 0)
     {
      Print("The creation of iMA has failed: MA_handle=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   return(INIT_SUCCEEDED);
  }

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime& time[],
                const double& open[],
                const double& high[],
                const double& low[],
                const double& close[],
                const long& tick_volume[],
                const long& volume[],
                const int& spread[])
  {
   int limit = rates_total - prev_calculated;
   //--- counting from 0 to rates_total
   ArraySetAsSeries(Buffer1, true);
   ArraySetAsSeries(Buffer2, true);
   //--- initial zero
   if(prev_calculated < 1)
     {
      ArrayInitialize(Buffer1, EMPTY_VALUE);
      ArrayInitialize(Buffer2, EMPTY_VALUE);
     }
   else
      limit++;
   datetime Time[];
   
   if(CopyLow(Symbol(), PERIOD_CURRENT, 0, rates_total, Low) <= 0) return(rates_total);
   ArraySetAsSeries(Low, true);
   if(BarsCalculated(MA_handle) <= 0) 
      return(0);
   if(CopyBuffer(MA_handle, 0, 0, rates_total, MA) <= 0) return(rates_total);
   ArraySetAsSeries(MA, true);
   if(CopyHigh(Symbol(), PERIOD_CURRENT, 0, rates_total, High) <= 0) return(rates_total);
   ArraySetAsSeries(High, true);
   if(CopyTime(Symbol(), Period(), 0, rates_total, Time) <= 0) return(rates_total);
   ArraySetAsSeries(Time, true);
   //--- main loop
   for(int i = limit-1; i >= 0; i--)
     {
      if (i >= MathMin(PLOT_MAXIMUM_BARS_BACK-1, rates_total-1-OMIT_OLDEST_BARS)) continue; //omit some old rates to prevent "Array out of range" or slow calculation   
      
      //Indicator Buffer 1
      if(Low[i] < MA[i]
      && Low[i+1] > MA[i+1] //Candlestick Low crosses below Moving Average
      )
        {
         Buffer1[i] = Low[i]; //Set indicator value at Candlestick Low
         if(i == 1 && Time[1] != time_alert) myAlert("indicator", "Look for EMA 100 bounce "); //Alert on next bar open
         time_alert = Time[1];
        }
      else
        {
         Buffer1[i] = EMPTY_VALUE;
        }
      //Indicator Buffer 2
      if(High[i] > MA[i]
      && High[i+1] < MA[i+1] //Candlestick High crosses above Moving Average
      )
        {
         Buffer2[i] = High[i]; //Set indicator value at Candlestick High
         if(i == 1 && Time[1] != time_alert) myAlert("indicator", "Look for EMA 100 bounce "); //Alert on next bar open
         time_alert = Time[1];
        }
      else
        {
         Buffer2[i] = EMPTY_VALUE;
        }
     }
   return(rates_total);
  }
//+------------------------------------------------------------------+

Schritt 3: EA-Entwicklung

In diesem Abschnitt werden wir Sie durch die Entwicklung eines einfachen, aber effektiven Swing Entry Monitoring Expert Advisor (EA) mit MQL5 führen. Dieser EA wurde entwickelt, um Marktpreise zu überwachen, mit einem besonderen Fokus auf Bitcoin als Beispiel, und um Alarme basierend auf vordefinierten Bedingungen zu senden.

Um diesen Prozess zu straffen, lassen wir die Details der Metadaten weg, da diese in der Phase der Indikatorenentwicklung ausführlich erläutert wurden. Wir werden den Code Schritt für Schritt aufschlüsseln und sicherstellen, dass jeder Teil leicht zu verstehen und umzusetzen ist.

1. Eingabe Parameter:

input string IndicatorName = "ema100_monitoring_indicator"; // Name of the custom indicator
input bool EnableTerminalAlerts = true;
input bool EnablePushNotifications = true;
input bool EnableTelegramAlerts = false;
input string TelegramBotToken = "YOUR_BOT_TOKEN"; // Replace with your bot token
input string TelegramChatID = "YOUR_CHAT_ID";     // Replace with your chat ID

In diesem Teil werden verschiedene anpassbare Eingabeparameter definiert, die die Flexibilität und Nutzerfreundlichkeit des EA erhöhen. Mit dem Parameter IndicatorName können wir den Namen des nutzerdefinierten Indikators angeben, den wir überwachen möchten. Die Standardeinstellung ist „Bitcoin Monitor“. Mit den booleschen Flags — EnableTerminalAlerts, EnablePushNotifications und EnableTelegramAlerts — können wir unsere Benachrichtigungseinstellungen anpassen. So können wir beispielsweise wählen, ob wir Benachrichtigungen direkt im Handelsterminal, auf unseren mobilen Geräten oder über Telegram erhalten möchten. Außerdem müssen wir unseren Bot-Token von Telegram und unsere Chat-ID eingeben, um die Alarme in Telegram zu aktivieren. Diese Anpassung ermöglicht es anderen Nutzern, ihre Handelserfahrung entsprechend ihren Vorlieben und Bedürfnissen zu optimieren.

2. Indikator Handles:

int indicatorHandle = INVALID_HANDLE;
int emaHandle = INVALID_HANDLE;

In diesem Abschnitt werden die notwendigen Variablen zur Verwaltung der in der EA verwendeten Indikatoren deklariert. Die Variablen indicatorHandle und emaHandle speichern Verweise auf den nutzerdefinierten Indikator bzw. den Exponential Moving Average (EMA). Beide Handles werden mit INVALID_HANDLE initialisiert, was anzeigt, dass sie noch nicht zugewiesen sind. Diese Einstellung ist entscheidend für die Funktionalität des EA, da sie es dem Programm ermöglicht, sich mit den angegebenen Indikatoren zu verbinden und relevante Marktdaten für die Analyse abzurufen.

3. Alert-Funktion:

void AlertMessage(string message) {
   if (EnableTerminalAlerts) Alert(message);
   if (EnablePushNotifications) SendNotification(message);
   if (EnableTelegramAlerts) SendTelegramMessage(message);
}

Die Funktion AlertMessage spielt eine wichtige Rolle bei der Verwaltung von Warnmeldungen innerhalb des EA. Diese Funktion benötigt einen String-Parameter, message, der den Text der zu sendenden Meldung enthält. Es prüft die Präferenzen des Nutzers für Alarmtypen — Endbenachrichtigungen, Push-Benachrichtigungen und Telegram-Nachrichten — und sendet die Nachricht entsprechend. Durch die Zentralisierung der Alarmverwaltung in dieser Funktion wird der Code übersichtlicher und leichter zu pflegen. Diese Funktion ist besonders wichtig für Händler, die auf rechtzeitige Benachrichtigungen angewiesen sind, um fundierte Entscheidungen auf der Grundlage von Marktbewegungen zu treffen.

4. Ein Alarm über Telegramm

void SendTelegramMessage(string message) {
   if (EnableTelegramAlerts) {
      string url = "https://api.telegram.org/bot" + TelegramBotToken + "/sendMessage?chat_id=" + TelegramChatID + "&text=" + message;
      int timeout = 5000;
      ResetLastError();

      char postData[];
      uchar result[];
      string response;

      int res = WebRequest("GET", url, NULL, timeout, postData, result, response);

      if (res != 200) {
         Print("Telegram WebRequest failed. Error: ", GetLastError(), ", HTTP Code: ", res);
      } else {
         Print("Telegram message sent successfully: ", response);
      }
   }
}

Um die Kommunikation mit den Nutzern zu erleichtern, wurde die Funktion SendTelegramMessage implementiert. Diese Funktion konstruiert eine URL, die die Telegram-API nutzt, um Nachrichten an einen bestimmten Chat zu senden. Zunächst wird geprüft, ob Telegram-Benachrichtigungen aktiviert sind. Wenn dies der Fall ist, bereitet die Funktion eine GET-Anfrage vor und sendet sie an den Telegram-Server mit der konstruierten URL, einschließlich des Bot-Tokens und der Chat-ID. Die Funktion behandelt auch mögliche Fehler während der Anfrage und gibt dem Nutzer eine Rückmeldung, wenn die Nachricht nicht gesendet werden kann. Diese Funktion ermöglicht es den Nutzern, Benachrichtigungen direkt auf Telegram zu erhalten, was die Zugänglichkeit und den Komfort verbessert.

5. Initialisierungsfunktion:

int OnInit() {
   Print("Bitcoin Monitoring EA started.");

   // Attach the custom indicator to the chart
   indicatorHandle = iCustom(_Symbol, _Period, IndicatorName);
   if (indicatorHandle == INVALID_HANDLE) {
      Print("Failed to attach indicator: ", IndicatorName, ". Error: ", GetLastError());
      return(INIT_FAILED);
   }

   // Attach built-in EMA 100 to the chart
   emaHandle = iMA(_Symbol, _Period, 100, 0, MODE_EMA, PRICE_CLOSE);
   if (emaHandle == INVALID_HANDLE) {
      Print("Failed to create EMA 100. Error: ", GetLastError());
      return(INIT_FAILED);
   }

   // Add EMA 100 to the terminal chart
   if (!ChartIndicatorAdd(0, 0, emaHandle)) {
      Print("Failed to add EMA 100 to the chart. Error: ", GetLastError());
   }

   return(INIT_SUCCEEDED);
}

Die Funktion OnInit wird ausgeführt, wenn der EA zum ersten Mal geladen wird. Sie ist dafür verantwortlich, die notwendigen Indikatoren zu erstellen und sicherzustellen, dass der EA einsatzbereit ist. In dieser Funktion wird der nutzerdefinierte Indikator unter Verwendung seines Namens an das Chart angehängt, und das Handle wird überprüft, um die erfolgreiche Anbringung zu bestätigen. Wenn die Anlage fehlschlägt, wird eine Fehlermeldung gedruckt, um die Diagnose des Problems zu erleichtern. Darüber hinaus erstellt die Funktion einen EMA mit einer Periode von 100 und prüft dessen erfolgreiche Erstellung, bevor sie ihn dem Chart hinzufügt. Die ordnungsgemäße Initialisierung ist für die Funktionalität des EA von entscheidender Bedeutung, da sie sicherstellt, dass alle Komponenten korrekt eingerichtet und bereit sind, Marktdaten zu verarbeiten.

6. Deinitialisierungsfunktion:

void OnDeinit(const int reason) {
   Print(" EA stopped.");
   if (indicatorHandle != INVALID_HANDLE) {
      IndicatorRelease(indicatorHandle);
   }
   if (emaHandle != INVALID_HANDLE) {
      IndicatorRelease(emaHandle);
   }
}

Die Funktion OnDeinit wird aufgerufen, wenn der EA aus dem Chart entfernt wird oder wenn das Terminal geschlossen wird. Sein Hauptzweck besteht darin, Ressourcen aufzuräumen und Speicherlecks zu verhindern. Diese Funktion prüft, ob die Indikator-Handles gültig sind, und gibt sie gegebenenfalls frei, um Systemressourcen freizugeben. Die Funktion gibt auch eine Meldung aus, dass der EA gestoppt wurde, sodass der Nutzer eine klare Rückmeldung über den Status des EA erhält. Eine ordnungsgemäße Deinitialisierung ist für die Aufrechterhaltung einer optimalen Leistung und die Sicherstellung einer übersichtlichen Handelsumgebung von wesentlicher Bedeutung.

7. Hauptlogik:

void OnTick() {
   static datetime lastAlertTime = 0; // Prevent repeated alerts for the same signal

   if (indicatorHandle == INVALID_HANDLE || emaHandle == INVALID_HANDLE) return;

   double buffer1[], buffer2[];
   ArraySetAsSeries(buffer1, true);
   ArraySetAsSeries(buffer2, true);

   // Read data from the custom indicator
   if (CopyBuffer(indicatorHandle, 0, 0, 1, buffer1) < 0) {
      Print("Failed to copy Buffer1. Error: ", GetLastError());
      return;
   }
   if (CopyBuffer(indicatorHandle, 1, 0, 1, buffer2) < 0) {
      Print("Failed to copy Buffer2. Error: ", GetLastError());
      return;
   }

   // Check for signals in Buffer1
   if (buffer1[0] != EMPTY_VALUE && TimeCurrent() != lastAlertTime) {
      string message = "Signal detected: Look for EMA 100 bounce (Low). Symbol: " + _Symbol;
      AlertMessage(message);
      lastAlertTime = TimeCurrent();
   }

   // Check for signals in Buffer2
   if (buffer2[0] != EMPTY_VALUE && TimeCurrent() != lastAlertTime) {
      string message = "Signal detected: Look for EMA 100 bounce (High). Symbol: " + _Symbol;
      AlertMessage(message);
      lastAlertTime = TimeCurrent();
   }

   // Debugging EMA 100 value
   double emaValueArray[];
   ArraySetAsSeries(emaValueArray, true); // Ensure it's set as series
   if (CopyBuffer(emaHandle, 0, 0, 1, emaValueArray) > 0) {
      Print("EMA 100 Current Value: ", emaValueArray[0]);
   } else {
      Print("Failed to read EMA 100 buffer. Error: ", GetLastError());
   }
}

Die Funktion OnTick enthält die Kernlogik des EA, die jedes Mal ausgeführt wird, wenn der Markt einen neuen Tick an Daten erhält. Diese Funktion prüft die Gültigkeit der Indikator-Handles, bevor sie mit ihren Berechnungen fortfährt. Es initialisiert Arrays, die Daten aus dem nutzerdefinierten Indikator enthalten, und ruft die neuesten Werte aus den Indikatorpuffern ab. Wird in einem der beiden Puffer ein Signal erkannt, löst die Funktion über AlertMessage eine Warnung aus, die den Nutzer über potenzielle Handelsmöglichkeiten informiert. Darüber hinaus ruft die Funktion den aktuellen Wert des EMA zu Debugging-Zwecken ab und bietet so Transparenz über die Funktionsweise des EA. Diese Echtzeitanalyse ermöglicht es dem EA, schnell auf Marktveränderungen zu reagieren, was ihn zu einem wertvollen Werkzeug für Händler macht.

Insgesamt ist unser EA-Code wie folgt :

//+------------------------------------------------------------------+
//| Bitcoin Monitoring Expert Advisor                                |
//| Copyright 2024, Clemence Benjamin                                |
//| https://www.mql5.com/en/users/billionaire2024/seller            |
//+------------------------------------------------------------------+
#property copyright "Clemence Benjamin"
#property link      "https://www.mql5.com/en/users/billionaire2024/seller"
#property version   "1.0"
#property description "BTCUSD Monitoring Expert Advisor"

//--- Input parameters
input string IndicatorName = "ema100_monitoring_indicator"; // Name of the custom indicator
input bool EnableTerminalAlerts = true;
input bool EnablePushNotifications = true;
input bool EnableTelegramAlerts = false;
input string TelegramBotToken = "YOUR_BOT_TOKEN";         // Replace with your bot token
input string TelegramChatID = "YOUR_CHAT_ID";             // Replace with your chat ID

//--- Indicator handles
int indicatorHandle = INVALID_HANDLE;
int emaHandle = INVALID_HANDLE;

//--- Alert function
void AlertMessage(string message) {
   if (EnableTerminalAlerts) Alert(message);
   if (EnablePushNotifications) SendNotification(message);
   if (EnableTelegramAlerts) SendTelegramMessage(message);
}

//--- Telegram Alerting
void SendTelegramMessage(string message) {
   if (EnableTelegramAlerts) {
      string url = "https://api.telegram.org/bot" + TelegramBotToken + "/sendMessage?chat_id=" + TelegramChatID + "&text=" + message;
      int timeout = 5000;
      ResetLastError();

      char postData[];
      uchar result[];
      string response;

      int res = WebRequest("GET", url, NULL, timeout, postData, result, response);

      if (res != 200) {
         Print("Telegram WebRequest failed. Error: ", GetLastError(), ", HTTP Code: ", res);
      } else {
         Print("Telegram message sent successfully: ", response);
      }
   }
}

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit() {
   Print("Bitcoin Monitoring EA started.");

   // Attach the custom indicator to the chart
   indicatorHandle = iCustom(_Symbol, _Period, IndicatorName);
   if (indicatorHandle == INVALID_HANDLE) {
      Print("Failed to attach indicator: ", IndicatorName, ". Error: ", GetLastError());
      return(INIT_FAILED);
   }

   // Attach built-in EMA 100 to the chart
   emaHandle = iMA(_Symbol, _Period, 100, 0, MODE_EMA, PRICE_CLOSE);
   if (emaHandle == INVALID_HANDLE) {
      Print("Failed to create EMA 100. Error: ", GetLastError());
      return(INIT_FAILED);
   }

   // Add EMA 100 to the terminal chart
   if (!ChartIndicatorAdd(0, 0, emaHandle)) {
      Print("Failed to add EMA 100 to the chart. Error: ", GetLastError());
   }

   return(INIT_SUCCEEDED);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
   Print("Bitcoin Monitoring EA stopped.");
   if (indicatorHandle != INVALID_HANDLE) {
      IndicatorRelease(indicatorHandle);
   }
   if (emaHandle != INVALID_HANDLE) {
      IndicatorRelease(emaHandle);
   }
}

void OnTick() {
   static datetime lastAlertTime = 0; // Prevent repeated alerts for the same signal

   if (indicatorHandle == INVALID_HANDLE || emaHandle == INVALID_HANDLE) return;

   double buffer1[], buffer2[];
   ArraySetAsSeries(buffer1, true);
   ArraySetAsSeries(buffer2, true);

   // Read data from the custom indicator
   if (CopyBuffer(indicatorHandle, 0, 0, 1, buffer1) < 0) {
      Print("Failed to copy Buffer1. Error: ", GetLastError());
      return;
   }
   if (CopyBuffer(indicatorHandle, 1, 0, 1, buffer2) < 0) {
      Print("Failed to copy Buffer2. Error: ", GetLastError());
      return;
   }

   // Check for signals in Buffer1
   if (buffer1[0] != EMPTY_VALUE && TimeCurrent() != lastAlertTime) {
      string message = "Signal detected: Look for EMA 100 bounce (Low). Symbol: " + _Symbol;
      AlertMessage(message);
      lastAlertTime = TimeCurrent();
   }

   // Check for signals in Buffer2
   if (buffer2[0] != EMPTY_VALUE && TimeCurrent() != lastAlertTime) {
      string message = "Signal detected: Look for EMA 100 bounce (High). Symbol: " + _Symbol;
      AlertMessage(message);
      lastAlertTime = TimeCurrent();
   }

   // Debugging EMA 100 value
   double emaValueArray[];
   ArraySetAsSeries(emaValueArray, true); // Ensure it's set as series
   if (CopyBuffer(emaHandle, 0, 0, 1, emaValueArray) > 0) {
      Print("EMA 100 Current Value: ", emaValueArray[0]);
   } else {
      Print("Failed to read EMA 100 buffer. Error: ", GetLastError());
   }
}

Testen und Optimieren

Nachdem wir den Code erfolgreich kompiliert hatten, testeten wir ihn mit dem Strategy Tester im MetaTrader 5 Terminal. Nachfolgend finden Sie einige Bilder, die den Testprozess und die Ergebnisse veranschaulichen.

Bitcoin-Überwachungsexperte

Experte für Bitcoin-Überwachung: Testlauf im Strategy-Tester

Wir haben die Echtzeit-Kursüberwachungsfunktionen des EA während des Strategie-Testerlaufs erfolgreich demonstriert. Nachstehend finden Sie eine Abbildung, die den Prozess und die Leistung des EA in Aktion zeigt.

Die Preisüberwachung durch Bitcoin Monitoring EA im Test

In OnTick werden BTC-Preisänderungen überwacht: Jahr 2022

Ergebnisse und Analyse

Wir haben die Leistung des Indikators erfolgreich visualisiert, indem wir seine Interaktion mit dem EMA 100 über höhere Zeitrahmen, insbesondere H4 und D1, beobachtet haben. Das System zeigt, dass es in der Lage ist, Warnmeldungen auf drei verschiedene Arten zu versenden, einschließlich Telegram-Benachrichtigungen. Der Preis respektierte durchweg den gewählten EMA, wie die von uns gezeigten Abbildungen zeigen. Das folgende Bild zeigt den Start des EA und des Indikators auf dem MetaTrader 5-Terminal und veranschaulicht ihre Integration und Funktionalität.

Starten des EAs und des Indikators auf dem Chart

Schlussfolgerung

Der Monitoring EA, den wir in diesem Artikel entwickelt haben, dient als wertvolles Werkzeug für jeden Händler. Durch die Automatisierung der Preisbeobachtung und die Integration von Strategien wie dem EMA 100 wird der manuelle Aufwand für die Identifizierung von Handelsmöglichkeiten reduziert. Wir haben es für BTCUSD entwickelt, aber es kann auf andere Instrumente ausgeweitet oder für zusätzliche Indikatoren angepasst werden. Dieses Projekt bietet Anfängern eine einfache und motivierende Grundlage für den Einstieg. Der Himmel ist die Grenze, also probieren Sie ruhig verschiedene Ansätze aus.

Laden Sie den beigefügten EA und Indikator herunter, testen Sie ihn mit Ihren bevorzugten Einstellungen und verfeinern Sie ihn, damit er zu Ihrer Handelsstrategie passt. Bleiben Sie in der dynamischen Welt des Handels an der Spitze, indem Sie technische Analyse mit Automatisierung kombinieren. Bitte beachten Sie, dass dieses System ausschließlich für Überwachungs- und Warnzwecke entwickelt wurde und derzeit noch keine Handelsfunktionen integriert sind. Weitere Informationen zu Telegram-Anmeldeinformationen finden Sie in diesem Artikel: Link 1 und Link 2

Tabelle der angehängten Dateien:

Dateien	Beschreibung
ema100_monitoring_indicator.mq5	Nutzerdefinierter Indikator basierend auf der Strategie des Abpralls vom EMA 100
bitcoin_monitoring_expert.mq5	Expert Advisor, um die Telegramm-Alarmierungsfunktionalität über WebRequest zu aktivieren und auch kontinuierlich zu überwachen.

Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/16563

Beigefügte Dateien |

ZIP herunterladen

ema100_monitoring_indicator.mq5 (5.62 KB)

bitcoin_monitoring_expert.mq5 (4.95 KB)

Warnung: Alle Rechte sind von MetaQuotes Ltd. vorbehalten. Kopieren oder Vervielfältigen untersagt.

Andere Artikel von diesem Autor

Zur Diskussion im Händlerforum

Ensemble-Methoden zur Verbesserung von Klassifizierungsaufgaben in MQL5

In diesem Artikel stellen wir die Implementierung mehrerer Ensemble-Klassifikatoren in MQL5 vor und erörtern ihre Wirksamkeit in verschiedenen Situationen.

Entwicklung eines Toolkit zur Analyse von Preisaktionen (Teil 6): Der Mean Reversion Signal Reaper

Während einige Konzepte auf den ersten Blick einfach erscheinen, kann ihre Umsetzung in der Praxis eine ziemliche Herausforderung darstellen. Im folgenden Artikel nehmen wir Sie mit auf eine Reise durch unseren innovativen Ansatz zur Automatisierung eines Expert Advisor (EA), der den Markt mithilfe einer Mean-Reversion-Strategie fachkundig analysiert. Seien Sie dabei, wenn wir die Feinheiten dieses spannenden Automatisierungsprozesses entschlüsseln.

Neuronale Netze im Handel: Vereinheitlichtes Trajektoriengenerierungsmodell (UniTraj)

Das Verständnis des Agentenverhaltens ist in vielen verschiedenen Bereichen wichtig, aber die meisten Methoden konzentrieren sich nur auf eine der Aufgaben (Verstehen, Rauschunterdrückung oder Vorhersage), was ihre Effektivität in realen Szenarien verringert. In diesem Artikel werden wir uns mit einem Modell vertraut machen, das sich an die Lösung verschiedener Probleme anpassen lässt.

MQL5-Assistenten-Techniken, die Sie kennen sollten (Teil 52): Accelerator Oszillator

Der Accelerator Oszillator ist ein weiterer Indikator von Bill Williams, der die Beschleunigung der Preisdynamik und nicht nur ihr Tempo verfolgt. Ähnlich wie der Awesome Oszillator, den wir in einem kürzlich erschienenen Artikel besprochen haben, versucht er, die Verzögerungseffekte zu vermeiden, indem er sich mehr auf die Beschleunigung als auf die Geschwindigkeit konzentriert. Wir untersuchen wie immer, welche Muster wir daraus ableiten können und welche Bedeutung sie für den Handel mit einem von einem Assistenten zusammengestellten Expert Advisor haben könnten.