Aufbau des Kerzenmodells Trend-Constraint (Teil 5): Nachrichtensystem (Teil I)

Inhalt

• Einführung
• Terminal-Nachrichten
• Push-Benachrichtigungen
• E-Mail-Nachrichten
• Debugging Trend Constraint V1.04
• Integration der Kanäle sozialer Netzwerke (z. B. Telegram und WhatsApp)
• Telegramm-Integration
• WhatsApp-Integration
• Die Leistungsfähigkeit des virtuellen privaten Netzwerks (VPS) in unserem Benachrichtigungssystem
• Schlussfolgerung

Einführung

MetaTrader 5 bietet verschiedene Benachrichtigungsoptionen, um die Nutzer über Handelsereignisse zu informieren, z. B. Terminal-, E-Mail- und Push-Benachrichtigungen. Die Integration mit sozialen Plattformen wie Telegram und WhatsApp zur gemeinsamen Nutzung von Signalen kann von großem Nutzen sein. Die Konfiguration von Nachrichten in MetaTrader 5 ermöglicht es Ihnen, unabhängig von Ihrem Standort über Ihre Handelsaktivitäten informiert zu bleiben. Durch die Nutzung der oben genannten Methoden für den Zugang zur Benachrichtigung können Sie die Option wählen, die Ihren Anforderungen am besten entspricht. Dieser Leitfaden führt Sie durch die Einrichtung und Anpassung von MetaTrader 5-Nachrichten, einschließlich der Integration mit Telegram und anderen Social Media-Plattformen. Der Schwerpunkt liegt auf den Details der Konfiguration und den ersten Schritten der Integration, die den Weg für eine eingehendere Untersuchung in Teil II dieser Serie ebnen.

Terminal-Nachrichten

Terminal-Nachrichten sind interne Warnungen in der MetaTrader 5-Plattform. Sie decken alle Alarmereignisse ab, die im MetaTrader 5 ausgelöst werden. Sie können in MetaTrader 5 manuell Alarme einstellen, die ausgelöst werden, wenn bestimmte Bedingungen erfüllt sind. Die Einstellungen für Alarme finden Sie normalerweise auf der Registerkarte „Werkzeuge“ am unteren Rand des Standardfensters von MetaTrader 5.

• Symbol: Wählen Sie das Handelsinstrument aus, für das Sie den Alarm einstellen möchten.
• Zustand: Wählen Sie die Bedingung, die den Alarm auslöst (z.B. Bid >, Ask <, Time =, etc.).
• Wert: Geben Sie den Wert an, mit dem die Bedingung verglichen werden soll (z. B. ein bestimmtes Preisniveau).
• Datei: Wählen Sie die Art des Alarms (z. B. Ton, Datei, E-Mail usw.). Für Terminal-Nachrichten können Sie Ton wählen.
• Aktion: Wählen Sie die Aktion aus, die ausgeführt werden soll, wenn der Alarm ausgelöst wird (z. B. Abspielen eines Tons, Senden einer Benachrichtigung usw.).
• Ton: Wählen Sie eine Tondatei, die abgespielt werden soll, wenn der Alarm ausgelöst wird.
• Ablauf: Legen Sie das Zeitintervall fest, nach dem der Alarm erneut überprüft werden soll.
• Maximale Wiederholungen: Geben Sie an, wie oft der Alarm ausgelöst werden soll.

Nachfolgend finden Sie ein Beispiel für die Einrichtung einer Warnmeldung unter Verwendung von Step Index Synthetics. Die in der Tabelle angegebenen Werte können je nach Bedarf angepasst werden. Nachdem Sie die Einstellungen konfiguriert haben, klicken Sie auf Ok, um die Meldung zu erstellen und sie zu aktivieren. Das animierte Demonstrationsbild unter der Tabelle gibt Ihnen einen schnellen Überblick. Um zu beginnen, klicken Sie mit der rechten Maustaste auf die Registerkarte „Alarm“ im Fenster „Werkzeuge“ und wählen Sie im angezeigten Menü „Erstellen“.

Einstellung	Wert
Symbol	Step Index
Bedingung	Bid >
Wert	9666
Datei	Ton
Aktion	Eine Tondatei ausgewählt ( alert2.wav )
Verzögerung	Einstellung auf 60 Sekunden
Maximale Wiederholungen	Auf 5 einstellen

 

Push-Benachrichtigungen

