Erstellen eines integrierten MQL5-Telegram Expert Advisors (Teil 1): Senden von Nachrichten von MQL5 an Telegram

Einführung

Dieser Artikel wird den Verlauf der Integration von Telegram mit MetaTrader 5 verfolgen. Wir beabsichtigen, dies zu erreichen, indem wir einen maßgeschneiderten Expert Advisor (EA) in der Programmiersprache MetaQuotes Language 5 (MQL5) entwickeln. Unsere Hauptaufgabe ist es, einen Handelsassistenten zu programmieren, der in Echtzeit arbeitet und uns über einen Chat auf Telegram auf dem Laufenden hält. Der Telegram-Bot, den wir bauen werden, wird wie ein Update-Server fungieren und uns pikante Informationshäppchen schicken, die uns helfen, wichtige Handelsentscheidungen zu treffen.

Um dieses Ziel zu erreichen, werden wir einen Telegram-Bot einrichten und unseren EA so anpassen, dass er mit der Application Programming Interface (API) von Telegram kommuniziert. Wir werden zunächst den BotFather einrichten, einen Telegram-Bot, der Ihnen hilft, neue Bots zu erstellen und Ihre bestehenden zu verwalten. Mit „BotFather“ erstellen wir einen neuen Bot und haben die Möglichkeit, ihm einen Namen zu geben. Außerdem erhalten wir eine wichtige Information, das Token, mit dem wir unseren Bot identifizieren und über die Anwendungsprogrammierschnittstelle (API) Zugang zu ihm erhalten können. Danach erhalten wir die Chat-ID und verwenden diese beiden Elemente, um die API zu erreichen und sie zum Laufen zu bringen.

Daher bieten wir in diesem Artikel eine umfassende Anleitung zur Programmierung. Wir zeigen Ihnen, wie Sie einen Expert Advisor schreiben und implementieren, der eine bidirektionale Verbindung zwischen MetaTrader 5 und Telegram herstellt. Wir erklären Ihnen nicht nur das „Wie“, sondern auch das „Warum“, damit Sie die technischen und praktischen Aspekte der Integration verstehen. Wir werden auch auf mögliche Fehler eingehen, die während der Einrichtung und des Betriebs auftreten können, vor allem, um sie zu vermeiden, aber auch, um sicherzustellen, dass Sie wissen, wie Sie damit umgehen können, wenn sie trotz unserer Bemühungen, sie vorherzusehen und zu vermeiden, auftreten.

Um den Inhalt leicht in kleinen Häppchen aufnehmen zu können, werden wir den Prozess in die folgenden Unterthemen aufteilen:

1. Einführung in MQL5 und Telegramm-Integration
2. Einrichten des Telegram-Bots
3. MetaTrader 5 für die Telegrammkommunikation konfigurieren
4. Implementation in MQL5
5. Testen der Integration
6. Schlussfolgerung

Am Ende dieses Artikels sollten Sie ein solides Verständnis dafür haben, wie Sie eine integrierte, automatisierte Kommunikation zwischen MetaTrader 5 und Telegram erreichen können, mit einem funktionierenden EA als Endprodukt.

Einführung in MQL5 und Telegramm-Integration

• Überblick über die Reihe und die Ziele:

Diese Artikelserie soll den Kreis zwischen Ihrem Handel auf der MetaTrader 5-Plattform und Ihrer Sofortkommunikation über die Telegram-Anwendung schließen. Am Ende der Serie werden Sie einen funktionierenden Expert Advisor (EA) in MQL5 haben, der Nachrichten senden und empfangen und sogar Bilder über Ihre Handelsplattform und Ihr Telegram-Konto weiterleiten kann. Jeder Teil der Serie baut auf dem letzten auf und schärft die Funktionalität des EA und das gesamte Handelssystem, das Sie verwenden können.

• Vorteile der Integration von Telegram mit MQL5:

Die Integration von Telegram in MQL5 hat mehrere Vorteile. Zunächst einmal bietet es die Möglichkeit, Sofortnachrichten zu versenden. Wenn Sie einen Expert Advisor für den Handel mit MQL5 eingerichtet haben, können Sie ihn so programmieren, dass er Ihnen Alarme über Telegram sendet. Das funktioniert sehr gut, weil Sie Ihren Handelsalgorithmus so konfigurieren können, dass Sie nur Benachrichtigungen über eine neue Handelsmöglichkeit oder eine wichtige Aktualisierung einer offenen Position erhalten. Der andere wichtige Weg, über den Sie mit Ihrem Handelsalgorithmus über Telegram kommunizieren können, ist die Verwendung eines Telegram-Bots. Bots bieten einige eindeutige Vorteile, wenn es darum geht, einen Dienst so zu programmieren, dass er Ihnen Warnungen sendet und/oder eine begrenzte, aber sichere Kommunikation von handelssensiblen Daten ermöglicht. Darüber hinaus können Sie alle Arten von handelsrelevanten Medien, wie Charts oder Screenshots, mit dem Bot teilen, damit Ihre Handelsalgorithmen Sie besser unterstützen können. Technisch gesehen, vermittelt der Bot die Kommunikation zwischen dem Nutzer und dem Server. Hier finden Sie eine detaillierte Visualisierung der chronologischen Prozesse:

• Relevanz im modernen Handel:

Die heutige Handelswelt verlangt von ihren Akteuren eine schnelle Anpassungsfähigkeit; sie ist eine Frage von Gewinn und Verlust. Wir Händler haben zwangsläufig nach Möglichkeiten gesucht, unsere Strategien zu automatisieren, um mit den Märkten in Kontakt zu bleiben, ohne an unseren Schreibtisch gebunden zu sein. Einer der neueren Ansätze, dies zu erreichen, beinhaltet die Verwendung von MQL5, einer leistungsstarken Programmiersprache, mit Telegram, einer Instant-Messaging-App, die fast wie ein maßgeschneidertes Handels-Dashboard funktionieren kann. Dieses Proxy Trading Telegramm-Setup deckt die notwendigen Grundlagen für die Aufnahme in jedes Telegramm ab, das dazu dient, den Nutzer über relevante Ereignisse für alle von ihm verwalteten Konten zu informieren. Unabhängig davon, ob Sie ein Team haben oder nicht, machen die Peer-to-Peer-Update-Funktionen von Telegram die App zu einem legitimen Kandidaten für die Aufnahme in das Toolkit eines Traders.

