Entwicklung eines Toolkit zur Analyse von Preisaktionen (Teil 4): Der Analytik Forecaster EA

Inhalt:

• Einführung
• Rückblick auf den vorherigen Artikel
• Überblick über das Projekt
• Aufbau eines Telegram-Bots und Abruf von Chart-IDs
• Implementierung der Telegram-Integration in den EA (Expert Advisor)
• Prüfung 
• Schlussfolgerung

Einführung

Nach dem Übergang von einem Skript zu einem Expert Advisor (EA) wurde das vorherige Tool, der EA Analytics Master, entwickelt, um wichtige Kennzahlen zu analysieren und kontinuierliche Aktualisierungen direkt auf dem Chart zu liefern. Es diente zwar als Grundlage, seine Möglichkeiten waren jedoch auf den Zugriff auf Analyseinformationen innerhalb des Charts selbst beschränkt. Bevor wir mit der Entwicklung fortschrittlicherer Analysewerkzeuge fortfahren, halte ich es für unerlässlich, unsere analytische Informationsübertragung zu verbessern.

In diesem Artikel werden wir uns auf die Integration unserer Sendung mit Telegram konzentrieren, um einen breiteren Zugang zu analysierten Informationen zu gewährleisten. Ich habe Telegram für diesen Zweck gewählt, da es bei Händlern sehr beliebt und leicht zugänglich ist. Die Integration von MetaTrader 5 Chart-Updates mit Telegram bietet aktiven Händlern erhebliche Vorteile. Diese Einrichtung bietet unmittelbaren Zugang zu wichtigen Marktinformationen, erhöht die Nutzerfreundlichkeit und verbessert die Kommunikation. So können Sie wirksamere Strategien entwickeln und auf einem sich schnell verändernden Markt schnell reagieren. Mit dieser Integration können Sie Ihre Erfolgschancen erhöhen und fundiertere, zeitnahe Entscheidungen treffen.

Rückblick auf den vorherigen Artikel

Werfen wir einen Blick auf unser vorheriges Tool, den EA Analytics Master, um eine Zusammenfassung zu erhalten. Wir integrieren die gleichen Analyseinformationen aus diesem Tool in Telegram. Um mehr darüber zu erfahren, folgen Sie dem Link https://www.mql5.com/de/articles/16434. Der EA Analytics Master wurde entwickelt, um die folgenden wichtigen Marktkennzahlen zu analysieren und zu berechnen:

• Eröffnungs- und Schlusskurs des Vortages
• Volumen des Vortages
• Volumen des aktuellen Tages
• Hoch und Tief des Vortages
• Wichtige Unterstützungs- und Widerstandsniveaus
• Kontostand
• Kapital auf dem Konto
• Markt-Spread
• Minimale und maximale Losgröße
• Marktvolatilität

Das Verständnis dieser metrischen Werte ist für Händler von entscheidender Bedeutung, da sie Einblicke in das Marktverhalten und die Trends bieten. Die Metriken der vergangenen Tage helfen dabei, einen Kontext für die aktuellen Marktbedingungen zu schaffen, während die aktuellen Metriken bei der Beurteilung der Leistung helfen. Durch die Identifizierung von Unterstützungs- und Widerstandsniveaus können Händler fundiertere Entscheidungen über Einstiegs- und Ausstiegspunkte treffen. Die Kenntnis des Kontostandes und des Eigenkapitals stellt zudem sicher, dass das Handelsrisiko wirksam gesteuert wird. Die Kenntnis von Markt-Spreads, Losgrößen und Volatilität ist entscheidend für die Optimierung der Handelsausführung und die Maximierung potenzieller Gewinne bei gleichzeitiger Minimierung der Risiken. Insgesamt ermöglicht ein solides Verständnis dieser Metriken den Händlern, fundierte Strategien zu entwickeln und die allgemeine Handelsleistung zu verbessern.

Der EA zeichnete Trendlinien für wichtige Unterstützungs- und Widerstandsniveaus und lieferte die voraussichtliche Marktrichtung auf der Grundlage der berechneten Metriken. All diese Informationen wurden auf dem Chart in einem tabellenähnlichen Format dargestellt und regelmäßig alle zwei Stunden aktualisiert. Siehe Abb. 1 unten.

Abb. 1. Ergebnis von Analytik Master

Der Analyseabschnitt enthält auch den Zeitpunkt der letzten Aktualisierung, sodass die neuesten Informationen leicht zu finden sind. Das Tool dient ausschließlich der Marktanalyse; es führt keine Handelsgeschäfte automatisch aus. Die Nutzer müssen ihre Handelsgeschäfte manuell auf der Grundlage der analysierten Informationen und der generierten Signale ausführen. Um optimale Ergebnisse zu erzielen, ist es wichtig, diese Daten mit der eigenen Handelsstrategie zu kombinieren.

