MetaTrader Tick-Info-Zugang von MQL5-Diensten zur Python-Anwendung über Sockets

Einführung

Manchmal ist nicht alles in der MQL5-Sprache programmierbar. Und selbst wenn es möglich wäre, bestehende fortgeschrittene Bibliotheken in MQL5 zu konvertieren, wäre dies sehr zeitaufwändig. Besser ist es, die vorhandenen Bibliotheken zu integrieren oder zu nutzen, um eine Aufgabe zu erfüllen. Zum Beispiel gibt es zahlreiche Bibliotheken für maschinelles Lernen in Python. Es ist nicht die beste Option für uns, identische Kopien in MQL5-Form zu erstellen, nur um eine maschinelle Lernaufgabe für den Handel zu erfüllen. Es ist besser, die für diese Python-Bibliothek für maschinelles Lernen benötigten Daten zu exportieren, die notwendigen Prozesse in der Python-Umgebung durchzuführen und das Ergebnis wieder in das MQL5-Programm zu importieren. In diesem Artikel geht es darum, solche Daten vom MetaTrader-Terminal in die Python-Umgebung zu transportieren.

Es gibt ein Python-Paket namens MetaTrader 5, das verwendet werden kann, um auf die Daten der MetaTrader-Charts zuzugreifen, wie z.B. Balkeninformationen, Tickinformationen, Nutzerinformationen, Handelsinformationen usw. Dieses Paket ist jedoch nur für Windows verfügbar, d. h., wenn Sie das Paket verwenden möchten, benötigen Sie ein Windows-Betriebssystem. In diesem Artikel zeige ich Ihnen, wie Sie mit Hilfe von Sockets auf die Tick-Daten von MetaTrader in einem Python-Programm zugreifen können.

Mit der Einführung von Berkeley-Sockets im Unix-Betriebssystem 4.2BSD im Jahr 1983 wurde die Kommunikation zwischen Maschinen einfach und weit verbreitet. Fortschrittlichere Bibliotheken und Protokolle der Anwendungsschicht hängen alle von Socket-Protokollen auf Transportebene ab, die wir in diesem Artikel verwenden werden.

Zu Demonstrationszwecken werde ich nur Tick-Daten (Geld-, Brief- und Tick-Zeitdaten) über Socket-Ports an die Python-Anwendung übertragen, die in der Python-Anwendung verwendet werden sollen. Mit der in diesem Artikel vorgestellten Idee können wir alle Arten von Chart-Daten exportieren, z. B. Balkeninformationen, Nutzerinformationen, Handelsinformationen usw. Und wir können nicht nur Dienste, sondern auch Skripte, Indikatoren oder Expert Advisors verwenden, um diese Aufgabe zu erfüllen.

Programmablauf

Dieser Artikel konzentriert sich auf die Nutzung des MetaTrader 5 Services-Programms, um Tick-Informationen wie Bid, Ask und Time an einen Python-Server zu senden, und der Python-Server sendet die Informationen an alle Client-Sockets, die mit dem Server verbunden sind. Dies wird in der folgenden Abbildung deutlicher.

Wie Sie in der Abbildung sehen können, ist das MetaTrader-Serviceprogramm mit einem Python-Server verbunden, der auf Port 9070 lauscht. Alle Tick-Daten der Charts, die im MetaTrader 5-Terminal geöffnet sind, werden an den Python-Server an Port 9070 gesendet. Der Python-Server analysiert dann die vom MetaTrader 5 empfangenen Daten, führt die notwendige Analyse der Daten durch und verteilt oder besser gesagt sendet die Tick-Informationen an die angeschlossenen Clients. Die Clients können dann die empfangenen Daten verwenden, um die erforderlichen Aufgaben auszuführen oder Algorithmen anzuwenden, um das gewünschte Ergebnis zu erzielen, das dann zur weiteren Verarbeitung an das MetaTrader-Dienstprogramm zurückgesendet werden kann.

Warum Dienstleistungen und Python?

Es gibt keinen besonderen Grund, MetaTrader 5-Dienste für die Übermittlung von Tick-Informationen zu wählen. Skripte, Indikatoren und Expert Advisor können auch verwendet werden, um solche Aufgaben zu erledigen und ich werde das in meinen nächsten Artikeln tun. Ich wollte nur zeigen, dass Tick- und andere chartbezogene Informationen mit Hilfe von MetaTrader-Diensten über Socket-Programmierung zu anderen Anwendungen transportiert werden können. Und anstelle von Python-Server und -Clients können wir auch andere Plattformen und Frameworks für die Entwicklung von Server und Clients verwenden. Python war für mich praktisch.