• Sie legen den Grundstein für die Serie:

Das Verständnis der wesentlichen Konzepte und grundlegenden Instrumente der Integration ist von größter Bedeutung. Wir beginnen mit den Grundlagen: Erstellen eines Telegram-Bots und Konfigurieren von MQL5 zum Senden von Nachrichten über diesen Bot. Dieser Schritt ist von grundlegender Bedeutung. Er ermöglicht es uns, eine Grundlage zu schaffen, auf der wir in Zukunft fortschrittlichere, anspruchsvollere und nützlichere Funktionalitäten aufbauen können. Am Ende von Teil 1 werden wir über ein einfaches, aber funktionierendes System verfügen, mit dem wir Textnachrichten von unserem EA an Telegram senden können. Diese Grundlage vermittelt Ihnen nicht nur praktische Fähigkeiten, sondern bereitet Sie auch auf komplexere Aufgaben vor, wie das Senden von Bildern und die Handhabung der bidirektionalen Kommunikation zwischen MQL5 und Telegram. Am Ende werden wir die Integration wie folgt haben:

Dies wird als Grundlage für die anderen Teile dienen.

Einrichten des Telegram-Bots

Der erste Schritt zur Verbindung von Telegram mit MetaTrader 5 ist die Erstellung eines Telegram-Bots. Dieser Bot dient als Vermittler für Nachrichten, die an Telegram und MetaTrader 5 gesendet und von dort empfangen werden. Mit dem BotFather erstellen wir einen neuen Bot, konfigurieren ihn mit den erforderlichen Berechtigungen und erhalten dann das API-Token, das die Kommunikation mit unserem Bot ermöglicht.

Um einen Bot zu erstellen, öffnen Sie zunächst die Telegram-App und suchen Sie nach „BotFather“. Dies ist ein spezieller Bot, mit dem Sie andere Bots erstellen und verwalten können. Da es viele von ihnen mit fast ähnlichen Namen geben könnte, sollten Sie darauf achten, dass Sie den Wortlaut wie abgebildet eingeben.

Wir starten einen Chat mit BotFather und verwenden den Befehl „/newbot“, um einen neuen Bot zu erstellen. BotFather fordert uns dann auf, einen Namen und einen Nutzernamen für Ihren Bot anzugeben. Danach erhalten wir ein eindeutiges API-Token. Das ist eine große Sache, denn es ermöglicht Ihrer Anwendung, sich bei den Telegram-Servern zu authentifizieren und mit ihnen auf eine Weise zu interagieren, von der die Server wissen, dass sie legitim ist. Zur Veranschaulichung des Prozesses haben wir ein Bild im Graphics Interchange Format (GIF) betrachtet, um sicherzustellen, dass Sie die richtigen Schritte nachvollziehen können.

Einrichten des Bots: Nachdem wir das API-Token erworben haben, müssen wir den Bot so einrichten, dass er unseren Anforderungen entspricht. Wir können ihn so programmieren, dass er Befehle erkennt und darauf reagiert, indem wir den Befehl „/setcommands“ von BotFather verwenden. Um den Bot zu öffnen, können Sie ihn entweder über seinen Namen suchen oder einfach auf den ersten Link klicken, der von „BotFather“ bereitgestellt wird (siehe unten):

Wir können dem Bot auch eine nutzerfreundlichere Oberfläche geben. Das Hinzufügen eines Profils, einer Beschreibung und eines Bildes macht es ein wenig einladender, aber das ist ein optionaler Schritt. Der nächste Schritt bei der Konfiguration des Bots besteht darin, sicherzustellen, dass er die eigentlichen Nachrichten entsprechend unseren Anforderungen verarbeiten kann.

Abrufen der Chat-ID: Um direkte Nachrichten von unserem Bot an einen bestimmten Chat oder eine Gruppe zu senden, müssen wir die Chat-ID erhalten. Wir können dies erreichen, indem wir unserem Bot eine Nachricht senden und dann die Telegram-API-Methode „getUpdates“ verwenden, um die Chat-ID abzurufen. Wir benötigen diese ID, wenn wir möchten, dass unser Bot Nachrichten an eine andere Stelle als an seinen Besitzer sendet. Wenn der Bot Nachrichten an eine Gruppe oder einen Kanal senden soll, können wir den Bot zuerst der Gruppe hinzufügen und dann die gleichen Methoden verwenden, um die Chat-ID zu erhalten. Um die Chat-ID zu erhalten, verwenden wir das folgende Codeschnipsel. Wir kopieren einfach das Bot-Token, ersetzen es durch das Token unseres Bots und führen es in unserem Browser aus.

//CHAT ID = https://api.telegram.org/bot{BOT TOKEN}/getUpdates
//https://api.telegram.org/bot7456439661:AAELUurPxI1jloZZl3Rt-zWHRDEvBk2venc/getUpdates

Das sind die Ergebnisse, die wir erhalten:

Sie können sehen, dass unser Ergebnis keine aktualisierte Nachricht enthält, auch wenn wir true zurückgeben, was darauf hindeutet, dass alle Angaben korrekt sind. Wenn wir etwas in den Link eingeben, das nicht korrekt ist, erhalten wir eine fehlerhafte Webanfrage und eine falsche Rückmeldung wie unten:

{"ok":false,"error_code":404,"description":"Not Found"}

In unserem Fall geben wir true zurück, und dennoch ist unsere Struktur leer. Das liegt daran, dass wir eine Nachricht an den Bot senden müssen, damit er eine Aktualisierung vornimmt. In unserem Fall senden wir einen Startbefehl „/start“.

Wenn wir die Nachricht abschicken und den Link erneut aktualisieren, erhalten wir nun die Aktualisierung. Hier ist es gut zu wissen, dass die Nachrichten nur 24 Stunden auf dem Telegrammserver gespeichert und danach verworfen werden. Wenn wir also die Chat-ID mit dieser Methode erhalten, müssen wir sicher stellen, dass die Nachrichten innerhalb von 24 Stunden vor dem Vorgang gesendet wurden. Hier ist, was wir haben:

Wir erhalten die Aktualisierungen, aber die Präsentationsstruktur ist ziemlich kompakt und unattraktiv. Um ein besser lesbares Format zu erhalten, aktivieren wir einfach das Kästchen „Pretty-Print“ und wir sollten die folgende Struktur erhalten.