Überblick über das Projekt

Die Telegram-Integration mit MetaTrader 5 beinhaltet die Verbindung der MetaTrader 5-Handelsplattform mit Telegram, einem Messaging-Dienst, der es Händlern ermöglicht, sofortige Nachrichten, Alarme und Analysen über ihre Handelsaktivitäten direkt in ihrem Telegram-Chat zu erhalten. Diese Integration nutzt die Telegram Bot API und ermöglicht eine automatisierte Kommunikation zwischen dem Handelsalgorithmus oder Expert Advisor (EA), der auf MetaTrader 5 läuft, und einem bestimmten Telegram-Chat. Das folgende Diagramm fasst alles zusammen.

Abb. 2. Integrationspfad

Schlüsselkomponenten der Integration

• Telegram-Bot: Erstellen eines Telegram-Bot mit dem BotFather auf Telegram, der ein Zugriffstoken bereitstellt, das zur Authentifizierung von Anfragen an die Telegram-API benötigt wird.
• Chat-ID: Eingabe der Chat-ID, an die die Nachrichten gesendet werden sollen. Dabei kann es sich um einen persönlichen Chat oder einen Gruppenchat handeln, und es wird verwendet, um zu bestimmen, wohin die Warnmeldungen gesendet werden.
• MetaTrader 5: Verwendung der Programmiersprache MQL5, um EAs oder Skripte zu entwickeln oder zu ändern, die sich mit der Telegram-API verbinden können. In der Regel werden dabei HTTP-POST-Anfragen zum Senden von Nachrichten verwendet.

Aufbau eines Telegram-Bots und Abruf von Chart-IDs 

Telegram-Bots sind automatisierte Softwareanwendungen, die innerhalb der Telegram-Messaging-Plattform arbeiten und die Interaktion mit Nutzern durch automatisierte Aufgaben ermöglichen. Eine ihrer Hauptfunktionen besteht darin, die Kommunikation zu rationalisieren, indem sie ohne menschliches Zutun schnelle und relevante Antworten auf Nutzeranfragen geben. Diese Funktion ermöglicht es Unternehmen und Entwicklern, verschiedene Aufgaben zu automatisieren, z. B. das Versenden von Nachrichten und die Verarbeitung von Befehlen, was die Nutzerfreundlichkeit und das Engagement verbessert.

Darüber hinaus zeichnen sich Telegram-Bots bei der Informationsbeschaffung aus: Sie können Daten aus externen Quellen wie Marktdaten oder Nachrichtenfeeds abrufen und sie direkt an die Nutzer weiterleiten. Im Zusammenhang mit dem Handel sind Bots besonders wertvoll, um Nutzer über bestimmte Marktereignisse, Preisänderungen oder Signale auf der Grundlage vordefinierter Kriterien zu informieren. Durch ihre Fähigkeit zur Integration mit APIs und anderen Diensten können sie außerdem erweiterte Funktionen wie Datenanalyse und Berichterstellung ausführen, was sie zu vielseitigen Tools für verschiedene Anwendungen macht. Folgen Sie den folgenden Schritten, um Ihren Telegram-Bot zu erstellen:

Schritt 1: Telegram App öffnen

Stellen Sie sicher, dass Sie die Telegram-App auf Ihrem Gerät installiert haben.

Schritt 2: Suche nach dem BotFather

Abb. 3. Botfather

Eingeben von BotFather in der Suchleiste der App.

BotFather ist ein offizieller Telegram-Bot, mit dem Sie andere Bots erstellen und verwalten können.

Schritt 3: Beginn eines Chats mit BotFather

Abb. 4. Schritt 3 und 4

Mit einem Klick auf das BotFather-Ergebnis den Chat öffnen.

Mit einem Klick auf die Schaltfläche Start oder durch die Eingabe von /start, um das Gespräch zu beginnen.

Schritt 4: Erstellen eines neuen Bot

Den Befehl /newbot eingeben und absenden.

BotFather wird Sie auffordern, einen Namen für Ihren Bot zu wählen. Dies ist der Anzeigename, den die Nutzer sehen werden.

Nachdem Sie den Namen eingegeben haben, werden Sie aufgefordert, einen Nutzernamen für Ihren Bot anzugeben. Der Nutzername muss auf „bot“ enden (z. B. MyCoolBot).

Schritt 5: Erhalten Sie Ihr Bot-Token

Abb. 5. Schritt 5