Es handelt sich um eine Funktion in MetaTrader 5, die es ermöglicht, auf der Plattform generierte Nachrichten, ob intern oder von einem Indikator oder einem Expert Advisor generiert, über die MetaQuotes-ID des mobilen Geräts an die MetaTrader 5-Plattform zu senden. Um Push-Benachrichtigungen zu erhalten, muss MetaTrader 5 über playstore für Android  oder apple store für IOS installiert werden. Auf dem Desktop MetaTrader 5 müssen Push-Benachrichtigungen aktiviert sein, damit der Alarm auf dem Mobiltelefon empfangen werden kann. Eine eindeutige MetaQuotes-ID wird auf dem Mobiltelefon kurz nach der Installation des mobilen MetaTrader 5 erstellt. 

Auf der linken Seite finden Sie eine Abbildung, die zeigt, wie Sie die MetaQuotes-ID finden können. Auf der rechten Seite ist ein Bild zu sehen, das zeigt, wie man Push-Benachrichtigungen auf der Desktop-Plattform MetaTrader 5 aktiviert, zusammen mit dem Feld für die Eingabe der MetaQuotes-ID. Wenn Sie das Kästchen markieren und die ID Ihrer mobilen Plattform eingeben, können Sie sofort beginnen, Nachrichten im Nachrichtenbereich Ihrer MetaTrader 5 Mobilplattform zu erhalten. Sie können mehrere MetaQuotes-IDs von verschiedenen mobilen Geräten hinzufügen und sie voneinander trennen

E-Mail-Nachrichten

Die E-Mail ist nach wie vor ein leistungsfähiges und vielseitiges Kommunikationsmittel, da sie bequem und effizient ist und über eine Vielzahl von Funktionen verfügt. Ob für den privaten Gebrauch, die geschäftliche Korrespondenz oder die berufliche Vernetzung - E-Mail ist ein zuverlässiges und effektives Mittel, um in Verbindung zu bleiben und Informationen auszutauschen. Die Einrichtung von E-Mail-Nachrichten in MetaTrader 5 ermöglicht es Ihnen, Nachrichten über verschiedene Handelsaktivitäten per E-Mail zu erhalten, z. B. über Kursbewegungen, Auftragsausführungen und nutzerdefinierte Ereignisse.

Der Vorteil von E-Mails ist ihre nahezu sofortige Zustellung, die einen raschen Informationsaustausch und eine effiziente Verbreitung an große Gruppen ermöglicht. E-Mail-Dienste bieten häufig Verschlüsselung zum Schutz von Inhalten und sensiblen Informationen. Die direkte Zustellung an den Posteingang des Empfängers minimiert das Abhörrisiko im Vergleich zu anderen Kommunikationsformen.

Hier finden Sie eine Schritt-für-Schritt-Anleitung für die Einrichtung von E-Mail-Nachrichten:

• Starten Sie die MetaTrader 5-Plattform auf Ihrem Computer.
• Gehen Sie zu Extras > Optionen > E-Mail.
• Aktivieren Sie das Kontrollkästchen Aktivieren.
• Füllen Sie die Details des SMTP-Servers aus:

Einstellung	Details ausfüllen
SMTP-Server	Die SMTP-Serveradresse Ihres E-Mail-Anbieters (z. B. smtp.gmail.com für Google Mail).
SMTP-Anmeldung	Ihre E-Mail Adresse (z.B. [e-mail]).
SMTP-Kennwort	Ihr E-Mail-Passwort oder app-spezifisches Passwort, wenn Sie Gmail verwenden.
Von	Ihre E-Mail Adresse (z.B. [e-mail]).
zu:	Die E-Mail-Adresse, an die die Nachrichten geschickt werden sollen (kann mit der Absenderadresse identisch sein oder sich von ihr unterscheiden).

Wie funktioniert der SMTP-Server.

Nach meinen Recherchen ist ein Simple Mail Transfer Protocol (SMTP)-Server ein Mail-Server, der das (SMTP)-Protokoll zum Senden, Empfangen und Weiterleiten ausgehender E-Mails verwendet. Er funktioniert zusammen mit dem Mail Transfer Agent (MTA), um E-Mails vom E-Mail-Client des Absenders zum E-Mail-Server des Empfängers zu leiten. Hier finden Sie eine Liste von E-Mail-Anbietern mit SMTP-Servern:

• gmail
• yahoo mail
• hotmail
• zohomail
• icloud mail

Debugging Trend Constraint V1.04