{
  "ok": true,
  "result": [
    {
      "update_id": 794283176,
      "message": {
        "message_id": 1,
        "from": {
          "id": [YOUR ID],
          "is_bot": false,
          "first_name": "Forex Algo-Trader",
          "username": "Forex_Algo_Trader",
          "language_code": "en"
        },
        "chat": {
          "id": [YOUR ID],
          "first_name": "Forex Algo-Trader",
          "username": "Forex_Algo_Trader",
          "type": "private"
        },
        "date": 1722368989,
        "text": "/start",
        "entities": [
          {
            "offset": 0,
            "length": 6,
            "type": "bot_command"
          }
        ]
      }
    }
  ]
}

Unsere Chat-ID ist diejenige unter der Spalte „Chat-ID“. Bis zu diesem Punkt können wir, bewaffnet mit dem Bot-Token und der Chat-ID, ein Programm erstellen, das Nachrichten von MQL5 an den von uns erstellten Telegram-Bot sendet.

MetaTrader 5 für die Telegrammkommunikation konfigurieren

Um sicherzustellen, dass unsere MetaTrader 5 Plattform mit Telegram kommunizieren kann, müssen wir die Telegram API URL zur Liste der erlaubten URLs in MetaTrader 5 hinzufügen. Wir beginnen damit, MetaTrader 5 zu öffnen und zum Menü „Tools“ zu navigieren. Von dort aus wählen wir „Optionen“, die alternativ durch Drücken von „STRG + O“ geöffnet werden können.

Sobald sich das Fenster „Optionen“ öffnet, navigieren wir zur Registerkarte „Expert Advisors“. Hier aktivieren wir das Kästchen „WebRequest für aufgelistete URL zulassen“ und fügen die URL „https://api.telegram.org“ zur Liste hinzu. Dieser Schritt ist von entscheidender Bedeutung, da er unserem Expert Advisor die erforderlichen Berechtigungen zum Senden von HTTP-Anfragen an die Telegram-API erteilt, damit er Nachrichten und Updates an unseren Telegram-Bot senden kann. Durch die Konfiguration dieser Einstellungen stellen wir eine reibungslose und sichere Kommunikation zwischen unserer MetaTrader 5-Plattform und Telegram sicher, sodass unsere Handelsaktivitäten effektiv in Echtzeit überwacht und gesteuert werden können.

Nachdem wir all dies getan haben, sind wir bereit und wir können nun mit der Implementierung in MQL5 beginnen, wo wir die gesamte Logik definieren, die verwendet wird, um das Programm zu erstellen, das Nachrichten von MQL5 an Telegram weiterleitet. Legen wir los.

Implementation in MQL5

Die Integration wird auf einem Expert Advisor (EA) basieren. Um einen Expert Advisor zu erstellen, klicken wir auf Ihrem MetaTrader 5-Terminal auf die Registerkarte Tools und aktivieren MetaQuotes Language Editor, oder drücken F4 auf unserer Tastatur. Alternativ könnten wir auch auf das IDE-Symbol (Integrated Development Environment) in der Symbolleiste klicken. Dadurch wird die Umgebung des MetaQuotes-Editors geöffnet, die das Schreiben von Handelsrobotern, technischen Indikatoren, Skripten und Funktionsbibliotheken ermöglicht.

Sobald der MetaEditor geöffnet ist, navigieren wir in der Symbolleiste zur Registerkarte „Datei“ und wählen „Neue Datei“, oder drücken einfach die Tastenkombination STRG + N, um ein neues Dokument zu erstellen. Alternativ könnten wir auch auf das Symbol New auf der Registerkarte Werkzeuge klicken. Daraufhin erscheint ein Popup-Fenster des MQL-Assistenten.

In dem sich öffnenden Assistenten markieren wir die Option Expert Advisor (Vorlage bzw. template) und klicken auf Weiter (Next).

Wir geben in den allgemeinen Eigenschaften des Expert Advisors unter dem Abschnitt Name den Dateinamen Ihres Experten an. Nicht vergessen, den Backslash vor dem Namen des EA verwenden, um einen Ordner anzugeben oder zu erstellen, wenn er nicht existiert. Hier haben wir zum Beispiel standardmäßig „Experts\“. Das bedeutet, dass unser EA im Ordner Experts erstellt wird und wir ihn dort finden können. Die anderen Abschnitte sind recht einfach, aber wir können dem Link am Ende des Assistenten folgen, um zu erfahren, wie der Prozess genau abläuft.

Nachdem wir den gewünschten Namen des Expert Advisors eingegeben haben, klicken wir auf Weiter, dann auf Weiter und schließlich auf Fertig stellen. Nachdem wir all das getan haben, können wir unser Programm programmieren und erstellen.

Zunächst definieren wir einige Metadaten über den Expert Advisor (EA). Dazu gehören der Name des EA, die Copyright-Informationen und ein Link zur MetaQuotes-Website. Wir geben auch die Version des EA an, die auf „1.00“ eingestellt ist. 

//+------------------------------------------------------------------+
//|                                          TG NOTIFICATIONS EA.mq5 |
//|                                  Copyright 2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"

Beim Laden des Programms werden Informationen angezeigt, die dem unten gezeigten Bild entsprechen.

Als Nächstes definieren wir mehrere Konstanten, die in unserem Code verwendet werden. 

const string TG_API_URL = "https://api.telegram.org";
const string botTkn = "7456439661:AAELUurPxI1jloZZl3Rt-zWHRDEvBk2venc";
const string chatID = "{YOUR CHAT ID}";

Hier enthält die Konstante „TG_API_URL“ die Basis-URL für die Telegram-API, die für das Senden einer Anfrage im Hyper Text Transfer Protokoll (HTTP) an die Telegram-Server erforderlich ist. Die Konstante „botTkn“ enthält das eindeutige Token für unseren Telegram-Bot, das von BotFather bereitgestellt wird und für die Authentifizierung erforderlich ist. Die Konstante „chatID“ ist der eindeutige Bezeichner für den Telegram-Chat, an den wir Nachrichten senden wollen. Hier geben Sie Ihre Chat-ID ein, die wir mit der getUpdates-Methode der Telegram-API erhalten haben. Beachten Sie, dass wir konstante String-Variablen verwendet haben. Das Schlüsselwort const sorgt dafür, dass unsere Variablen nach der Definition intakt und unverändert bleiben. So müssen wir sie nicht noch einmal neu definieren und sie behalten ihre Initialisierungswerte im gesamten Code bei. Auf diese Weise sparen wir Zeit und Platz, da wir sie nicht jedes Mal neu eingeben müssen, wenn wir die Werte benötigen, sondern nur die erforderlichen Variablen aufrufen, und auch hier ist die Wahrscheinlichkeit, dass die Werte falsch eingegeben werden, deutlich geringer.