Sobald Sie die vorherigen Schritte abgeschlossen haben, wird BotFather Ihren Bot erstellen und Ihnen ein eindeutiges API-Token zur Verfügung stellen. Dieses Token ist für die Interaktion mit der Telegram Bot API unerlässlich, also speichern Sie es an einem sicheren Ort.

Nach dem Erstellen des Telegram-Bot, muss im nächsten Schritt die persönliche Chat-ID gefunden werden. Chart-IDs andererseits dienen als eindeutige Identifikatoren, die bestimmten Datenvisualisierungen oder Charts innerhalb von Handelsanwendungen oder Charting-Tools zugewiesen werden. Diese IDs spielen eine entscheidende Rolle bei der Identifizierung und dem Abruf von Charts, sodass Nutzer und Entwickler leicht auf bestimmte Visualisierungen verweisen können. Chart-IDs erleichtern die Extraktion aktueller oder historischer Daten in Bezug auf bestimmte Charte und ermöglichen so einen maßgeschneiderten Ansatz für die Datenanalyse. Dieser Aspekt ist besonders im Handel von Vorteil, da er den Nutzern einen schnellen Zugriff auf relevante Informationen ermöglicht, was zu fundierten Entscheidungen führt.

Darüber hinaus ermöglichen die Chart-IDs eine individuelle Anpassung, sodass die Entwickler Parameter und Einstellungen entsprechend den individuellen Nutzerpräferenzen oder Handelsstrategien ändern können. Wenn sie in Telegram-Bots integriert werden, können Chart-IDs die Funktionalität erheblich verbessern. Sie ermöglichen es den Bots, den Nutzern spezifische Datenvisualisierungen direkt in ihrer Chat-Oberfläche zur Verfügung zu stellen und so den Prozess der Gewinnung von Erkenntnissen und Handelsentscheidungen zu vereinfachen. Nachfolgend finden Sie zwei Methoden, um es mit Telegram-Bots zu erwerben.

Methode 1: Verwendung von Get ID Bots

Dies ist ein unkomplizierter Ansatz. Sie können nach Bots wie @get_id_bot oder @userinfobot suchen und diese öffnen. Sobald Sie den Bot starten, indem Sie auf die Schaltfläche Start klicken oder /start eingeben, antwortet er mit Ihrer Chat-ID, die Sie sich dann notieren können.

Abb. 6. ID abrufen

Methode 2: Verwendung eines Webbrowsers

Beginnen Sie damit, eine beliebige Nachricht an Ihren Bot in Telegram zu senden. Öffnen Sie dann einen Webbrowser und geben Sie die folgende URL ein, wobei Sie <IhrBotToken> durch Ihr tatsächliches Bot-Token ersetzen: 

https://api.telegram.org/bot<YourBotToken>/getUpdates

Nachdem Sie die Eingabetaste gedrückt haben, prüfen Sie die von der API zurückgegebene Antwort. Ihre Chat-ID finden Sie im Abschnitt „Ergebnis“ der Antwort.

Implementierung der Telegram-Integration in den EA (Expert Advisor)

Die Implementierung der Telegram-Integration in den EA beinhaltet die Einbindung der Telegram-Nachrichtenfunktionen in unseren Expert Advisor (EA) auf MetaTrader. Diese Integration ermöglicht es dem EA, sofortige Nachrichten und Alarme direkt an ein Telegram-Konto zu senden, sodass die Nutzer über Marktbedingungen, wichtige Kennzahlen und andere wichtige Handelsinformationen informiert sind. Indem ich die API von Telegram nutze, kann ich die Funktionalität des EAs erweitern und sicherstellen, dass die Nutzer wichtige Updates erhalten, ohne ständig die Handelsplattform überprüfen zu müssen. Dies verbessert die Reaktionsfähigkeit auf Marktveränderungen und macht den Handel letztlich effizienter.

Der Code des Analytics Master EA wurde durch die Integration von Befehlen verbessert, die es ermöglichen, analysierte Metriken an die Telegram-App weiterzuleiten. Ich stelle den kompletten integrierten MQL5-Code zur Verfügung und führe Sie Schritt für Schritt durch den Integrationsprozess.

Der Code des Analytics Forecaster EA

//+-------------------------------------------------------------------+
//|                                        Analytics Forecaster EA.mq5|
//|                                 Copyright 2024, Christian Benjamin|
//|                                               https://www.mql5.com|
//+-------------------------------------------------------------------+
#property copyright   "2024, MetaQuotes Software Corp."
#property link        "https://www.mql5.com/en/users/lynnchris"
#property description "EA for market analysis,commenting and Telegram Integeration"
#property version     "1.1"
#property strict