Programm Dienstleistungen

Wie wir alle wissen, haben die Dienste in MetaTrader 5 nur eine Funktion, OnStart, und alles muss innerhalb dieser Funktion erfolgen. Dienste sind nicht an Fenster gebunden und die eingebauten Funktionen wie _Symbol, _Period, _Point und andere sind in Diensten nicht zugänglich, während sie in Skripten, Indikatoren und Expert Advisors zugänglich sind. Und das Ausführen und Verwalten von Diensten kann nur über das Navigatorfenster erfolgen. Dienste können nicht zum Öffnen von Chart-Fenstern zur Ausführung gezogen werden. Wie Sie die Dienste ausführen können, sehen Sie im folgenden Abschnitt, in dem ich eine GIF-Datei eingefügt habe.

Das Diensteprogramm beginnt mit der Definition von Socket-, Server- und Port-Variablen.

int socket;
string server = "localhost";
int port = 9070;

Die Funktion SocketInit() erzeugt ein Socket-Handle mit der Methode SocketCreate(). Der Socket-Handle wird zusammen mit der Server-Adresse und dem Port an die Funktion SocketConnect() übergeben, um eine Verbindung zum Server herzustellen. Wenn die Verbindung erfolgreich ist, wird true zurückgegeben.

void SocketInit() {
   socket=SocketCreate();
   bool connect = SocketConnect(socket, server, port, 1000);
   if(connect) {
      Print("socket is connected", " ", server, " port ", port);
   }
}

Wenn wir das Dienstprogramm aus dem Navigator-Fenster im MetaTrader-Terminal hinzufügen und ausführen, wird die Funktion OnStart aufgerufen, in der wir die Funktion SocketInit() aufrufen.