Unser Code wird sich hauptsächlich auf den Experteninitialisierungsabschnitt stützen, da wir schnelle Illustrationen erstellen wollen, ohne auf Ticks auf dem Chart warten zu müssen, damit wir Signale generieren können. OnInit wird also den größten Teil der Codestruktur enthalten.

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+

int OnInit(){

   ...
   
   return(INIT_SUCCEEDED);
}

Die Funktion OnInit ist eine Ereignisbehandlung, die bei der Initialisierungsinstanz des Experten aufgerufen wird, um gegebenenfalls notwendige Initialisierungen vorzunehmen. 

Für die Kommunikation mit dem Telegrammserver verwenden wir die MQL5-Funktion WebRequest. Die Funktion ist in der Regel überladen für den Datentyp Integer, mit zwei Formen.

Der Einfachheit halber werden wir die zweite Version verwenden. Lassen Sie uns die Funktion aufschlüsseln, damit wir verstehen, was jeder Parameter bedeutet.

int WebRequest(
   const string method,      // HTTP method (e.g., "GET", "POST")
   const string url,         // URL of the web server
   const string headers,     // Optional HTTP headers
   int timeout,              // Request timeout in milliseconds
   const char &data[],       // Data to send with the request
   char &result[],           // Buffer to store the response
   string &result_headers    // Buffer to store the response headers
);

Lassen Sie uns kurz die Parameter der Funktion WebRequest erklären.