// Inputs for risk management
input double RiskPercentage = 1.0;        // Percentage of account balance to risk per trade
input double StopLossMultiplier = 1.0;    // Multiplier for determining the stop loss distance
input int ATR_Period = 14;                // Period for ATR calculation

// Telegram configuration
input string TelegramToken = "YOUR BOT TOKEN"; // Your Telegram bot token
input string ChatID = "YOUR CHART ID"; // Your chat ID
input bool SendTelegramAlerts = true; // Option to enable/disable Telegram notifications

// Global variables for storing values
datetime lastUpdateTime = 0;
double previousDayOpen, previousDayClose, previousDayHigh, previousDayLow;
double previousDayVolume;
double currentDayVolume;
double support, resistance;

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   lastUpdateTime = 0; // Set the initial update time
   return INIT_SUCCEEDED;
  }

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   ObjectsDeleteAll(0); // Clean up any drawn objects on the current chart
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   UpdateMetrics(); // Call to the function that fetches and displays the metrics
  }

//+------------------------------------------------------------------+
//| Update metrics and display them                                  |
//+------------------------------------------------------------------+
void UpdateMetrics()
  {
// Check if 2 hours have passed since the last update
   if(TimeCurrent() - lastUpdateTime >= 2 * 3600)
     {
      // Fetch previous day's data
      datetime prevDay = iTime(NULL, PERIOD_D1, 1);
      previousDayOpen = iOpen(NULL, PERIOD_D1, 1);
      previousDayClose = iClose(NULL, PERIOD_D1, 1);
      previousDayHigh = iHigh(NULL, PERIOD_D1, 1);
      previousDayLow = iLow(NULL, PERIOD_D1, 1);
      previousDayVolume = iVolume(NULL, PERIOD_D1, 1);

      // Fetch current day's volume
      currentDayVolume = iVolume(NULL, PERIOD_D1, 0); // Volume for today

      // Calculate support and resistance
      support = previousDayLow - (previousDayHigh - previousDayLow) * 0.382; // Fibonacci level
      resistance = previousDayHigh + (previousDayHigh - previousDayLow) * 0.382; // Fibonacci level

      // Determine market direction
      string marketDirection = AnalyzeMarketDirection(previousDayOpen, previousDayClose, previousDayHigh, previousDayLow);

      // Calculate possible lot size based on risk management
      double lotSize = CalculateLotSize(support, resistance);

      // Retrieve account metrics
      double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
      double accountEquity = AccountInfoDouble(ACCOUNT_EQUITY);

      // Calculate market spread manually
      double marketBid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
      double marketAsk = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      double marketSpread = marketAsk - marketBid; // Calculate spread

      double minLotSize = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
      double maxLotSize = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MAX);

      // Calculate market volatility using ATR
      int atrHandle = iATR(NULL, PERIOD_H1, ATR_Period); // Get the ATR handle
      double atrValue = 0.0;

      if(atrHandle != INVALID_HANDLE)   // Check if the handle is valid
        {
         double atrBuffer[]; // Array to hold the ATR values
         if(CopyBuffer(atrHandle, 0, 0, 1, atrBuffer) > 0)   // Copy the latest ATR value
           {
            atrValue = atrBuffer[0]; // Retrieve the ATR value from the buffer
           }
         IndicatorRelease(atrHandle); // Release the indicator handle
        }

      // Create the output string, including pair name and last update time
      string pairName = Symbol(); // Get the current symbol name
      string lastUpdateStr = TimeToString(TimeCurrent(), TIME_DATE | TIME_MINUTES);
      string infoStr = StringFormat("Pair: %s\nPrev Day Open: %.2f\nPrev Day Close: %.2f\nPrev Day High: %.2f\nPrev Day Low: %.2f\n"
                                    "Prev Day Volume: %.0f\nCurrent Day Volume: %.0f\nMarket Direction: %s\n"
                                    "Support: %.2f\nResistance: %.2f\nAccount Balance: %.2f\nAccount Equity: %.2f\n"
                                    "Market Spread: %.2f\nMin Lot Size: %.2f, Max Lot Size: %.2f\n"
                                    "Market Volatility (ATR): %.2f\nLast Update Time: %s\nPossible Lot Size: %.2f",
                                    pairName, previousDayOpen, previousDayClose, previousDayHigh, previousDayLow,
                                    previousDayVolume, currentDayVolume, marketDirection,
                                    support, resistance, accountBalance, accountEquity, marketSpread,
                                    minLotSize, maxLotSize, atrValue, lastUpdateStr, lotSize);

      // Log the information
      Print(infoStr);

      // Display information on the chart
      Comment(infoStr);

      // Send Telegram notification
      if(SendTelegramAlerts)
         SendTelegramMessage(infoStr);

      // Remove old trend lines and create new ones for previous day's high/low
      ObjectsDeleteAll(0);

      // Draw continuous trend lines
      DrawContinuousTrendLine("PrevDayHigh", previousDayHigh);
      DrawContinuousTrendLine("PrevDayLow", previousDayLow);

      // Update last update time
      lastUpdateTime = TimeCurrent();
     }
  }