Wir haben den Stil Draw_Line erfolgreich in die Trends unseres Systems integriert. Ich habe jedoch festgestellt, dass aufgrund dieser neuen Funktion nach jedem Balken zahlreiche Alarme ausgelöst wurden. Wenn zum Beispiel ein Chart auf einen Minuten-Zeitrahmen eingestellt war, wurden bei jedem Kerzenende im Minutentakt Warnungen generiert, was ziemlich überwältigend ist.

Unser Ziel ist es, optimale Signale zu erhalten, indem wir uns auf einige wenige konzentrieren. Um dieses Problem in den Griff zu bekommen, habe ich erwogen, die Angelegenheit zu lösen, indem ich myalert() aus dem fünften und sechsten Puffer entfernt habe. Es ist wichtig, dass dieser Code für die nahtlose Integration von Telegram und WhatsApp korrigiert wird, wie in diesem Artikel beschrieben. Nachstehend finden Sie die überarbeitete Fassung unseres Kodex:

Puffer 5 Geändert:

// --- Buffer5 (Buy Trend)
      if(MA5[i] > MA6[i])
        {
         Buffer5[i] = Low[i] - 15 * myPoint;
         // Disabled myAlert from Buffer 5
         // myAlert("indicator", "BUY TREND | MA Fast: " + DoubleToString(MA5[i], 2) + " | MA Slow: " + DoubleToString(MA6[i], 2));
        }

Puffer 6 Geändert:

// --- Buffer6 (Sell Trend)
      if(MA5[i] < MA6[i])
        {
         Buffer6[i] = High[i] + 15 * myPoint;
         // Disabled myAlert from Buffer 6
         // myAlert("indicator", "SELL TREND | MA Fast: " + DoubleToString(MA5[i], 2) + " | MA Slow: " + DoubleToString(MA6[i], 2));
        }

Trend Constraint V1.04 geändert:

///Indicator Name: Trend Constraint
#property copyright "Clemence Benjamin"
#property link      "https://mql5.com"
#property version   "1.04"
#property description "A model that seek to produce sell signal when D1 candle is Bearish only and  buy signal when it is Bullish"
//--- indicator settings
#property indicator_chart_window
#property indicator_buffers 6
#property indicator_plots 6

#property indicator_type1 DRAW_ARROW
#property indicator_width1 5
#property indicator_color1 0xFF3C00
#property indicator_label1 "Buy"

#property indicator_type2 DRAW_ARROW
#property indicator_width2 5
#property indicator_color2 0x0000FF
#property indicator_label2 "Sell"

#property indicator_type3 DRAW_ARROW
#property indicator_width3 2
#property indicator_color3 0xE8351A
#property indicator_label3 "Buy Reversal"

#property indicator_type4 DRAW_ARROW
#property indicator_width4 2
#property indicator_color4 0x1A1AE8
#property indicator_label4 "Sell Reversal"

#property indicator_type5 DRAW_LINE
#property indicator_style5 STYLE_SOLID
#property indicator_width5 2
#property indicator_color5 0xFFAA00
#property indicator_label5 "Buy Trend"

#property indicator_type6 DRAW_LINE
#property indicator_style6 STYLE_SOLID
#property indicator_width6 2
#property indicator_color6 0x0000FF
#property indicator_label6 "Sell Trend"

#define PLOT_MAXIMUM_BARS_BACK 5000
#define OMIT_OLDEST_BARS 50

//--- indicator buffers
double Buffer1[];
double Buffer2[];
double Buffer3[];
double Buffer4[];
double Buffer5[];
double Buffer6[];

input double Oversold = 30;
input double Overbought = 70;
input int Slow_MA_period = 200;
input int Fast_MA_period = 100;
datetime time_alert; //used when sending alert
input bool Audible_Alerts = true;
input bool Push_Notifications = true;
double myPoint; //initialized in OnInit
int RSI_handle;
double RSI[];
double Open[];
double Close[];
int MA_handle;
double MA[];
int MA_handle2;
double MA2[];
int MA_handle3;
double MA3[];
int MA_handle4;
double MA4[];
double Low[];
double High[];
int MA_handle5;
double MA5[];
int MA_handle6;
double MA6[];