• method: Die für die Anfrage zu verwendende HTTP-Methode. Gängige Methoden sind "GET" und "POST". "GET" wird normalerweise verwendet, um Daten von einem Server abzurufen. "POST" wird verwendet, um Daten an einen Server zu senden.
• url: Die URL des Webservers, an den die Anfrage gesendet wird. Dazu gehören das Protokoll (http:// oder https://), die Domäne und der Pfad/die Ressource, auf die zugegriffen wird.
• headers: Optionale HTTP-Header, die in die Anfrage aufzunehmen sind. Header können dem Server zusätzliche Informationen liefern (z. B. Inhaltstyp, Authentifizierungstoken).
• timeout: Die maximale Zeit (in Millisekunden), die auf eine Antwort des Servers gewartet wird. Wenn der Server nicht innerhalb dieser Zeit antwortet, wird die Anfrage abgebrochen und ein Fehlercode zurückgegeben. Wenn wir z. B. eine Zeitüberschreitung von 10000 Millisekunden einstellen, haben wir 10000/1000 = 10 Sekunden.
• data: Die mit der Anfrage zu sendenden Daten. Bei „POST“-Anfragen ist dies in der Regel der Hauptteil der Anfrage (z. B. Formulardaten, JSON-Nutzdaten).
• result: Der Puffer, in dem die Antwortdaten des Servers gespeichert werden. Dieses Array wird mit der Antwort des Servers gefüllt, die wir dann in unserem Code verarbeiten können.
• result_headers: Der Puffer zum Speichern der Antwort-Header des Servers. Diese Zeichenfolge wird mit den Kopfzeilen gefüllt, die der Server in seiner Antwort sendet.

Nachdem wir nun wissen, wofür die Parameter verwendet werden und warum wir sie brauchen, wollen wir nun einige der wichtigsten Variablen definieren, die wir verwenden werden.

   char data[];
   char res[];
   string resHeaders;
   string msg = "EA INITIALIZED ON CHART "+_Symbol;
   //https://api.telegram.org/bot{HTTP_API_TOKEN}/sendmessage?chat_id={CHAT_ID}&text={MESSAGE_TEXT}
   const string url = TG_API_URL+"/bot"+botTkn+"/sendmessage?chat_id="+chatID+
   "&text="+msg;

Zunächst deklarieren wir die Arrays „data“ und „res“ vom Typ char. Diese Arrays werden in der Funktion WebRequest verwendet, um die an den Webserver gesendeten bzw. vom Webserver empfangenen Daten zu speichern. Das Array „data“ ist für alle Nutzdaten gedacht, die wir mit unserer HTTP-Anfrage senden möchten, obwohl wir es vorerst leer lassen werden. Das Array „res“ wird mit der Antwort des Servers aufgefüllt, sodass wir die Antwort des Servers in unserem Programm verarbeiten und nutzen können.

Als Nächstes definieren wir eine String-Variable mit dem Namen „resHeaders“, um die Kopfzeilen der HTTP-Antwort zu speichern, die wir vom Server erhalten. HTTP-Antwort-Header liefern wichtige Metadaten über die Antwort, z. B. den Inhaltstyp, Serverinformationen und Statuscodes. Durch die Erfassung dieser Kopfzeilen können wir mehr Kontext über die Antwort erhalten und sie mit unserem Expert Advisor (EA) angemessen behandeln.

Dann erstellen wir eine String-Variable namens „msg“, die die Nachricht enthält, die wir an Telegram senden wollen. In diesem Fall lautet die Meldung „EA INITIALIZED ON CHART“, gefolgt von dem Symbol des aktuellen Charts, das durch die integrierte Variable _Symbol dargestellt wird. Die Variable _Symbol enthält den Symbolnamen des Finanzinstruments, für das der EA ausgeführt wird, z. B. „AUDUSD“ oder „GBPUSD“. Indem wir diese Informationen in unsere Nachricht aufnehmen, liefern wir einen klaren und spezifischen Kontext über die aufgetretene Aktion oder das aufgetretene Ereignis, was besonders für Überwachungs- und Protokollierungszwecke nützlich sein kann. Dies ist nur ein willkürlicher Wert, den wir bei der Initialisierung des Programms anzeigen wollen, und so können Sie Ihren eigenen haben.

Anschließend erstellen wir den Uniform Resource Locator (URL), der für eine Anfrage an die Telegram-API erforderlich ist. Wir beginnen mit der in der Konstante „TG_API_URL“ gespeicherten Basis-URL, die „https://api.telegram.org“ lautet. Dann hängen wir den Pfad an die API-Methode „sendMessage“ an, einschließlich des Tokens unseres Bots (botTkn). Dieses Token identifiziert unseren Bot eindeutig und authentifiziert ihn bei den Telegram-Servern, um sicherzustellen, dass die Anfrage gültig und autorisiert ist. Der URL-Pfad sieht wie folgt aus: „/bot<botTkn>/sendmessage“, wobei <botTkn> durch das tatsächliche Bot-Token ersetzt wird.

Als Nächstes fügen wir die Abfrageparameter an die URL an. Der erste Parameter ist „chat_id“, der den eindeutigen Bezeichner des Telegram-Chats angibt, an den wir unsere Nachricht senden wollen. Diese wird in der Konstante „chatID“ gespeichert. Der zweite Parameter ist text, der die eigentliche Nachricht enthält, die wir senden wollen und die in der Variablen „msg“ gespeichert ist. Diese Parameter werden an die Basis-URL angehängt, um die vollständige Anfrage-URL zu bilden. Die endgültige URL sieht so aus: "https://api.telegram.org/bot<botTkn>/sendmessage?chat_id=<chatID>&text=<msg>", wobei <botTkn>, <chatID> und <msg> durch ihre jeweiligen Werte ersetzt werden.

Schließlich rufen wir die Funktion auf, um die Kommunikation durchzuführen, indem wir die notwendigen Argumente übergeben.

   int send_res = WebRequest("POST",url,"",10000,data,res,resHeaders);

Hier verwenden wir die Funktion WebRequest, um eine HTTP-POST-Anfrage an die angegebene URL zu senden. Für die Kommunikation mit einem externen Webdienst, wie der Telegram-API, müssen wir diese Funktion verwenden. Wir müssen die HTTP-Methode angeben; in diesem Fall ist es „POST“. Wir verwenden diese Methode, wenn wir Daten an einen Server senden, der eine Aktion ausführt. Die Aktion, die dieser Server ausführen soll, ist das Senden einer Nachricht an einen Telegram-Chat. Wir geben die Variable „url“ an, die wir zuvor im Code erstellt haben. Die von uns verwendete URL enthält die Basisadresse der Telegram-API, unser eindeutiges Bot-Token, die sendMessage-Methode der API, die ID des Chats, an den wir die Nachricht senden wollen, und den Text der Nachricht selbst.

Dann geben wir an, dass der Parameter headers eine leere Zeichenkette ist, was bedeutet, dass diese Anfrage keine zusätzlichen HTTP-Header benötigt. Die Zeitüberschreitung wird mit 10 Sekunden angegeben, was in der Regel 10*1000 = 10000 Millisekunden entspricht, was in einer Welt, in der Server in der Regel innerhalb weniger Sekunden antworten sollten, ziemlich großzügig ist. Diese Zeitüberschreitung verhindert, dass die Anfrage auf unbestimmte Zeit hängen bleibt, und dient dazu, den EA ansprechbar zu halten. Als Nächstes übergeben wir das Daten-Array und das Antwort-Array an die Funktion. Das Array data enthält alle zusätzlichen Informationen, die wir mit der Anfrage senden wollen, und das Array response enthält das Ergebnis der Anfrage. Schließlich übergeben wir den Response-Header-String, den die Funktion auch zum „Speichern“ des vom Server gesendeten Response-Headers verwendet.

Die Funktion gibt einen ganzzahligen Statuscode zurück, der in der Variablen „send_res“ gespeichert ist und angibt, ob die Anfrage erfolgreich war oder ein Fehler aufgetreten ist. Anhand der Ergebnisse können wir überprüfen, ob die Nachricht erfolgreich gesendet wurde, und wenn nicht, den aufgetretenen Fehler mitteilen.

Nach der HTTP-Anforderung können wir die Antwort bearbeiten, indem wir den in der Variablen „send_res“ gespeicherten Statuscode überprüfen. Um dies zu erreichen, können wir bedingte Anweisungen verwenden, um das Ergebnis unserer Anfrage zu bestimmen und auf der Grundlage des zurückgegebenen Statuscodes geeignete Maßnahmen zu ergreifen.

   if (send_res == 200){
      Print("TELEGRAM MESSAGE SENT SUCCESSFULLY");
   }

Wenn unsere Variable hier den Statuscode 200 enthält, wissen wir, dass unsere Anfrage erfolgreich war. Dies kann als Zeichen dafür gewertet werden, dass unsere Nachricht den angegebenen Telegram-Chat erreicht hat. In diesem Fall geben wir also auf dem Terminal etwas aus wie „TELEGRAM MESSAGE SENT SUCCESSFULLY“.

   else if (send_res == -1){
      if (GetLastError()==4014){
         Print("PLEASE ADD THE ",TG_API_URL," TO THE TERMINAL");
      }
      Print("UNABLE TO SEND THE TELEGRAM MESSAGE");
   }

Wenn das Ergebnis nicht gleich 200 ist, wird als Nächstes geprüft, ob es gleich -1 ist. Dieser Status sagt uns, dass bei der HTTP-Anfrage etwas schief gelaufen ist - Fehler! Aber wir können den Endnutzer nicht einfach auf diesem Fehlerbildschirm stehen lassen. Um die Dinge für sie aussagekräftiger zu machen, können wir unsere Fehlermeldungen ein wenig detaillierter und raffinierter gestalten. Das ist genau das, was wir als Nächstes tun werden.

Zunächst prüfen wir den spezifischen Fehler (Meldung), den wir erhalten haben, als der Funktionsaufruf fehlschlug. Wir verwenden die Funktion GetLastError, um den Fehlercode abzurufen, der uns sagt, was falsch gelaufen ist. Dann interpretieren wir das wahrscheinliche Szenario (was der Fehlercode bedeutet) und geben dem Nutzer eine Meldung aus, die ihn bei der Behebung des Problems, das den Fehler verursacht hat, unterstützt. Wenn er in diesem Fall 4014 beträgt, wissen wir, dass die URL auf dem Terminal weder aufgeführt noch aktiviert ist. Daher informieren wir den Nutzer, dass er die korrekte URL auf seinem Handelsterminal hinzufügen und aktivieren muss. Wir werden dies testen und die Bedeutung des Ausrufs feststellen.

Wenn das Problem nicht mit der URL-Beschränkung zusammenhängt (GetLastError liefert nicht 4014), zucken wir nicht nur resigniert mit den Schultern. Wir drucken eine Nachricht an den Nutzer aus, in der die Art der Störung klar beschrieben wird: „DIE TELEGRAMMNACHRICHT KANN NICHT GESENDET WERDEN.“ Es ist schon schlimm genug, dass wir nicht mit unserem Bot kommunizieren können, aber dass ein Bot und wir beide auf dieser Seite des Bildschirms komplett stumm geschaltet sind, ist noch schlimmer als alles andere. Wir erfassen sogar die zufällige „anomale“ Antwortbedingung.

   else if (send_res != 200){
      Print("UNEXPECTED RESPONSE ",send_res," ERR CODE = ",GetLastError());
   }

Wenn „send_res“ nicht 200 entspricht (also nicht gut ist) und nicht -1 ist (was auf ein offensichtliches Problem im Zusammenhang mit einer URL-Beschränkung hindeutet), dann haben wir ein Rätsel. Wenn alles gut geht, geben wir den erfolgreichen Integer-Wert zurück.

   return(INIT_SUCCEEDED);

Lassen Sie uns dies testen und sehen, ob alles gut funktioniert.

Im Telegram-Bot-Chat bekommen wir Folgendes zu hören:

Auf dem Handelsterminal sieht das so aus:

Sie können sehen, dass wir in der Lage waren, eine Nachricht vom Handelsterminal an den Telegrammserver zu senden, der sie an den Telegram-Chat weitergeleitet hat, was bedeutet, dass es ein Erfolg war.

Der vollständige Quellcode, der für das Senden der Nachricht vom Handelsterminal an den Telegram-Chat über einen Bot verantwortlich ist, ist unten aufgeführt:

//+------------------------------------------------------------------+
//|                                          TG NOTIFICATIONS EA.mq5 |
//|                                  Copyright 2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, MetaQuotes Ltd."
#property link      "https://www.mql5.com"
#property version   "1.00"

// Define constants for Telegram API URL, bot token, and chat ID
const string TG_API_URL = "https://api.telegram.org";  // Base URL for Telegram API
const string botTkn = "7456439661:AAELUurPxI1jloZZl3Rt-zWHRDEvBk2venc";  // Telegram bot token
const string chatID = "{YOUR CHAT ID}";  // Chat ID for the Telegram chat

// The following URL can be used to get updates from the bot and retrieve the chat ID
// CHAT ID = https://api.telegram.org/bot{BOT TOKEN}/getUpdates
// https://api.telegram.org/bot7456439661:AAELUurPxI1jloZZl3Rt-zWHRDEvBk2venc/getUpdates

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit() {
   char data[];  // Array to hold data to be sent in the web request (empty in this case)
   char res[];  // Array to hold the response data from the web request
   string resHeaders;  // String to hold the response headers from the web request
   string msg = "EA INITIALIZED ON CHART " + _Symbol;  // Message to send, including the chart symbol

   // Construct the URL for the Telegram API request to send a message
   // Format: https://api.telegram.org/bot{HTTP_API_TOKEN}/sendmessage?chat_id={CHAT_ID}&text={MESSAGE_TEXT}
   const string url = TG_API_URL + "/bot" + botTkn + "/sendmessage?chat_id=" + chatID +
      "&text=" + msg;

   // Send the web request to the Telegram API
   int send_res = WebRequest("POST", url, "", 10000, data, res, resHeaders);

   // Check the response status of the web request
   if (send_res == 200) {
      // If the response status is 200 (OK), print a success message
      Print("TELEGRAM MESSAGE SENT SUCCESSFULLY");
   } else if (send_res == -1) {
      // If the response status is -1 (error), check the specific error code
      if (GetLastError() == 4014) {
         // If the error code is 4014, it means the Telegram API URL is not allowed in the terminal
         Print("PLEASE ADD THE ", TG_API_URL, " TO THE TERMINAL");
      }
      // Print a general error message if the request fails
      Print("UNABLE TO SEND THE TELEGRAM MESSAGE");
   } else if (send_res != 200) {
      // If the response status is not 200 or -1, print the unexpected response code and error code
      Print("UNEXPECTED RESPONSE ", send_res, " ERR CODE = ", GetLastError());
   }

   return(INIT_SUCCEEDED);  // Return initialization success status
}
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason) {
   // Code to execute when the expert is deinitialized
}
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick() {
   // Code to execute on every tick event
}
//+------------------------------------------------------------------+