//+------------------------------------------------------------------+
//| Analyze market direction                                         |
//+------------------------------------------------------------------+
string AnalyzeMarketDirection(double open, double close, double high, double low)
  {
   string direction;

   if(close > open)
     {
      direction = "Bullish";
     }
   else
      if(close < open)
        {
         direction = "Bearish";
        }
      else
        {
         direction = "Neutral";
        }

// Include current trends or patterns based on high and low for further analysis
   if(high > open && high > close)
     {
      direction += " with bullish pressure"; // Example addition for context
     }
   else
      if(low < open && low < close)
        {
         direction += " with bearish pressure"; // Example addition for context
        }

   return direction;
  }

//+------------------------------------------------------------------+
//| Draw a continuous trend line to the left on the chart            |
//+------------------------------------------------------------------+
void DrawContinuousTrendLine(string name, double price)
  {
   datetime startTime = TimeCurrent() - 720 * 3600; // Extend 24 hours into the past
   ObjectCreate(0, name, OBJ_TREND, 0, startTime, price, TimeCurrent(), price);
   ObjectSetInteger(0, name, OBJPROP_COLOR, (StringFind(name, "High") >= 0) ? clrRed : clrBlue);
   ObjectSetInteger(0, name, OBJPROP_WIDTH, 2); // Set thickness of the line
   ObjectSetInteger(0, name, OBJPROP_XSIZE, 0); // Set this property to extend the line infinitely to the left
  }

//+------------------------------------------------------------------+
//| Calculate the lot size based on risk management                  |
//+------------------------------------------------------------------+
double CalculateLotSize(double support, double resistance)
  {
   double stopLossDistance = MathAbs((support - resistance) * StopLossMultiplier);
   double riskAmount = AccountInfoDouble(ACCOUNT_BALANCE) * (RiskPercentage / 100.0);

// Get the tick size for the current symbol
   double tickSize = SymbolInfoDouble(_Symbol, SYMBOL_TRADE_TICK_SIZE);

// Calculate the lot size based on the stop loss and tick size
   double lotSize = riskAmount / (stopLossDistance / tickSize); // Adjusted for the correct pip size
   lotSize = NormalizeDouble(lotSize, 2); // Normalize the lot size to two decimal places

// Ensure lot size is above minimum lot size allowed by broker
   double minLotSize = SymbolInfoDouble(_Symbol, SYMBOL_VOLUME_MIN);
   if(lotSize < minLotSize)
      lotSize = minLotSize;

   return lotSize;
  }

//+------------------------------------------------------------------+
//| Send message to Telegram API                                     |
//+------------------------------------------------------------------+
void SendTelegramMessage(string message)
  {
   string url = StringFormat("https://api.telegram.org/bot%s/sendMessage", TelegramToken);
   string headers = "Content-Type: application/json\r\n"; // Content type for JSON
   int timeout = 1000; // Timeout in milliseconds

// Format the data as JSON
   string postData = StringFormat("{\"chat_id\":\"%s\",\"text\":\"%s\"}", ChatID, message);

// Convert the string to a char array
   char dataArray[];
   StringToCharArray(postData, dataArray);

// Prepare the result buffer and response headers
   char result[];
   string responseHeaders;

// Perform the web request
   int responseCode = WebRequest("POST", url, headers, timeout, dataArray, result, responseHeaders);
   if(responseCode == 200)   // HTTP 200 OK
     {
      Print("Message sent successfully!");
     }
   else
     {
      PrintFormat("Error sending message. HTTP Response Code: %d. Error: %s", responseCode, GetLastError());
     }
  }

//+------------------------------------------------------------------+
//+------------------------------------------------------------------+

1. Eingabevariablen deklarieren:

Zu Beginn unseres EA sollten wir die erforderlichen Eingabevariablen deklarieren. Eingabevariablen in MQL5 ermöglichen es Händlern, die Funktionsweise des EAs anzupassen, ohne in den Code selbst einzugreifen. Dies erleichtert eine schnelle Anpassung der Handelsstrategien. Es ist wichtig, dass wir unsere Variablen intuitiv benennen. TelegramToken zum Beispiel gibt seinen Zweck klar an. Erwägen Sie die Verwendung von Standardwerten für Ihre Variablen, die der gängigen Praxis oder den Einstellungen in Ihrer Handelsstrategie entsprechen, um die Komplexität der Konfiguration beim Testen zu verringern.