void OnStart() {
   SocketInit();

Dann werden drei Variablen definiert, die erste zum Speichern der Tick-Informationen des geöffneten Chart-s, die zweite zum Speichern der Chart-ID und die dritte zum Speichern der Tick-Informationen, die an den Server gesendet werden sollen.

MqlTick latestTick;
long next;
string payload;

Da wir ständig Tick-Informationen an den Server senden müssen, wird eine while-Schleife mit true definiert und dann geprüft, ob der Server verbunden ist. Wenn die Socket-Verbindung nicht erfolgreich war, gibt SocketIsConnected(socket handle) false zurück und der Dienst wird gestoppt. 

while(true) {
   if(!SocketIsConnected(socket)){
      Print("socket is not initialized yet so stopping the service");
      break;
   }

Die Variablen next und payload werden mit der ersten Karten-ID und einem leeren String initialisiert.

next = ChartFirst();
payload = "";

Eine weitere while-Schleife zum Durchlaufen aller Chart-Fenster und zum Abrufen des Chart-Symbols wird als Nächstes ausgeführt.

while (next != -1) {
   string chartSymbol = ChartSymbol(next);

Aktuelle Tick-Informationen wie Geld- und Briefkurs und Uhrzeit für das Chart werden extrahiert. 

SymbolInfoTick(chartSymbol, latestTick);
double bid = latestTick.bid;
double ask = latestTick.ask;
string tickTime = TimeToString(latestTick.time, TIME_SECONDS);

Es wird ein Payload generiert, der an den Server gesendet wird und Symbol, Zeit, Geld- und Briefwerte enthält. Ich habe versucht, einen JSON-String-Wert für die Payload zu erstellen, sodass ich die JSON-Bibliothek in Python-Server verwenden können, um die JSON-Zeichenfolge in ein JSON-Objekt für die Datenextraktion zu dekodieren. Sie können jedes Format verwenden, das Ihnen zusagt.

bool stringAdded = StringAdd(payload, StringFormat("{\"pair\": \"%s\", \"time\": \"%s\", \"bid\": %f, \"ask\": %f}", chartSymbol, tickTime, bid, ask));

Wenn mehrere Chart-Fenster geöffnet sind, werden die Tick-Informationen des nächsten Chart-Fensters angehängt, indem #@# als Trennzeichen verwendet wird.

next = ChartNext(next);
if (next != -1 && stringAdded) {
   stringAdded = StringAdd(payload, "#@#");
}

Wenn alle geöffneten Chart-Fenster nach Tick-Daten gescannt sind und die Payload ausgefüllt sind, können sie an den Server gesendet werden. Die Methode SocketSend sendet die Daten an den Socket-Port, der als Socket-Handle definiert wurde. Vergewissern Sie sich, dass der Wert der Feldlänge korrekt ist, da sonst zusätzliche Zeichen mit den Daten gesendet werden, was eine zusätzliche Belastung für den Server beim Parsen der Daten bedeuten würde.

uchar data[];
int len = StringToCharArray(payload, data);
SocketSend(socket, data, len-1);

Und die Schleife wird vom ersten geöffneten Chart-Fenster an fortgesetzt, bis die Verbindung zum Server geöffnet ist.

Python-Server-Programm

Wie im Programmablauf beschrieben, sollte dieser Server auf den Empfang von Tick-Informationen vom MetaTrader-Terminal auf Port 9070 und auf das Senden der empfangenen Tick-Informationen an Clients auf Port 9071 warten. Es werden also zwei Socket-Verbindungen an diese Ports gebunden und an diesen Ports abgehört.

host = '127.0.0.1'
MT5_RECIEVING_PORT = 9070
CLIENT_SENDING_PORT = 9071
mt5Socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
mt5Socket.bind((host, MT5_RECIEVING_PORT))
mt5Socket.listen()
clientSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
clientSocket.bind((host, CLIENT_SENDING_PORT))
clientSocket.listen()

Ich habe den Server so programmiert, dass nur ein MetaTrader 5 eine Verbindung herstellen und kommunizieren kann. Dies geschieht, um Missmanagement und Chaos zu vermeiden, die bei mehreren MetaTrader 5-Verbindungen auftreten können. Auf der anderen Seite sollen die Clients die Tick-Daten zur weiteren Verarbeitung erhalten, wobei dieselben Daten von verschiedenen Clients für unterschiedliche Algorithmen verwendet werden können, um das gewünschte Ergebnis zu erzielen. Daher ist es notwendig, die Client-Verbindungen zu verwalten.

Die folgende Variable dict wird zum Speichern von live verbundenen Clients verwendet, um die verbundenen Clients auf der Serverseite zu verwalten.

connectedClients = {}

MetaTrader und Clients Flow werden als separate Threads gestartet, sodass sie unabhängig voneinander laufen können.

if __name__ == "__main__":

   thread = threading.Thread(target=acceptFromMt5)
   thread.start()
   thread = threading.Thread(target=acceptFromClients)
   thread.start()

Der MetaTrader 5-Thread wartet weiter, bis der MetaTrader-Dienst sich mit ihm verbindet. Sobald die Verbindung akzeptiert wurde, wird die Funktion processMt5Data aufgerufen, in der die Daten empfangen, verarbeitet und an die jeweiligen Clients gesendet werden. Dazu werde ich später mehr sagen.

Wenn ein Fehler bei der Annahme einer Verbindung vom MetaTrader-Dienst auftritt, wird auf die nächste Verbindung gewartet.

def acceptFromMt5():
   try:
       print("Server is listening for mt5")
       mt5Client, address = mt5Socket.accept()
       print(f"mt5 service is connected at {str(address)}")
       processMt5Data(mt5Client)

   except Exception as ex:
       print(f"error in accepting mt5 client {ex}")
       acceptFromMt5()

Bevor wir den Teil der Tick-Info-Analyse erörtern, ist es wichtig zu verstehen, wie die Clients verbunden und verwaltet werden. Wie beim MetaTrader 5-Service wartet der Server auf eine neue Client-Verbindung. Ein Client muss seine Identifikation senden, damit er auf dem Server verwaltet werden kann. Die Kennung ist das Symbolpaar des Chart-Fensters. Diese Kennung wird als Schlüssel für das Objekt dict verwendet, und der Client wird zu diesem Wörterbuch hinzugefügt. Eine while-Schleife wird verwendet, damit viele Clients eine Verbindung herstellen können.

def acceptFromClients():
   try:
       while True:

           print("Server is listening for clients")
           client, address = clientSocket.accept()
           pair = client.recv(7).decode("ascii")
           print(f"{pair} client service is connected at {str(address)}")
           clients = connectedClients[pair] if connectedClients and pair in connectedClients.keys() else []
           clients.append(client)
           connectedClients[pair] = clients

   except Exception as ex:
       print(f"error in accepting other clients {ex}")
       acceptFromClients()

Nachdem wir nun verstanden haben, wie neu angeschlossene Clients hinzugefügt werden, ist es einfach zu verstehen, wie die empfangenen Tick-Daten an diese Clients übertragen werden. Die Tick-Daten werden in ein JSON-Objekt umgewandelt und das Symbol wird daraus extrahiert. Die Tick-Informationen werden auf der Grundlage des Identifikationsschlüssels der Clients, der während der Verbindung an den Server gesendet wird, an die Clients weitergegeben. 

Die Tick-Daten werden mit demselben Trennzeichen aufgeteilt, das auch im Dienstprogramm MetaTrader 5 verwendet wird. Eine zusätzliche Aufteilung ist erforderlich, wenn mehrere Tick-Daten für ein Chart auf einmal gesendet werden. Die zweite Aufteilung wurde vorgenommen, da die Python-Bibliothek für JSON-Parsing nicht in der Lage war, die Tick-Informationen zu parsen, wenn mehrere Tick-Informationen auf einmal vom MetaTrader-Dienst an den Server gesendet werden.

def processMt5Data(mt5Client):
   data = "mt5 client connected"
   repeatativeEmpty = 0
   while(len(data) > 0):

       try:
          data = mt5Client.recv(1024000).decode("ascii")

           if len(data) > 0:
               for jsn in data.split("#@#"):

                   if "}{" in jsn:
                       splittedTickData = jsn.split("}{")
                       jsn = splittedTickData[0] + "}"

                   jsonTickData = json.loads(jsn)
                   pair = jsonTickData["pair"]

                   if pair in connectedClients.keys():
                       broadcastToClients(pair, jsonTickData)
           repeatativeEmpty = repeatativeEmpty + 1 if len(data) == 0 else 0

           if repeatativeEmpty > 10:
               print(f"data is not recieved for 10 times in a row {data}")
               break

       except Exception as ex:
           print(f"error in processing mt5 data {ex}")
           break

       time.sleep(0.1)
   acceptFromMt5()

Die Übermittlung von Daten an Clients ist einfach. Tritt beim Senden von Daten ein Fehler auf, so wird der Client aus der Liste der verbundenen Clients entfernt, wobei davon ausgegangen wird, dass der Client nicht verbunden ist, und das Wörterbuch wird aktualisiert.

def broadcastToClients(pair, message):
   for client in connectedClients[pair]:

       try:
           client.send(str(message).encode("ascii"))

       except Exception as ex:
           print(f"error while sending {message} to {client} for {pair}")
           client.close()
           clients = connectedClients[pair]
           clients.remove(client)
           connectedClients[pair] = clients

Und damit ist das Serverprogramm abgeschlossen.

Python-Client-Programm

Das Client-Programm verbindet sich mit dem Server über Port 9071, wie bereits im Programmablauf beschrieben. Wie bereits oben erwähnt, wird für die ordnungsgemäße Verwaltung der Clients auf dem Server ein Schlüssel benötigt, der das Symbol/Währungspaar repräsentiert. Daher benötigen wir Optionen, um die Liste der verfügbaren Schlüssel anzuzeigen, die aus der Liste für die Identifikations-ID, die an den Server gesendet werden soll, ausgewählt werden können.

CURRENCY_PAIRS = [

   "AUDUSD",
   "AUDJPY",
   "AUDCAD",
   "AUDNZD",
   "AUDCHF",
   "CADJPY",
   "CADCHF",
   "CHFJPY",
   "EURUSD",
   "EURJPY",
   "EURGBP",
   "EURCAD",
   "EURAUD",
   "EURNZD",
   "EURCHF",
   "GBPUSD",
   "GBPJPY",
   "GBPCAD",
   "GBPAUD",
   "GBPNZD",
   "GBPCHF",
   "NZDUSD",
   "NZDJPY",
   "NZDCAD",
   "USDCHF",
   "USDJPY",
   "USDCAD",
   "NZDCHF"
]
server = "127.0.0.1"
port = 9071

Wie Sie sehen, wird eine Option aus der obigen Liste ausgewählt und an den Server gesendet, sobald die Verbindung hergestellt ist, und dann wird gewartet, bis Daten vom Server eintreffen. 

if __name__ == "__main__":
   print(f"please choose from the currency pairs given below as name \n {', '.join(CURRENCY_PAIRS)}")
   name = input("enter the name for the client : ")

   if name in CURRENCY_PAIRS:
       client = socket.socket(socket.AF_INET, socket.SOCK_STREAM)

       if client.connect_ex((server, port)) == 0:
           client.send(name.encode("ascii"))
           receiveData(client)

       else:
           print("server could not be connected.")

   else:
       print("you didn't choose from the above list")

Das Client-Programm, das ich geschrieben habe, druckt nur die Tick-Daten aus, aber wir können alles damit machen, was wir wollen, z. B. die weitere Verarbeitung der Daten mit verfügbaren Frameworks und Bibliotheken, die Anwendung von Bibliotheken für maschinelles Lernen usw.

def receiveData(client):
   repeatativeEmpty = 0

   while True:
       data = client.recv(1024).decode("ascii")
       print("data received ", data)
       repeatativeEmpty = repeatativeEmpty + 1 if len(data) == 0 else 0

       if repeatativeEmpty > 10:
           print(f"data is not recieved for 10 times in a row {data}")

           break

Und damit ist das Client-Programm abgeschlossen.

Demo des Datenflusses

Für eine reibungslose Datenumwandlung muss der Server zuerst gestartet werden, da sonst keiner der Dienste laufen würde. Zu Testzwecken wird der Python-Server in einer virtuellen Umgebung ausgeführt, die in der folgenden Abbildung zu sehen ist.

Die Tick-Daten müssen vom Server empfangen und dann an die Clients übertragen werden. Die zweite Aufgabe besteht also darin, das Programm MetaTrader Services zu starten, wie im folgenden Screenshot zu sehen.

Wenn der MetaTrader-Dienst nicht ausgeführt wird, warten die verbundenen Clients auf den Empfang von Daten. Sobald ein Identifikationsschlüssel eines Clienten an den Server sendet und wenn Tick-Daten von den MetaTrader-Diensten gesendet werden, werden die Daten zunächst auf dem Kundenterminal ausgedruckt. Dies geschieht für EURUSD und GBPUSD, da beide Chart-Fenster im MetaTrader 5-Terminal zu diesem Zeitpunkt geöffnet sind. Dies ist auf den folgenden Screenshots zu sehen.

Ich habe versucht, den gesamten oben dargestellten Prozess in einem GIF zu erfassen, damit der gesamte Prozess besser erkennbar ist.

Schlussfolgerung

Dieser Artikel beschreibt die Verwendung von Socket-Programmierung, um Tick-Daten von MetaTrader 5 an eine Python-Anwendung zu senden, die MetaTrader-Dienste und Python Server und Client verwendet. Da wir wie in diesem Artikel Tick-Daten transportieren können, können wir auch andere Informationen über Charts transportieren. Ich habe einen Dienst genutzt, aber wir können auch Skripte, Indikatoren oder Expert Advisors verwenden. Und wie Python können wir auch andere Programmiersprachen verwenden.

Darüber hinaus wird in diesem Artikel auch versucht, die Abhängigkeit vom Windows-Betriebssystem zu beseitigen. MetaTrader und Python-Bibliotheken wie MetaTrader 5 hängen alle vom Windows-Betriebssystem ab. Anstatt die MetaTrader 5 Python-Bibliothek zu verwenden, können wir das Socket-Protokoll für die Datenübertragung von MetaTrader zu einer überzeugenderen Bibliothek für die einfache und erweiterte Verarbeitung von MetaTrader-Daten verwenden.

Dateiname	Beschreibung
TickSocketService.mq5	MQL-Datei, die Codes enthält, um eine Verbindung zum Socket-Server auf 9070 herzustellen und dann Tick-Daten zu senden
tick_server.py	Pythons Socket-Server öffnet Port 9070 für MetaTrader und Port 9071 für andere Clients
tick_client.py	Python-Client-Socket, der sich mit Port 9071 verbindet und vom Server gesendete Daten empfängt