Da dies ein Erfolg war, wollen wir im nächsten Unterthema den Code auf einige verschiedene Nachrichtenformate umstellen, um zu sehen, wie weit wir mit dem Senden von Nachrichten kommen, welche Fehler man machen kann und wie man sie entschärfen kann. Daher ist sie auch ebenso wichtig.

Testen der Integration

Um sicherzustellen, dass unser Expert Advisor (EA) korrekt Nachrichten an Telegram sendet, müssen wir die Integration gründlich testen. Ein wichtiger Aspekt beim Testen ist die Überprüfung des Verhaltens des EA, wenn bestimmte Einstellungen nicht korrekt sind, z. B. wenn das Kontrollkästchen „Allow WebRequest for listed URL“ im Handelsterminal deaktiviert ist. Um sicherzustellen, dass wir dies richtig machen, deaktivieren wir das Kontrollkästchen.

Wenn wir das Programm ausführen, erhalten wir eine Fehlermeldung, die den Nutzer darauf hinweist, dass die Kommunikation nur möglich ist, wenn der angegebene Link auf dem Handelsterminal enthalten und erlaubt ist.

Außerdem können wir sehen, dass wir nicht nur auf den Fehler hinweisen, sondern dem Nutzer auch eine praktikable Lösung zur Behebung der aufgetretenen Fehler anbieten.

Nachdem wir nun die Fehler erkannt und behoben haben, können wir die Nachrichtenformate kreativer, klarer und ausgefallener gestalten. Nehmen wir zunächst Emojis in unsere erste Nachricht auf.

   //--- Simple Notification with Emoji:
   string msg = "🚀 EA INITIALIZED ON CHART " + _Symbol + " 🚀";

Hier fügen wir einfach zwei Raketen-Emojis an die ursprüngliche Nachricht an. Nach dem Kompilieren ergibt sich folgendes Bild:

Sie können sehen, dass die einfache Nachricht mit dem Emoji erfolgreich gesendet wurde. Um die Emoji-Zeichen abzurufen, drücken Sie einfach die Tasten Windows + Punkt (.) gleichzeitig. Wir können jetzt noch kreativer werden und unsere Benachrichtigung so ändern, dass sie Handelssignale wie „KAUFEN“ oder „VERKAUFEN“, Informationen über den Kontostand, die Eröffnung von Handelsinstanzen, geänderte Handelsstufen wie Stop-Loss und Take-Profit, eine tägliche Leistungsübersicht und Informationen zur Aktualisierung des Kontostatus enthält. Dies sind nur willkürliche Meldungen, die an den eigenen Handelsstil angepasst werden können. Dies wird durch den folgenden Code erreicht.

   //--- Simple Notification with Emoji:
   string msg = "🚀 EA INITIALIZED ON CHART " + _Symbol + " 🚀";
   //--- Buy/Sell Signal with Emoji:
   string msg = "📈 BUY SIGNAL GENERATED ON " + _Symbol + " 📈";
   string msg = "📉 SELL SIGNAL GENERATED ON " + _Symbol + " 📉";
   //--- Account Balance Notification:
   double accountBalance = AccountInfoDouble(ACCOUNT_BALANCE);
   string msg = "💰 Account Balance: $" + DoubleToString(accountBalance, 2) + " 💰";
   //--- Trade Opened Notification:
   string orderType = "BUY";  // or "SELL"
   double lotSize = 0.1;  // Example lot size
   double price = 1.12345;  // Example price
   string msg = "🔔 " + orderType + " order opened on " + _Symbol + "; Lot size: " + DoubleToString(lotSize, 2) + "; Price: " + DoubleToString(price, 5) + " 🔔";
   //--- Stop Loss and Take Profit Update:
   double stopLoss = 1.12000;  // Example stop loss
   double takeProfit = 1.13000;  // Example take profit
   string msg = "🔄 Stop Loss and Take Profit Updated on " + _Symbol + "; Stop Loss: " + DoubleToString(stopLoss, 5) + "; Take Profit: " + DoubleToString(takeProfit, 5) + " 🔄";
   //--- Daily Performance Summary:
   double profitToday = 150.00;  // Example profit for the day
   string msg = "📅 Daily Performance Summary 📅; Symbol: " + _Symbol + "; Profit Today: $" + DoubleToString(profitToday, 2);
   //--- Trade Closed Notification:
   string orderType = "BUY";  // or "SELL"
   double profit = 50.00;  // Example profit
   string msg = "❌ " + orderType + " trade closed on " + _Symbol + "; Profit: $" + DoubleToString(profit, 2) + " ❌";
   //--- Account Status Update:
   double accountEquity = AccountInfoDouble(ACCOUNT_EQUITY);
   double accountFreeMargin = AccountInfoDouble(ACCOUNT_FREEMARGIN);
   string msg = "📊 Account Status 📊; Equity: $" + DoubleToString(accountEquity, 2) + "; Free Margin: $" + DoubleToString(accountFreeMargin, 2);

Wenn wir dieses Codeschnipsel mit den einzelnen Nachrichtenformaten ausführen, erhalten wir die folgende Summierung der Ergebnisse:

Anhand des obigen Codeschnipsels und des Bildes können Sie sehen, dass die Integration erfolgreich war. Damit haben wir unser Ziel erreicht, Nachrichten von Handelsterminals an den Telegram-Bot-Chat zu senden. Wenn Sie die Nachrichten an einen Telegram-Kanal oder eine Gruppe senden möchten, müssen Sie den Bot nur zu der Gruppe oder dem Kanal hinzufügen und ihn zum Administrator machen. Wir haben zum Beispiel eine Gruppe erstellt und sie „Forex Algo Trader Group“ genannt, in Anlehnung an unseren Namen und unser Logo, aber Sie können Ihrer Gruppe auch einen kreativeren und anderen Namen geben. Danach haben wir den Bot zu einem Administrator gemacht. 

Aber selbst wenn wir den Bot zu einem Administrator machen, müssen wir immer noch die Chat-ID für die Gruppe erhalten. Bleibt die Bot-Chat-ID bestehen, werden die Nachrichten immer an diese weitergeleitet und nicht an die gewünschte Gruppe. Der Prozess, um die ID der Gruppe zu erhalten, ist also ähnlich wie der ursprüngliche Prozess. 

// The following URL can be used to get updates from the bot and retrieve the chat ID
// CHAT ID = https://api.telegram.org/bot{BOT TOKEN}/getUpdates
https://api.telegram.org/bot7456439661:AAELUurPxI1jloZZl3Rt-zWHRDEvBk2venc/getUpdates

Wir müssen nur eine Nachricht an die Gruppe senden und den Code im Browser ausführen. Die Nachricht, die wir gesendet haben, lautet wie folgt:

Im Browser erhalten wir die folgenden Informationen in einem strukturierten Format:

{
  "ok": true,
  "result": [
    {
      "update_id": 794283177,
      "my_chat_member": {
        "chat": {
          "id": -4273023945,
          "title": "Forex Algo Trader Group",
          "type": "group",
          "all_members_are_administrators": true
        },
        "from": {
          "id": <YOUR ID>,
          "is_bot": false,
          "first_name": "Forex Algo-Trader",
          "username": "Forex_Algo_Trader",
          "language_code": "en"
        },
        "date": 1722593740,
        "old_chat_member": {
          "user": {
            "id": 
<YOUR ID> ,
            "is_bot": true,
            "first_name": "mql5tg_allan_bot",
            "username": "mql5_tg_allan_bot"
          },
          "status": "left"
        },
        "new_chat_member": {
          "user": {
            "id": <YOUR ID>,
            "is_bot": true,
            "first_name": "mql5tg_allan_bot",
            "username": "mql5_tg_allan_bot"
          },
          "status": "member"
        }
      }
    },
    {
      "update_id": 794283178,
      "message": {
        "message_id": 64,
        "from": {
          "id": 
<FROM ID> ,
          "is_bot": false,
          "first_name": "Forex Algo-Trader",
          "username": "Forex_Algo_Trader",
          "language_code": "en"
        },
        "chat": {
          "id": -4273023945,
          "title": "Forex Algo Trader Group",
          "type": "group",
          "all_members_are_administrators": true
        },
        "date": 1722593740,
        "new_chat_participant": {
          "id": 
<NEW ID> ,
          "is_bot": true,
          "first_name": "mql5tg_allan_bot",
          "username": "mql5_tg_allan_bot"
        },
        "new_chat_member": {
          "id": <NEW ID>,
          "is_bot": true,
          "first_name": "mql5tg_allan_bot",
          "username": "mql5_tg_allan_bot"
        },
        "new_chat_members": [
          {
            "id": 
<NEW ID> ,
            "is_bot": true,
            "first_name": "mql5tg_allan_bot",
            "username": "mql5_tg_allan_bot"
          }
        ]
      }
    },
    {
      "update_id": 794283179,
      "my_chat_member": {
        "chat": {
          "id": -4273023945,
          "title": "Forex Algo Trader Group",
          "type": "group",
          "all_members_are_administrators": true
        },
        "from": {
          "id": <FROM ID>,
          "is_bot": false,
          "first_name": "Forex Algo-Trader",
          "username": "Forex_Algo_Trader",
          "language_code": "en"
        },
        "date": 1722593975,
        "old_chat_member": {
          "user": {
            "id": <USER ID>,
            "is_bot": true,
            "first_name": "mql5tg_allan_bot",
            "username": "mql5_tg_allan_bot"
          },
          "status": "member"
        },
        "new_chat_member": {
          "user": {
            "id": <USER ID>,
            "is_bot": true,
            "first_name": "mql5tg_allan_bot",
            "username": "mql5_tg_allan_bot"
          },
          "status": "administrator",
          "can_be_edited": false,
          "can_manage_chat": true,
          "can_change_info": true,
          "can_delete_messages": true,
          "can_invite_users": true,
          "can_restrict_members": true,
          "can_pin_messages": true,
          "can_promote_members": false,
          "can_manage_video_chats": true,
          "can_post_stories": false,
          "can_edit_stories": false,
          "can_delete_stories": false,
          "is_anonymous": false,
          "can_manage_voice_chats": true
        }
      }
    },
    {
      "update_id": 794283180,
      "message": {
        "message_id": 65,
        "from": {
          "id": <YOUR FROM ID>,
          "is_bot": false,
          "first_name": "Forex Algo-Trader",
          "username": "Forex_Algo_Trader",
          "language_code": "en"
        },
        "chat": {
          "id": -4273023945,
          "title": "Forex Algo Trader Group",
          "type": "group",
          "all_members_are_administrators": true
        },
        "date": 1722594029,
        "text": "MESSAGE TO GET THE CHAT ID"
      }
    }
  ]
}

Hier hat unsere Chat-ID ein negatives Vorzeichen vor der Nummer. Dies ist die ID, die wir extrahieren und mit der ursprünglichen ID austauschen. Unsere Chat-ID lautet nun also wie folgt:

// Define constants for Telegram API URL, bot token, and chat ID
const string TG_API_URL = "https://api.telegram.org";  // Base URL for Telegram API
const string botTkn = "7456439661:AAELUurPxI1jloZZl3Rt-zWHRDEvBk2venc";  // Telegram bot token
const string chatID = "-4273023945";  // Chat ID for the Telegram chat

Wenn wir dies ausführen, erhalten wir das folgende Ergebnis.

Bis zu diesem Punkt konnten wir ein Programm in MQL5 zu erstellen, das korrekt Nachrichten vom Handelsterminal an das Bot-Chat-Feld von Telegram mit allen notwendigen Informationen sendet. Dies ist ein Erfolg für eine einfache Nachricht, aber für komplexe Nachrichten, die fremde Zeichen wie das Zeilenvorschubzeichen „\n“ oder Buchstaben aus Unicode-Zeichensätzen wie Emoji-Codes „U+1F600“ enthalten, werden nicht gesendet. Darauf werden wir in den folgenden Abschnitten eingehen. Lassen Sie uns erst einmal alles einfach und direkt auf den Punkt bringen. Prost!

Schlussfolgerung

In diesem Artikel haben wir einen Expert Advisor erstellt, der mit MQL5 und Telegram funktioniert. Dies ermöglicht die Kommunikation zwischen dem Endgerät und einem Telegram-Bot, d. h. wir können Nachrichten vom Endgerät an den Bot und vom Bot an das Endgerät senden. Das ist aus zwei Gründen sehr cool: Erstens, weil der Bot im Wesentlichen ein Proxy zwischen Ihnen und dem Terminal ist, um Nachrichten zu senden und zu empfangen, und zweitens, weil dieser Handelsaufbau aus irgendeinem Grund viel cooler erscheint als das Senden einer Nachricht per E-Mail.

Wir haben uns auch mit dem Testprozess befasst und die möglichen Fehler ermittelt, die auftreten können, wenn die Parameter von WebRequest nicht korrekt eingestellt sind. Wir haben die Gründe für diese Fehler herausgefunden und sie dann behoben, sodass das Programm jetzt mit einer höheren Zuverlässigkeit läuft. Das heißt, es funktioniert reibungslos und fehlerfrei und sendet Nachrichten mit den richtigen Informationen zur richtigen Zeit an den richtigen Ort. Dieses Verständnis für das „Warum“ und „Wie“ des Fehlers ermöglicht es uns, mit Zuversicht in die Zukunft zu blicken, da wir wissen, dass wir unserer „Grundzelle“ vertrauen können.

In den folgenden Teilen dieser Serie werden wir unsere Integration auf ein höheres Niveau heben, indem wir einen nutzerdefinierten Indikator konstruieren, der Handelssignale erzeugt. Diese Signale werden verwendet, um Nachrichten an unseren Gruppenchat in Telegram zu senden, sodass wir alle in Echtzeit über die Arten von potenziellen Handelsmöglichkeiten informiert werden, nach denen wir normalerweise Ausschau halten und sie nutzen. Dabei geht es nicht nur darum, dass unsere Handelsstrategie besser funktioniert. Es geht auch darum, zu zeigen, wie wir MQL5 mit Telegram kombinieren können, um einen dynamischen Handels-Workflow zu schaffen, der Warnungen sendet, ohne dass wir etwas anderes tun müssen, als auf unser Telefon zu schauen. Bleiben Sie dran, denn wir werden dieses integrierte System weiter ausbauen und verfeinern.