input string TelegramToken = "YOUR_BOT_API_TOKEN"; // Replace with your actual bot token
input string ChatID = "YOUR_CHAT_ID"; // Replace with your actual chat ID
input bool SendTelegramAlerts = true; // Control whether alerts are sent

 Denken Sie daran, „YOUR_BOT_API_TOKEN“ und „YOUR_CHAT_ID“ durch die tatsächlichen Werte zu ersetzen.

2. Erstellen Sie die Funktion zum Versenden von Nachrichten:

Die Funktion SendTelegramMessage erstellt eine strukturierte HTTP-POST-Anfrage an die Telegram-API und sendet eine Benachrichtigung an den angegebenen Chat. Durch die Vorbereitung der API-URL, das Festlegen der Kopfzeilen, die Formatierung der Nachrichtendaten als JSON, die Ausführung der Anfrage und die Bearbeitung der Antwort ermöglicht diese Funktion dem EA die sofortige Übermittlung von Aktualisierungen an Nutzer über Telegram. Diese gestraffte Logik ermöglicht eine schnelle Kommunikation von Trades und Alarmen und verbessert die Gesamtfunktionalität des EA als Handelsassistent, indem er den Nutzer mühelos auf dem Laufenden hält.

• Zweck der Funktion: Diese Funktion regelt die Kommunikation mit der Telegram-API. Sie kapselt die Logik, die benötigt wird, um eine Nachricht an unseren Telegram-Bot zu senden. Durch die Erstellung wiederverwendbarer Funktionen sorgen wir für einen übersichtlichen Code und reduzieren Doppelarbeit.
• Fehlerbehandlung: Die Einbeziehung der Fehlerbehandlung ist entscheidend. Wenn wir eine Nachricht senden, sollten wir nicht nur erfolgreiche Sendungen protokollieren, sondern auch alle Fehler, die auftreten. Diese Praxis erleichtert die Fehlersuche und gibt Feedback.

void SendTelegramMessage(string message)
{
    string url = StringFormat("https://api.telegram.org/bot%s/sendMessage", TelegramToken);
    string headers = "Content-Type: application/json\r\n";
    int timeout = 1000;

    string postData = StringFormat("{\"chat_id\":\"%s\",\"text\":\"%s\"}", ChatID, message);

    char dataArray[];
    StringToCharArray(postData, dataArray);

    char result[];
    string responseHeaders;

    int responseCode = WebRequest("POST", url, headers, timeout, dataArray, result, responseHeaders);
    if (responseCode == 200)
    {
        Print("Message sent successfully! Response: ", CharArrayToString(result));
    }
    else
    {
        PrintFormat("Error sending message. HTTP Response Code: %d. Error: %s", responseCode, GetLastError());
    }
}

• Verstehen von WebRequest: Die Funktion WebRequest ist von entscheidender Bedeutung, da sie unserem EA ermöglicht, HTTP-Anforderungen an APIs zu stellen. Vergewissern Sie sich, dass die Option „Automatischen Handel zulassen“ in den EA-Eigenschaften aktiviert ist, damit er ordnungsgemäß funktioniert.

3. Auslösen der Telegram-Nachricht

• Zeitprüfung und Abruf von Daten

Der erste Teil des Codes leitet eine Zeitprüfung ein, um festzustellen, ob seit der letzten Aktualisierung der Marktkennzahlen zwei Stunden vergangen sind. Mit der FunktionTimeCurrent() wird die aktuelle Zeit abgerufen und mit der Variablen lastUpdateTime verglichen. Wenn mehr als zwei Stunden verstrichen sind, sammelt der Expert Advisor (EA) die neuesten Daten zu den Marktbedingungen. Diese Prüfung ist wichtig, um zu verhindern, dass der EA den Telegram-Chat zu häufig mit Nachrichten überflutet, was vom Nutzer als Spam empfunden werden könnte.

// Check if 2 hours have passed since the last update
if (TimeCurrent() - lastUpdateTime >= 2 * 3600)
{
    // ... [Code that fetches data and calculates support/resistance, etc.]
}

• Erstellen des Output-Strings

Im zweiten Teil wird eine detaillierte, ausgegebene Zeichenkette, infoStr genannt, erstellt, um die aus den Operationen des EA gesammelten Marktmetriken zu konsolidieren. Der Code ruft das aktuelle Handelssymbol mit dem Paar-Namen ab und formatiert zusätzlich die aktuelle Zeit für die Nachricht mit lastUpdateStr. Die Funktion StringFormat wird dann verwendet, um die Nachricht zu erstellen. Sie enthält verschiedene Platzhalter, die durch die spezifischen Metriken ersetzt werden, z. B. Höchst-, Tiefst-, Eröffnungs- und Schlusskurs des Vortags, Volumen des aktuellen Tages, Marktrichtung und andere Kontodetails. Diese formatierte Zeichenfolge ist ein wesentlicher Bestandteil der Operation, da sie eine klare und strukturierte Zusammenfassung der aktuellen Marktbedingungen darstellt, die später über Telegram gesendet wird.