void myAlert(string type, string message)
  {
   if(type == "print")
      Print(message);
   else if(type == "error")
     {
      Print(type+" | Trend Constraint V1.04 @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
     }
   else if(type == "order")
     {
     }
   else if(type == "modify")
     {
     }
   else if(type == "indicator")
     {
      if(Audible_Alerts) Alert(type+" | Trend Constraint V1.04 @ "+Symbol()+","+IntegerToString(Period())+" | "+message);
      if(Push_Notifications) SendNotification(type+" | Trend Constraint V1.04 @ "+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, 241);
   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, 242);
   SetIndexBuffer(2, Buffer3);
   PlotIndexSetDouble(2, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(2, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(2, PLOT_ARROW, 236);
   SetIndexBuffer(3, Buffer4);
   PlotIndexSetDouble(3, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(3, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   PlotIndexSetInteger(3, PLOT_ARROW, 238);
   SetIndexBuffer(4, Buffer5);
   PlotIndexSetDouble(4, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(4, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   SetIndexBuffer(5, Buffer6);
   PlotIndexSetDouble(5, PLOT_EMPTY_VALUE, EMPTY_VALUE);
   PlotIndexSetInteger(5, PLOT_DRAW_BEGIN, MathMax(Bars(Symbol(), PERIOD_CURRENT)-PLOT_MAXIMUM_BARS_BACK+1, OMIT_OLDEST_BARS+1));
   //initialize myPoint
   myPoint = Point();
   if(Digits() == 5 || Digits() == 3)
     {
      myPoint *= 10;
     }
   RSI_handle = iRSI(NULL, PERIOD_CURRENT, 14, PRICE_CLOSE);
   if(RSI_handle < 0)
     {
      Print("The creation of iRSI has failed: RSI_handle=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle = iMA(NULL, PERIOD_CURRENT, 7, 0, MODE_SMMA, PRICE_CLOSE);
   if(MA_handle < 0)
     {
      Print("The creation of iMA has failed: MA_handle=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle2 = iMA(NULL, PERIOD_CURRENT, 400, 0, MODE_SMA, PRICE_CLOSE);
   if(MA_handle2 < 0)
     {
      Print("The creation of iMA has failed: MA_handle2=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle3 = iMA(NULL, PERIOD_CURRENT, 100, 0, MODE_EMA, PRICE_CLOSE);
   if(MA_handle3 < 0)
     {
      Print("The creation of iMA has failed: MA_handle3=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle4 = iMA(NULL, PERIOD_CURRENT, 200, 0, MODE_SMA, PRICE_CLOSE);
   if(MA_handle4 < 0)
     {
      Print("The creation of iMA has failed: MA_handle4=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle5 = iMA(NULL, PERIOD_CURRENT, Fast_MA_period, 0, MODE_SMA, PRICE_CLOSE);
   if(MA_handle5 < 0)
     {
      Print("The creation of iMA has failed: MA_handle5=", INVALID_HANDLE);
      Print("Runtime error = ", GetLastError());
      return(INIT_FAILED);
     }
   
   MA_handle6 = iMA(NULL, PERIOD_CURRENT, Slow_MA_period, 0, MODE_SMA, PRICE_CLOSE);
   if(MA_handle6 < 0)
     {
      Print("The creation of iMA has failed: MA_handle6=", 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);
   ArraySetAsSeries(Buffer3, true);
   ArraySetAsSeries(Buffer4, true);
   ArraySetAsSeries(Buffer5, true);
   ArraySetAsSeries(Buffer6, true);
   //--- initial zero
   if(prev_calculated < 1)
     {
      ArrayInitialize(Buffer1, EMPTY_VALUE);
      ArrayInitialize(Buffer2, EMPTY_VALUE);
      ArrayInitialize(Buffer3, EMPTY_VALUE);
      ArrayInitialize(Buffer4, EMPTY_VALUE);
      ArrayInitialize(Buffer5, EMPTY_VALUE);
      ArrayInitialize(Buffer6, EMPTY_VALUE);
     }
   else
      limit++;
   datetime Time[];
   
   int RSIBuffer;
   int MABuffer;
   int RSIPeriod = 14;
   ArrayResize(RSI, rates_total);
   ArrayResize(Open, rates_total);
   ArrayResize(Close, rates_total);
   CopyOpen(NULL, 0, 0, rates_total, Open);
   CopyClose(NULL, 0, 0, rates_total, Close);
   if(CopyBuffer(RSI_handle, 0, 0, rates_total, RSI) < 0)
     {
      Print("Getting RSI values failed, not enough bars!");
     }
   ArrayResize(MA, rates_total);
   if(CopyBuffer(MA_handle, 0, 0, rates_total, MA) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   ArrayResize(MA2, rates_total);
   if(CopyBuffer(MA_handle2, 0, 0, rates_total, MA2) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   ArrayResize(MA3, rates_total);
   if(CopyBuffer(MA_handle3, 0, 0, rates_total, MA3) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   ArrayResize(MA4, rates_total);
   if(CopyBuffer(MA_handle4, 0, 0, rates_total, MA4) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   ArrayResize(Low, rates_total);
   if(CopyLow(NULL, 0, 0, rates_total, Low) < 0)
     {
      Print("Getting LOW values failed, not enough bars!");
     }
   ArrayResize(High, rates_total);
   if(CopyHigh(NULL, 0, 0, rates_total, High) < 0)
     {
      Print("Getting HIGH values failed, not enough bars!");
     }
   ArrayResize(MA5, rates_total);
   if(CopyBuffer(MA_handle5, 0, 0, rates_total, MA5) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   ArrayResize(MA6, rates_total);
   if(CopyBuffer(MA_handle6, 0, 0, rates_total, MA6) < 0)
     {
      Print("Getting MA values failed, not enough bars!");
     }
   
   for(int i=limit-1; i>=0; i--)
     {
      if(i < rates_total-1 && time[i] != time[i+1]+PeriodSeconds())
        {
         continue;
        }
      Buffer1[i] = EMPTY_VALUE;
      Buffer2[i] = EMPTY_VALUE;
      Buffer3[i] = EMPTY_VALUE;
      Buffer4[i] = EMPTY_VALUE;
      Buffer5[i] = EMPTY_VALUE;
      Buffer6[i] = EMPTY_VALUE;

      // --- Indicator calculations
      // --- Buffer1 (Buy)
      if((Close[i] > MA[i] && MA[i] > MA2[i] && RSI[i] < Oversold) || (RSI[i] < Oversold && Close[i] > MA3[i]))
        {
         Buffer1[i] = Low[i] - 5 * myPoint;
         myAlert("indicator", "BUY OPPORTUNITY | RSI: " + DoubleToString(RSI[i], 2) + " | MA: " + DoubleToString(MA[i], 2));
        }
      
      // --- Buffer2 (Sell)
      if((Close[i] < MA[i] && MA[i] < MA2[i] && RSI[i] > Overbought) || (RSI[i] > Overbought && Close[i] < MA3[i]))
        {
         Buffer2[i] = High[i] + 5 * myPoint;
         myAlert("indicator", "SELL OPPORTUNITY | RSI: " + DoubleToString(RSI[i], 2) + " | MA: " + DoubleToString(MA[i], 2));
        }
      
      // --- Buffer3 (Buy Reversal)
      if(RSI[i] < Oversold && Close[i] > MA[i])
        {
         Buffer3[i] = Low[i] - 10 * myPoint;
         myAlert("indicator", "BUY REVERSAL | RSI: " + DoubleToString(RSI[i], 2) + " | MA: " + DoubleToString(MA[i], 2));
        }
      
      // --- Buffer4 (Sell Reversal)
      if(RSI[i] > Overbought && Close[i] < MA[i])
        {
         Buffer4[i] = High[i] + 10 * myPoint;
         myAlert("indicator", "SELL REVERSAL | RSI: " + DoubleToString(RSI[i], 2) + " | MA: " + DoubleToString(MA[i], 2));
        }
      
      // --- Buffer5 (Buy Trend)
      if(MA5[i] > MA6[i])
        {
         Buffer5[i] = Low[i] - 15 * myPoint;
         //Disabled myAlert from Buffer 5
         // myAlert("indicator", "BUY TREND | MA Fast: " + DoubleToString(MA5[i], 2) + " | MA Slow: " + DoubleToString(MA6[i], 2));
        }
      
      // --- Buffer6 (Sell Trend)
      if(MA5[i] < MA6[i])
        {
         Buffer6[i] = High[i] + 15 * myPoint;
         // Disabled myAlert from Buffer 6
         // myAlert("indicator", "SELL TREND | MA Fast: " + DoubleToString(MA5[i], 2) + " | MA Slow: " + DoubleToString(MA6[i], 2));
        }
     }
   return(rates_total);
  }

Integration eines sozialen Netzwerks (z. B. Telegram und WhatsApp)

In diesem Artikel wird die Integration von Telegram und WhatsApp in MetaTrader 5 speziell für unseren Trend Constraint Indikator gezeigt. Dieser Prozess erweitert die Möglichkeiten von MetaTrader 5 erheblich, indem er sichere und bequeme Nachrichten in Echtzeit bietet. Diese Integrationen verbessern die Effizienz, Reaktionsfähigkeit und Effektivität der Handelsaktivitäten und dienen den Händlern von heute als wertvolle Werkzeuge. Da diese Plattformen eine große Nutzerbasis haben, kann der Austausch von Signalen mit diesen Gemeinschaften von Vorteil sein. Lassen Sie uns untersuchen, wie wir die von unserem Indikator erzeugten Signale an die Plattformen der sozialen Medien weiterleiten können. Ich habe dies recherchiert und getestet, um seine Funktionalität zu bestätigen.

Bedingungen: 

• Neueste Version der MetaTrader5 Desktop-Plattform.
• Verifizierte Whatsapp- und Telegram-Konten (Download im Playstore für Android und im App Store für IOS).
• Webbrowser z.B. Google Chrome.
• Server für das Hosting von Middleware-Skripten.

Telegramm-Integration

Schritt 1: Einen Telegram-Bot erstellen

Erstellen des Bots:

• Öffnen Sie Telegram und suchen Sie nach dem Bot „BotFather“.
• Starten Sie einen Chat mit BotFather und nutze den Befehl /newbot, um einen neuen Bot zu erstellen.
• Folgen Sie den Aufforderungen, um einen Namen und einen Nutzernamen für Ihren Bot festzulegen.
• BotFather stellt ein Token zur Verfügung, mit dem Sie mit der Telegram-API interagieren können.

Chat-ID abrufen:

• Fügen Sie Ihren Bot zu einer Telegram-Gruppe hinzu oder starte einen Chat mit ihm.
• Verwenden Sie die folgende URL in Ihrem Browser, um Updates zu erhalten und Ihre Chat-ID zu finden: https://api.telegram.org/bot<IhrBotToken>/getUpdates
• Senden Sie eine Nachricht im Chat und überprüfen Sie die URL erneut, um die Chat-ID zu finden.

Für eine umfassendere Anleitung zum Erhalt einer Chat-ID besuchen Sie Github

Schritt 2: Ein Middleware-Skript erstellen

Sie benötigen ein Skript, um Nachrichten über die API von Telegram zu versenden.

Um ein Middleware-Skript zu erstellen, werden wir die Sprache Python verwenden, wie ich es in meinen Untersuchungen gemacht habe. Dieses Python-Skript verwendet die Requests-Bibliothek, um über einen Bot eine Nachricht an einen Telegram-Chat zu senden. Im Folgenden werden die einzelnen Zeilen des Skripts erläutert:

import requests

Importiert die Anforderungsbibliothek, die für die Erstellung von HTTP-Anforderungen in Python verwendet wird. In diesem Skript wird es verwendet, um eine POST-Anfrage an die Telegram Bot API zu senden.

def send_telegram_message(chat_id, message, bot_token):

Definiert eine Funktion namens send_telegram_message: Diese Funktion benötigt drei Parameter:

1. chat_id: Der eindeutige Bezeichner für den Ziel-Chat oder der Nutzername des Ziel-Channels.
2. message: Die zu sendende Textnachricht.
3. bot_token: Das Token für den Telegram-Bot, das von @BotFather bei der Erstellung des Bots angegeben wird.

    url = f"https://api.telegram.org/bot{bot_token}/sendMessage"

Diese Zeile konstruiert die URL für die Telegram-Bot-API-Methode sendMessage unter Verwendung des angegebenen bot_token.

    payload = {
        'chat_id': chat_id,
        'text': message
    }

Erzeugt die Nutzlast für die POST-Anfrage. Dieses Wörterbuch enthält die von der sendMessage-Methode benötigten Parameter:

• chat_id: Die ID des Chats, an den die Nachricht gesendet werden soll.
• Text: Der Inhalt der Nachricht.

    response = requests.post(url, data=payload)

Diese Zeile sendet die HTTP-POST-Anforderung an die konstruierte URL mit den Nutzdaten unter Verwendung der Methode requests.post. Die Antwort der API wird in der Antwortvariablen gespeichert.

    return response.json()

Diese Zeile konvertiert die Antwort in das JSON-Format und gibt sie zurück. Diese JSON-Antwort enthält in der Regel Informationen über die gesendete Nachricht, einschließlich Nachrichten-ID, Absender, Chat-Details und mehr.

Wenn man alle Teile des Codes miteinander kombiniert, erhält man folgendes Ergebnis:

import requests

def send_telegram_message(chat_id, message, bot_token):
    url = f"https://api.telegram.org/bot{bot_token}/sendMessage"
    payload = {
        'chat_id': chat_id,
        'text': message
    }
    response = requests.post(url, data=payload)
    return response.json()

Schritt 3: Konfigurieren Sie MetaTrader 5 für die Verwendung der Middleware

Erstellen Sie ein MQL5-Skript, um Warnmeldungen über HTTP-Anfragen an Ihr Middleware-Skript zu senden.

Gehen wir die Aufschlüsselung des Codes durch und machen uns ein Bild von jeder Zeile:

void SendTelegramMessage(string chat_id, string message, string bot_token)

 Das definiert eine Funktion namens SendTelegramMessage.

Parameter innerhalb der Funktion:

• chat_id: Eine Zeichenfolge, die die Telegram-Chat-ID angibt, an die die Nachricht gesendet werden soll.
• message: Eine Zeichenfolge, die die zu sendende Nachricht enthält.
• bot_token: Eine Zeichenfolge, die das Bot-Token darstellt, das für die Autorisierung mit der Telegram-API erforderlich ist.

Hauptteil der Funktion nach der ersten Klammer:

{
    string url = "http://your-server-url/send_telegram_message";

 Weist die Server-Endpunkt-URL der Variablen url zu. Diese URL ist die Adresse des Servers, der die Weiterleitung der Nachricht an Telegram übernimmt.

    char postData[];
    StringToCharArray("chat_id=" + chat_id + "&message=" + message + "&bot_token=" + bot_token, postData);

Das Array postData:

• Deklaration: Es deklariert ein Array postData vom Typ char zur Aufnahme der POST-Anfragedaten.
• Konvertierung von Zeichenketten in Char-Arrays: Konvertiert eine verkettete Zeichenfolge aus den Parametern chat_id, message und bot_token in ein Zeichenarray und speichert es in postData. Die verkettete Zeichenfolge bildet den Textkörper der POST-Anforderung in dem vom Server benötigten Format.

    char result[];

Deklaration des Arrays result vom Typ char , um die Antwort der Webanfrage zu speichern.

    int res = WebRequest("POST", url, "", NULL, 0, postData, 0, result, NULL);

Web-Anfrage:

• HTTP-Methode: „POST“ gibt die Art der Anfrage an.
• URL: url ist der Endpunkt, an den die Anfrage gesendet wird.
• Headers: Eine leere Zeichenkette "" bedeutet, dass keine zusätzlichen Kopfzeilen vorhanden sind.
• Cookies: NULL bedeutet keine Cookies.
• Timeout: 0 gibt keine Timeout (Ablaufzeit) an.
• Post Data: postData sind die Daten, die in der POST-Anfrage gesendet werden.
• Result: Das Ergebnis ist der Ort, an dem die Antwort gespeichert wird.
• Die Funktion gibt eine ganze Zahl res zurück, die den HTTP-Statuscode der Antwort angibt.

    if (res != 200)

Antwortcode prüfen: Vergleicht den Antwortcode res mit 200 (HTTP OK). Ist er nicht 200, liegt ein Fehler vor.

Fehlerbehandlung:

    {
        Print("Error sending message: ", GetLastError());
    }

Fehlermeldung drucken: Wenn der Antwortcode nicht 200 ist, gibt dieser Block eine Fehlermeldung zusammen mit dem letzten Fehlercode unter Verwendung von GetLastError() aus.

Erfolgsbehandlung:

    else
    {
        Print("Message sent successfully.");
    }

Erfolgsmeldung drucken: Wenn der Antwortcode 200 lautet, gibt dieser Block eine Erfolgsmeldung aus, die besagt, dass die Nachricht erfolgreich gesendet wurde.

Diese Zeile beendet die Funktion SendTelegramMessage mit einer schließenden Klammer.

 MQL5 Code Senden von Telegram-Nachrichten:

void SendTelegramMessage(string chat_id, string message, string bot_token)
{
    string url = "http://your-server-url/send_telegram_message";
    char postData[];
    StringToCharArray("chat_id=" + chat_id + "&message=" + message + "&bot_token=" + bot_token, postData);
    
    char result[];
    int res = WebRequest("POST", url, "", NULL, 0, postData, 0, result, NULL);
    if (res != 200)
    {
        Print("Error sending message: ", GetLastError());
    }
    else
    {
        Print("Message sent successfully.");
    }
}

Das obige MQL5-Skript wurde entwickelt, um eine Nachricht an einen Telegram-Chat zu senden, indem eine Web-Anfrage an einen Server-Endpunkt gestellt wird. Das Verwendungsbeispiel zeigt, wie die Funktion SendTelegramMessage innerhalb des OnStart-Ereignisses verwendet wird, das beim Starten des Skripts ausgeführt wird. Wir sehen uns die WhatsApp-Integration im nächsten Abschnitt an, und wir haben erklärt, dass die Integration von Telegram Sinn macht, auch wenn es jetzt eine andere soziale Plattform ist. Denken Sie immer daran, einen Teil des Codes durch Ihre tatsächlichen Anmeldedaten zu ersetzen, damit sie funktionieren.

WhatsApp-Integration

Schritt 1: Registrieren Sie sich bei einem Messaging-API-Anbieter.

• Wählen eines Anbieters: Twilio ist eine beliebte Wahl für die Integration von WhatsApp.
• Erstellen eines Kontos: Melden Sie sich bei Twilio an und führen Sie alle erforderlichen Verifizierungen durch.
• API-Zugangsdaten abrufen: Holen Sie sich Ihre API-Anmeldeinformationen (Konto-SID, Auth-Token) von Twilio.

Schritt 2: Erstellen Sie ein Middleware-Skript.

Middleware Python-Skript für WhatsApp-Integration:

import requests

def send_whatsapp_message(to, message, account_sid, auth_token):
    url = f"https://api.twilio.com/2010-04-01/Accounts/{account_sid}/Messages.json"
    payload = {
        'From': 'whatsapp:[phone]',  # Twilio sandbox number
        'To': f'whatsapp:{to}',
        'Body': message
    }
    headers = {
        'Authorization': f'Basic {account_sid}:{auth_token}'
    }
    response = requests.post(url, data=payload, headers=headers)
    return response.json()

Schritt 3: Konfigurieren Sie MetaTrader 5 für die Verwendung der Middleware

MQL5-Code sendet WhatsApp-Nachrichten:

void SendWhatsAppMessage(string to, string message, string account_sid, string auth_token)
{
    string url = "http://your-server-url/send_whatsapp_message";
    char postData[];
    StringToCharArray("to=" + to + "&message=" + message + "&account_sid=" + account_sid + "&auth_token=" + auth_token, postData);
    
    char result[];
    int res = WebRequest("POST", url, "", NULL, 0, postData, 0, result, NULL);
    if (res != 200)
    {
        Print("Error sending message: ", GetLastError());
    }
    else
    {
        Print("Message sent successfully.");
    }
}

Die Macht des Virtual Private Service (VPS) in unserem Nachrichtensystem

Ein Virtual Private Service arbeitet kontinuierlich und ohne Ausfallzeiten und stellt sicher, dass Ihre MetaTrader 5 Plattform und Ihre Benachrichtigungssysteme immer aktiv sind. Dies ist entscheidend für den Erhalt von Echtzeit-Nachrichten ohne Unterbrechungen. VPS-Provider bieten robuste und stabile Internetverbindungen und verringern so das Risiko von Verbindungsabbrüchen, die bei Heim- oder Büronetzwerken auftreten können.  VPS-Server befinden sich oft in Datenzentren mit Hochgeschwindigkeitsverbindungen zu den großen Finanzbörsen, wodurch die Latenzzeit verringert und die Geschwindigkeit, mit der Handelswarnungen und -nachrichten empfangen und umgesetzt werden, verbessert wird.  Im Gegensatz zum Shared Hosting bietet ein VPS dedizierte CPU-, RAM- und Speicherressourcen, die eine gleichbleibende Leistung für die Ausführung von MetaTrader 5 und die Bearbeitung von Nachrichten gewährleisten.  Auf einen VPS kann von jedem Gerät mit einer Internetverbindung aus zugegriffen werden. So können Sie Ihre MetaTrader 5-Plattform verwalten und von überall aus Nachrichten erhalten.

Schlussfolgerung

Wir haben erfolgreich ein robustes Benachrichtigungssystem für unseren Indikator konfiguriert und damit die Grundlage für die Integration von WhatsApp und Telegram gelegt. Diese Verbesserung ist entscheidend für die Anziehung einer großen Gemeinschaft, da diese Signale sofort weitergegeben werden können. Die Entwickler können davon profitieren, indem sie diese Signale über diese beliebten Plattformen an interessierte Händler vermarkten und so eine schnelle und effiziente Übertragung direkt von der Plattform zu den Social-Media-Kanälen ermöglichen.

Dieser Ansatz gewährleistet, dass das Signal jederzeit und überall, wo ein Internetzugang vorhanden ist, zugänglich ist und mit nur einem Klick weitergegeben werden kann. Händler können bequem zwischen Telegram oder WhatsApp für den Signalzugang wählen. Weitere Einzelheiten zur Integration werden in Teil II behandelt. Im Anhang finden Sie die Referenzdateien. Sie können sich gerne an den Diskussionen im Kommentarbereich beteiligen.