// Create the output string, including pair name and last update time
string pairName = Symbol(); // Get the current symbol name
string lastUpdateStr = TimeToString(TimeCurrent(), TIME_DATE | TIME_MINUTES);
string infoStr = StringFormat("Pair: %s\nPrev Day Open: %.2f\nPrev Day Close: %.2f\n"
                               "Prev Day High: %.2f\nPrev Day Low: %.2f\n"
                               "Prev Day Volume: %.0f\nCurrent Day Volume: %.0f\n"
                               "Market Direction: %s\nSupport: %.2f\nResistance: %.2f\n"
                               "Account Balance: %.2f\nAccount Equity: %.2f\n"
                               "Market Spread: %.2f\nMin Lot Size: %.2f, Max Lot Size: %.2f\n"
                               "Market Volatility (ATR): %.2f\nLast Update Time: %s\nPossible Lot Size: %.2f",
                               pairName, previousDayOpen, previousDayClose, previousDayHigh,
                               previousDayLow, previousDayVolume, currentDayVolume,
                               marketDirection, support, resistance, accountBalance,
                               accountEquity, marketSpread, minLotSize, maxLotSize,
                               atrValue, lastUpdateStr, lotSize);

•  Protokollierung und Darstellung von Informationen

Im dritten Teil geht es um die Protokollierung und Darstellung der erstellten Informationen. Der Aufruf der Funktion Print(infoStr); dient dazu, die Nachricht auf der Registerkarte Experts der MetaTrader-Plattform zu protokollieren, sodass die über Telegram gesendeten Informationen sichtbar werden. Dies ist ein nützliches Debugging-Tool, um zu bestätigen, dass die Metriken korrekt formuliert sind. Darüber hinaus zeigt der Befehl Comment(infoStr); dieselben Informationen direkt auf dem Handels-Chart an und bietet Händlern eine visuelle Bestätigung der Metriken, ohne dass sie die Protokolle einsehen müssen. Diese Schritte informieren den Nutzer über die gemeldeten Metriken und überprüfen die Richtigkeit der Daten, bevor sie an Telegram gesendet werden.

// Log the information
Print(infoStr); // Here the information is logged for debugging

// Display information on the chart
Comment(infoStr); // Display the same information on the chart

• Senden der Telegram-Nachricht

Im letzten Teil verwaltet der Code das eigentliche Senden der Telegram-Benachrichtigung. if (SendTelegramAlerts) prüft, ob die Option zum Senden von Nachrichten aktiviert ist, sodass Nutzer Nachrichten einfach deaktivieren können, ohne dass Codeänderungen erforderlich sind. Wenn Warnungen aktiviert sind, wird die Funktion SendTelegramMessage(infoStr) aufgerufen, die die sorgfältig erstellte Nachricht an den angegebenen Telegram-Chat sendet. Dieser Schritt ist von entscheidender Bedeutung, denn hier werden Kennzahlen des Marktes dem Nutzer effektiv vermittelt. Anschließend aktualisiert der Code die Variable lastUpdateTime mit lastUpdateTime = TimeCurrent(); auf die aktuelle Zeit, wodurch der Abschluss dieses Aktualisierungszyklus markiert und sichergestellt wird, dass der Zeitplan für die nächste Aktualisierung das zuvor festgelegte Zwei-Stunden-Intervall einhält.

// Send Telegram notification
if (SendTelegramAlerts) // Check if sending alerts is enabled
    SendTelegramMessage(infoStr); // Send the constructed message

// Update last update time
lastUpdateTime = TimeCurrent();

• Der Name des aktuellen Paares

Ich habe auch eine Funktion hinzugefügt, die den Namen des aktuellen Paares neben den analysierten Metriken anzeigt, sodass es einfacher ist zu erkennen, welches Paar gerade analysiert wird.

// Create the output string, including pair name and last update time
      string pairName = Symbol(); // Get the current symbol name

Im Folgenden sehen Sie, wie die Informationen auf Telegram erscheinen werden:

Abb. 7. Das Ergebnis von dem Namen des Paares

Tests 

Vor dem Testen müssen einige Anpassungen in Ihrem MetaTrader 5 vorgenommen werden, um sicherzustellen, dass die Informationen reibungslos an Telegram weitergeleitet werden.

Webanfragen zulassen:

• Öffnen Sie MetaTrader 5 und navigieren Sie zu Extras > Optionen > Experten.

Abb. 8. Webanfragen einstellen

• Aktivieren Sie das Kontrollkästchen „WebRequest für die folgenden URLs erlauben:“ (engl. Allow WebRequest for listed URL) und fügen Sie https://api.telegram.org zur Liste hinzu. Diese Einstellung ermöglicht es dem EA, Anfragen an die API von Telegram zu senden.

Abb. 9. Einstellung der Web-Anfrage

Zu Testzwecken können Sie den Aktualisierungszeitpunkt auch auf eine niedrigere Frequenz einstellen. In diesem Fall werde ich sie von 2 Stunden auf 15 Sekunden reduzieren.

//+------------------------------------------------------------------+
//| Update metrics and display them                                  |
//+------------------------------------------------------------------+
void UpdateMetrics()
  {
// Check if 15 seconds have passed since the last update
   if(TimeCurrent() - lastUpdateTime >= 15)

Kompilieren Sie nun Ihren MQL5-Code im MetaEditor und fügen Sie den Expert Advisor oder das Skript zu einem Chart in MetaTrader 5 hinzu. Nach erfolgreicher Kompilierung ziehen Sie bitte Ihren Expert Advisor (EA) auf den Chart. Von dort aus sollten Sie in Ihrem Telegram Nachrichten über Updates erhalten, die vom EA gesendet werden. Unten habe ich die Testergebnisse aus meinem Telegram dargestellt.

Abb. 10. Telegram-Ergebnis

Das Chart unten zeigt auch, dass die Informationen auf dem MetaTrader 5 Chart die gleichen sind wie die Informationen zu Telegram.

Abb. 11. Test Ergebnisse

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass der Erfolg des Analytics Forecaster EA, wie die oben dargestellten Diagramme zeigen, in seinem ausgeklügelten Ansatz zur Marktanalyse und den zeitnahen Nachrichten durch die Telegram-Integration liegt. Durch die Verwendung verschiedener Handelsmetriken, wie z. B. Daten des Vortags, aktuelle Volumenvergleiche, Marktrichtung und Risikomanagementprinzipien, liefert der EA Händlern wertvolle Erkenntnisse. Die berechneten Unterstützungs- und Widerstandsniveaus in Kombination mit der automatischen Bestimmung der Losgröße ermöglichen fundiertere Handelsentscheidungen und stellen sicher, dass sowohl Anfänger als auch erfahrene Händler ihre Strategien an die Marktbedingungen anpassen und gleichzeitig ihr Risiko effektiv steuern können.

Darüber hinaus verbessert die nahtlose Integration mit Telegram die Interaktion mit den Nutzern, indem sie zeitnahe Updates liefert, die es den Händlern ermöglichen, schnell auf Marktveränderungen zu reagieren. Die Möglichkeit, wichtige Handelsinformationen auf einer mobilen Plattform zu erhalten, verbessert den Komfort bei der Überwachung von Handelsgeschäften erheblich und fördert gleichzeitig ein reaktionsschnelleres Handelsumfeld. Insgesamt zeigt der Analytics Forecaster EA bemerkenswerte Fähigkeiten bei der Automatisierung von Analyse und Risikomanagement und ermöglicht es Händlern so, ihre Performance in einem dynamischen Markt zu optimieren. Mit seinem Schwerpunkt auf Datengenauigkeit und nutzerfreundlichen Funktionen hebt sich dieser EA als leistungsstarkes Werkzeug im Arsenal des Händlers hervor und ebnet den Weg für zukünftige Fortschritte bei automatisierten Handelslösungen.

Datum	Name des Werkzeugs	Beschreibung	Version	Aktualisierungen	Hinweis
01/10/24	Chart Projector	Skript zur Überlagerung der Kursentwicklung des Vortages mit Geistereffekt.	1.0	Erste Veröffentlichung	Erstes Werkzeug in Lynnchris Tool Chest
18/11/24	Analytical Comment	Er liefert Informationen zum Vortag in Tabellenform und nimmt die zukünftige Marktentwicklung vorweg.	1.0	Erste Veröffentlichung	Zweites Werkzeug in Lynnchris Tool Chest
27/11/24	Analytics Master	Regelmäßige Aktualisierung der Marktmetriken alle zwei Stunden	1.01	Zweite Veröffentlichung	Drittes Werkzeug in Lynnchris Tool Chest
02/12/24	Analytics Forecaster	Regelmäßige Aktualisierung der Marktmetriken alle zwei Stunden mit Telegram-Integration	1.1	Dritte Auflage	Tool Nummer 5