Einführung in MQL5 (Teil 7): Anleitung für Anfänger zur Erstellung von Expert Advisors und zur Verwendung von AI-generiertem Code in MQL5
202
0
Einführung
Willkommen zurück auf unserer MQL5-Reise! Bereiten Sie sich darauf vor, in das faszinierende Reich der realen Beispiele einzutauchen, wenn wir Teil 7 unserer MQL5-Programmierserie beginnen. In diesem Kapitel werden wir von der Theorie zur Praxis übergehen, mit praktischen Übungen, die uns helfen, die Ideen, die wir in früheren Artikeln studiert haben, in die Praxis umzusetzen.
Das Verständnis der Bedeutung von Pseudocode wird ein wesentlicher Bestandteil unserer Untersuchung sein. Pseudocode dient als Bindeglied zwischen konkreten Codeimplementierungen und abstrakten algorithmischen Konzepten. Bevor wir mit dem Programmieren beginnen, können wir damit schnell und einfach unsere Ideen in einem für Menschen lesbaren Format skizzieren. In den nächsten Abschnitten werden wir uns mit der Leistungsfähigkeit von Pseudocode beschäftigen und damit, wie er hilft, algorithmische Strategien in praktikablen Code umzusetzen.
Die rasante Entwicklung der künstlichen Intelligenz in der heutigen Technologielandschaft hat Diskussionen über die Zukunft der Codierung ausgelöst. Einige argumentieren, dass der von der KI erzeugte Code die Notwendigkeit herkömmlicher Programmierkenntnisse ersetzen könnte. Aber nichts könnte weiter von der Realität entfernt sein als dies. Dieser Artikel soll mit diesem Mythos aufräumen und die Bedeutung von Programmierkenntnissen hervorheben. Wir werden Ihnen zeigen, wie Sie KI-generierten Code nahtlos in unsere Programmierprojekte einbinden können, sodass er unsere Fähigkeiten ergänzt und nicht ersetzt. Lassen Sie uns also loslegen und die MQL5-Programmierung ohne Verzögerung voll ausschöpfen. Bereiten Sie sich darauf vor, die Theorie auf reale Situationen anzuwenden, und lassen Sie uns etwas zaubern!
In diesem Artikel werden wir die folgenden Themen behandeln:
- MQL5 beherrschen
- Pseudocode
- Generierung von MQL5-Codes mit AI
Im letzten Artikel habe ich erwähnt, dass ich ein Video über Array-Funktionen einfügen würde. Dieses Video dient auch dazu, uns daran zu erinnern, wo wir aufgehört haben.
1. MQL5 beherrschen
Das Erlernen aller Einzelheiten von MQL5 auf einmal könnte überwältigend sein. Stattdessen kann die Konzentration auf Projekte den Lernprozess überschaubarer und angenehmer machen. Beginnen Sie mit der Beherrschung grundlegender Konzepte wie Variablen, Schleifen, Bedingungen, Funktionen und all den anderen grundlegenden Konzepten, die in früheren Artikeln besprochen wurden. Sobald Sie diese Grundlagen beherrschen, können Sie sich mit Projekten beschäftigen, die Sie interessieren, z. B. mit der Erstellung von Expert Advisors oder nutzerdefinierten Indikatoren. Jedes Projekt, an dem Sie arbeiten, wird Sie vor neue Schwierigkeiten stellen und Ihnen unbezahlbare Lektionen erteilen. Durch projektbasiertes Lernen können Sie Ihr theoretisches Wissen in realen Szenarien anwenden, was Ihnen hilft, die Komplexität von MQL5 besser zu verstehen. Sie werden nach und nach die Kenntnisse und Fähigkeiten erwerben, die erforderlich sind, um die Komplexität der MQL5-Programmierung zu bewältigen, während Sie an einer Vielzahl von Projekten arbeiten.
Wenn Sie diese Art des Lernens akzeptieren, können Sie sich als Programmierer stetig und selbstbewusst weiterentwickeln. Anstatt sich von der Weite von MQL5 eingeschüchtert zu fühlen, werden Sie es Projekt für Projekt angehen und Ihre Kenntnisse schrittweise verbessern. Akzeptieren Sie daher die projektbasierte Lernreise; sie ist der zuverlässigste Weg, MQL5 zu beherrschen. Ich habe mich in dieser Reihe für projektbasiertes Lernen entschieden, weil es so effektiv ist. Anstatt Sie kopfüber in die Komplexität von MQL5 zu stürzen, werden wir uns auf praktische Projekte konzentrieren, die es Ihnen ermöglichen, durch Erfahrung zu lernen. Die Arbeit an realen Projekten wird Ihnen helfen, das Thema besser zu verstehen und nützliche Fähigkeiten zu entwickeln, die Ihre Handelsstrategien verbessern werden.
Wir werden mit einfachen, anfängerfreundlichen Projekten beginnen und uns zu komplexeren Projekten vorarbeiten. Durch diesen methodischen Ansatz können Sie sicherstellen, dass Sie über ein solides Verständnis der MQL5-Programmierung verfügen, bevor Sie zu komplexeren Themen übergehen. Mit jedem Projekt lernen Sie neue Fähigkeiten und Ideen kennen, die Ihnen helfen, sich schrittweise zu verbessern. Das Projekt, an dem wir in diesem Artikel arbeiten werden, dient als praktisches Beispiel für das sequenzielle Verfahren zur Erstellung von Expert Advisors in MQL5. Wir werden uns auch mit der Optimierung der Vorteile von KI-generiertem Code im Kontext von MQL5 befassen.
Das anfängerfreundliche Projekt, an dem wir arbeiten werden, ist ein Wecker in MQL5. Das Besondere an diesem Projekt ist die Verwendung einer voraufgezeichneten Sprachnachricht anstelle des von MQL5 bereitgestellten Standardtöne. Sie lernen, wie Sie ein Alarmsystem einrichten, das es den Nutzern ermöglicht, Warnungen per Sprachnachricht einzustellen, und so Ihr Handelserlebnis noch persönlicher zu gestalten.
Der erste Schritt bei der Erstellung eines Expert Advisors (EA) in MQL5 besteht darin, alle notwendigen Komponenten aufzulisten, die der EA enthalten soll. Um zu gewährleisten, dass der EA mit einem präzisen Ziel und Plan vor Augen erstellt wird, ist diese Planungsphase unerlässlich. Damit der EA die Marktdaten analysieren und Handelsentscheidungen treffen kann, sollten Sie zunächst die Handelsstrategie festlegen, die er verwenden soll. Dazu gehört die Festlegung von Ein- und Ausstiegsregeln, Risikomanagementverfahren und anderen besonderen Anforderungen.
Beim Schreiben eines Expert Advisors (EA) ist es wichtig zu wissen, an welchem Typ von EA Sie arbeiten. Während sich einige EAs in erster Linie mit der Durchführung von Geschäften nach vorher festgelegten Strategien befassen, haben andere verschiedene Funktionen wie Risikomanagement, Datenüberwachung oder sogar das Versenden von Handelswarnungen, ohne tatsächlich Geschäfte zu tätigen. Wenn Sie wissen, welche Art von EA Sie aufbauen wollen, können Sie Ihre Bemühungen darauf ausrichten und einen EA entwerfen, der den beabsichtigten Zweck effektiv und effizient erfüllt. Am Ende dieses Artikels werden die Leser nicht nur einen funktionsfähigen EA haben, der in der Lage ist, Sprachwarnungen zu senden, sondern auch wertvolle Einblicke in den Prozess der EA-Entwicklung und das Potenzial von KI-gestützten Handelsstrategien erhalten.
2. Pseudocode
2.1. Was ist Pseudocode?
Mit Pseudocode können Sie definieren, was Sie tun wollen, bevor Sie mit der Programmierung beginnen. Sie können Ihre Ziele festlegen, bevor Sie mit der Codierung beginnen, indem Sie Pseudocode verwenden. Es ist ein Mittel, um Ihre Ziele für Ihr Programm in einfacher, verständlicher Sprache zu umreißen, ohne sich um die Syntax der Programmiersprache zu kümmern. Es erleichtert Ihnen später das Schreiben des eigentlichen Codes, indem es Ihnen hilft, die Schritte und die Logik zu organisieren, denen Ihr Programm folgen wird.
Analogie
Nehmen wir an, Sie möchten ein Computerprogramm verwenden, um zwei Zahlen zueinander zu addieren. Sie setzen sich hin und legen alle Schritte fest, die Sie unternehmen müssen, bevor Sie den eigentlichen Code schreiben. Die Art und Weise, wie wir planen, ist ähnlich wie bei Pseudocode! Es hilft Ihnen dabei, die Funktionalität Ihres Programms zu skizzieren, bevor Sie mit dem Schreiben von Code beginnen.
Wie Ihr Pseudocode aussehen wird:
Erster Schritt: Eingabe von Zahlen
- Bitten Sie den Nutzer um die Eingabe der ersten und zweiten Zahl.
Zweiter Schritt: Zahlen addieren und das Ergebnis drucken
- Addieren Sie die erste Zahl zur zweiten Zahl und drucken Sie das Ergebnis aus.
Jeder Schritt in diesem Pseudocode bezeichnet eine bestimmte Aktion, die Sie durchführen müssen, um die beiden Zahlen zu addieren. Es hilft dabei, den Prozess in kleinere, leichter zu bewältigende Aufgaben zu zerlegen, ähnlich wie beim Kochen nach einem Rezept. Wenn Sie Ihr Programm Schritt für Schritt schreiben, wird es einfacher, wenn es auf diese Weise geplant ist, ähnlich wie wenn Sie den Anweisungen folgen, um ein mathematisches Problem zu lösen.
Warum ist Pseudocode wichtig?
Selbst erfahrene Programmierer übersehen häufig den Pseudocode, obwohl er ein wesentlicher Bestandteil der Programmierung ist. Zwar es leicht ist, sich in den Nervenkitzel des Codeschreibens zu vertiefen und zu beobachten, wie Ihr Programm zum Leben erwacht, dennoch kann Planen und Skizzieren Ihrer Ideen in Pseudocode die Entwicklung erheblich beschleunigen. Wie viele Entwickler habe auch ich mich ohne großen Plan ins Programmieren gestürzt. Diese Methode kann jedoch zu Missverständnissen, Ineffektivität und Zeitverlust führen.
Meiner Erfahrung nach hat mir das Schreiben von Pseudocode, bevor ich mit der Programmierung beginne, viele Stunden Frustration und Fehlersuche erspart. Wenn man darauf bedacht ist, Ergebnisse zu erzielen, kann man die Bedeutung von Organisation und Planung leicht unterbewerten. Dennoch lässt sich nicht leugnen, dass die Verwendung von Pseudocode bei der Programmierung hilfreich sein kann, da sie Klarheit, Orientierung und Vertrauen schafft.
Darüber hinaus spielt Pseudocode eine wichtige Rolle bei der Erstellung von Expert Advisors (EAs) und macht die Verwendung von KI-generiertem Code in MQL5 einfacher zu verstehen. Bei der Arbeit mit komplexen Algorithmen und KI-gestützten Tools dient Pseudocode als Brücke zwischen abstrakten Konzepten und der praktischen Umsetzung. Es hilft Entwicklern dabei, Ideen auf hoher Ebene in umsetzbare Schritte zu übersetzen, wodurch der Prozess der Integration von KI-generiertem Code in MQL5-Programme einfacher und zugänglicher wird. Durch die Verwendung von Pseudocode zur Planung und Skizzierung der Logik Ihrer EAs können Sie sicherstellen, dass Ihr Code gut strukturiert, effizient und leicht zu pflegen ist.
Ein weiterer Vorteil des Verständnisses von Pseudocode ist seine Verwendbarkeit für freiberufliche Möglichkeiten innerhalb der MQL5-Gemeinschaft. Indem Sie Ihren Kunden Ihre Programmierpläne und -strategien mit Hilfe von Pseudocode effektiv vermitteln, können Sie Ihr Fachwissen unter Beweis stellen und Ihre Chancen erhöhen, Projekte für die Erstellung von Expert Advisors zu erhalten, die auf die spezifischen Bedürfnisse des Kunden zugeschnitten sind.
2.2. Wie man Pseudocode schreibt
Der erste Schritt beim Schreiben von Pseudocode besteht darin, die Ziele Ihres Programms in kleinere, besser durchführbare Aufgaben zu unterteilen. Erläutern Sie anschließend jeden Prozessschritt in einfachen, verständlichen Worten. Vermeiden Sie es, sich in der Syntax einer bestimmten Programmiersprache zu verzetteln, und konzentrieren Sie sich stattdessen auf die allgemeine Logik und den Ablauf Ihres Programms.
Werfen wir einen Blick auf den EA, an dem wir arbeiten werden. Wir werden zum Beispiel an einem Handelsalarm arbeiten, mit dem Sie sich zu bestimmten Zeiten erinnern lassen können. Das Besondere an diesem Projekt ist, dass Sie beim Einrichten der Erinnerung die Möglichkeit haben, den gewünschten Sound auszuwählen. Wir könnten den Pseudocode dafür folgendermaßen schreiben:
Der erste Schritt besteht darin, den EA zu initialisieren:
- Definieren und konfigurieren Sie die erforderlichen Variablen und Einstellungen, einschließlich:
Der zweite Schritt ist die Einrichtung von Erinnerungsfunktionen:
- Erlauben Sie den Nutzern die Eingabe der gewünschten Alarmzeiten und die Auswahl des Sounds, den sie für jede Erinnerung bevorzugen.
- Speichern Sie die Alarmzeiten und die ausgewählten Töne in den entsprechenden Variablen.
Der dritte Schritt ist die Überwachung der Zeitzone, in der gehandelt wird:
- Ständiger Vergleich der aktuellen Zeit mit den festgelegten Alarmzeiten.
- Lösen Sie den akustischen Alarm aus, wenn eine Alarmzeit erreicht ist.
Der vierte Schritt ist das Ertönen des akustischen Alarms:
- Benachrichtigung der Händler über die eingestellte Erinnerungszeit.
- Spielen der ausgewählten Audiodatei, um die Händler zu alarmieren.
Jeder Schritt in diesem Pseudocode steht für eine bestimmte Aufgabe oder Aktion, die der EA ausführt. Bevor wir mit der eigentlichen Programmierung beginnen, können wir die Logik und die Struktur unseres EA effizient planen, indem wir die Ziele des Programms in kleinere Schritte unterteilen und sie in einfachen Worten erklären.
3. Generierung von MQL5-Codes mit AI
Durch die künstliche Intelligenz (KI) haben sich die Codierungsverfahren erheblich weiterentwickelt. Der neue Ansatz verändert die Art und Weise, wie Entwickler Expert Advisors (EAs) erstellen, völlig. Die Automatisierung der Codegenerierung ist ein großer Vorteil der MQL5-Programmierung mit KI-gestützten Tools. Diese Tools verwenden fortschrittliche Algorithmen, um High-Level-Anweisungen und Pseudocode durch Analyse der Eingabedaten in ausführbaren MQL5-Code zu übersetzen. Künstliche Intelligenz verkürzt die Entwicklungszeiten und erhöht die Produktivität bei der Codegenerierung, indem sie sich wiederholende Aufgaben automatisiert und manuelle Eingriffe reduziert.
Aber selbst mit diesen Entwicklungen befindet sich die KI-Technologie noch in einem frühen Stadium und ist anfällig für Programmierfehler. Man muss sich darüber im Klaren sein, dass der von der KI erzeugte Code möglicherweise nicht fehlerfrei ist und korrigiert werden muss. Um KI-generierte Codes effektiv nutzen zu können, müssen die Entwickler daher immer noch über ein grundlegendes oder mittleres Verständnis von MQL5 verfügen. Dies garantiert die Korrektheit und Zuverlässigkeit des von der KI generierten Codes, indem es ihr ermöglicht, Fehler des Systems zu erkennen und zu beheben. Auch wenn die KI den Prozess der Codeerstellung beschleunigt, müssen die Entwickler immer noch informiert und wachsam sein, um die Qualität des Endprodukts zu gewährleisten.
3.1. Wie man genaue AI-Codes generiert
Hier ist die schrittweise Vorgehensweise:
3.1.1 EA-Pseudocode
Bevor Sie AI zur Generierung von MQL5-Code verwenden, erstellen Sie einen gründlichen Pseudocode. Unterteilen Sie die Ziele Ihres EA in kleinere, besser durchführbare Schritte und skizzieren Sie die Bedingungen und Maßnahmen für jeden Schritt.
Nach der Auswahl eines KI-gestützten Tools zur Generierung von MQL5-Code besteht der nächste Schritt darin, einen gründlichen Pseudocode zu erstellen, der die Logik und Funktionalität Ihres Expert Advisors (EA) beschreibt. In dieser Phase werden Sie bei jedem Schritt des Pseudocodes aufgefordert, Fragen zu stellen und sich mit den Besonderheiten der Funktionsweise Ihres EA zu befassen. Indem Sie den Pseudocode in umsetzbare Schritte aufteilen und die Fragen beantworten, die sich bei jedem Schritt stellen, können Sie sicherstellen, dass Ihr EA umfassend konzipiert ist und Ihre Handelsstrategie effektiv umsetzt.
Der erste Schritt besteht darin, den EA zu initialisieren:
- Definieren und konfigurieren Sie die erforderlichen Variablen und Einstellungen, einschließlich:
Dieser Schritt wirft Fragen wie diese auf:
- Welche Variablen sind notwendig, damit der EA funktioniert?
- Welche Datentypen sollen für die Variablen verwendet werden?
- Wie sollten die Standardwerte für Variablen festgelegt werden? Gibt es irgendwelche externen Abhängigkeiten oder Ressourcen, die geladen werden müssen?
Mit diesen Fragen können wir sicherstellen, dass der erste Schritt der EA-Initialisierung effektiv ausgeführt wird, wobei die erforderlichen Variablen und Einstellungen konfiguriert werden, und die aufgezeichnete Sprachnachricht ordnungsgemäß geladen und für die Wiedergabe während der vorgesehenen Handelssitzungen vorbereitet wird.
Der zweite Schritt ist die Einrichtung von Erinnerungsfunktionen:
- Erlauben Sie den Nutzern die Eingabe der gewünschten Alarmzeiten und die Auswahl des Sounds, den sie für jede Erinnerung bevorzugen.
- Speichern Sie die Alarmzeiten und die ausgewählten Töne in den entsprechenden Variablen.
Dieser Schritt wirft Fragen wie diese auf:
- In welchem Format sollen die Alarmzeiten angezeigt werden?
- Wie werden die Nutzer den Sound auswählen, den sie für die Erinnerung bevorzugen?
- Wo werden die ausgewählten Alarmzeiten und -töne gespeichert?
- Werden die Nutzer die Möglichkeit haben, bestehende Erinnerungen zu ändern oder zu löschen?
Der dritte Schritt ist die Überwachung der Zeitzone, in der gehandelt wird:
- Ständiger Vergleich der aktuellen Zeit mit den festgelegten Alarmzeiten.
- Lösen Sie den akustischen Alarm aus, wenn eine Alarmzeit erreicht ist.
Dieser Schritt wirft Fragen wie diese auf:
- Wie vergleicht der EA kontinuierlich die aktuelle Zeit mit den festgelegten Alarmzeiten?
- Welche Maßnahmen werden ergriffen, wenn eine Alarmzeit erreicht wird?
- Wie oft wird der EA die Alarmzeiten überprüfen?
Der zweite Schritt ist die Einrichtung von Erinnerungsfunktionen:
- Der vierte Schritt ist das Ertönen des akustischen Alarms:
- Benachrichtigung der Händler über die eingestellte Erinnerungszeit.
- Spielen der ausgewählten Audiodatei, um die Händler zu alarmieren.
Dieser Schritt wirft Fragen wie diese auf:
- Wie fügen wir die aufgezeichnete Sprachnachricht zu unserem MQL5-Projekt hinzu?
- Wie wird die ausgewählte Audiodatei abgespielt, um die Händler zu warnen?
Diese Art von Fragen ist für die Entwicklung von KI-Code unerlässlich. Indem wir sorgfältig auf sie eingehen, erstellen wir eine präzise Roadmap für die KI-gestützte Codegenerierung. Dieses Verfahren stellt sicher, dass der endgültige Code die Komplexität unseres Projekts genau erfasst und die Tür für die reibungslose Einbindung der KI-Technologie in die Erstellung unserer Expert Advisors (EAs) öffnet.
3.1.2. Code-Erstellung
Erzeugen Sie auf der Grundlage der vorgegebenen Aktionen und Bedingungen Schritt für Schritt MQL5-Code, indem Sie einige der aus dem Pseudocode abgeleiteten Fragen als Anleitung verwenden. Verwenden Sie das gewählte KI-gestützte Tool, um jedes Pseudocode-Segment zu entschlüsseln, auf das Sie keine Antworten haben, und wandeln Sie es in ausführbaren MQL5-Code um. Stellen Sie sicher, dass der generierte Code die beabsichtigte Logik und Funktionalität angemessen widerspiegelt, indem Sie sich auf die einzelnen Schritte konzentrieren.
Es ist wichtig zu verstehen, dass der Code, den die KI generiert, nicht die endgültige Version sein wird, die wir verwenden. Vielmehr dienen sie als lehrreiche Modelle, die Ihnen als Anfänger zeigen, wie Sie bestimmte Ziele bei der Erstellung Ihres Expert Advisors (EA) erreichen können.
Als Anfänger können Sie damit beginnen, einige Antworten auf diese Fragen zu finden, und auf diese Weise die nächsten Schritte, die Sie bei Ihrem Projekt unternehmen sollten, besser verstehen. Es ist wichtig zu verstehen, dass es dabei auch mehr darum geht, die KI mit den Besonderheiten Ihres Projekts vertraut zu machen, als ihr lediglich Fragen zu stellen und eine Antwort zu erwarten. Sie können das Verständnis der KI für Ihr Projekt aktiv verbessern, indem Sie mit ihr interagieren und relevante Fragen stellen. Dieser Austausch trägt dazu bei, die Genauigkeit des Codes zu verbessern, den er schließlich für Sie produziert. Je mehr Sie mit der KI kommunizieren und ihr Hintergrundinformationen über Ihr Projekt geben, desto besser ist sie in der Lage, Sie bei Ihren Programmieraufgaben erfolgreich zu unterstützen.
Anmerkung: Bevor Sie einer KI Fragen zu Ihrem Projekt stellen, ist es wichtig, dass Sie Ihr Projekt ausführlich erläutern. Diese Einführung dient als Grundlage für die KI, um den Kontext und die Ziele des Projekts zu verstehen.
Um zu demonstrieren, wie man Code aus der KI generiert, beginnen wir mit dem ersten Schritt anhand einer der Fragen:
Welche Variablen sind notwendig, damit der EA funktioniert?
Die Antwort von AI:
Für das Projekt Handelsalarm sind mehrere Variablen erforderlich, damit der EA effektiv funktioniert. Dazu können gehören:
- Die Variablen der Alarmzeiten: Variablen zum Speichern der nutzerdefinierten Alarmzeiten. Dabei kann es sich um Datumsvariablen handeln, die bestimmte Zeitpunkte während des Handelstages angeben, an denen die Erinnerungen ausgelöst werden sollen.
- Die Variablen zur Audiodateiauswahl: Die Variablen zum Speichern des vom Nutzer gewählten Sounds für jeden Alarm. Dies könnte eine String-Variable sein, die den Dateipfad oder den Namen der ausgewählten Audiodatei enthält.
- Aktuelle Zeitvariable: Eine Variable, die die aktuelle Zeit enthält, die kontinuierlich mit den Alarmzeiten verglichen wird, um die Erinnerungen auszulösen.
- Die Variable für den Pfad der Audiodateien: Variablen zum Speichern der Dateipfade der verfügbaren Audiodateien, aus denen der Nutzer wählen kann.
- Die Variable für die Benachrichtigungen: Eine Variable zum Speichern von Benachrichtigungen, die die Alarme begleiten können.
- Andere Konfigurationsvariablen: Je nach den spezifischen Anforderungen des Projekts können zusätzliche Variablen erforderlich sein, z. B. Variablen zur Steuerung des Verhaltens des EA oder zur Speicherung von Nutzerpräferenzen
Mit diesen theoretischen Antworten in der Hand ist es offensichtlich, dass die Antworten der KI nicht immer perfekt sein könnten. Indem wir jedoch im Vorfeld eine ausführliche Erläuterung des Projekts gegeben haben, haben wir die KI in die Lage versetzt, umfassendere Antworten zu geben. Dieser detaillierte Überblick hilft der KI, den Kontext der Fragen zu verstehen und aufschlussreiche Antworten zu geben. Dieser Ansatz verbessert die Qualität der KI-Antworten und fördert eine fruchtbare Interaktion zwischen den Projektanforderungen und den Fähigkeiten der KI.
Für eine noch deutlichere Erklärung können Sie die KI jetzt bitten, ein Codebeispiel einzufügen. Diese Ergänzung veranschaulicht, wie die theoretischen Konzepte in die tatsächliche Code-Implementierung umgesetzt werden, und bietet eine praktische Demonstration der Funktionalität des Projekts.
Die Antwort von AI:
// Define variables for alarm times datetime Alarm1; datetime Alarm2; datetime Alarm3; // Define variables for sound selection string Sound1 = "alert1.wav"; string Sound2 = "alert2.wav"; string Sound3 = "alert3.wav"; // Define variables for current time and notification message datetime CurrentTime; string NotificationMessage; // Define other configuration variables int NumberOfAlarms = 3;
In diesem Beispiel:
- Alarm1, Alarm2 und Alarm3 sind Datetime-Variablen zur Speicherung der nutzerdefinierten Alarmzeiten.
- Sound1, Sound2 und Sound3 sind String-Variablen, die die Dateipfade oder Namen der ausgewählten Audiodateien für jeden Alarm enthalten.
- NotificationMessage ist eine String-Variable zur Speicherung von Benachrichtigungen.
- NumberOfAlarms ist eine ganzzahlige Variable, die die Gesamtzahl der Alarme angibt, die der Nutzer einstellen kann.
Die Erklärung für die KI bietet zwar einige Antworten, aber sie sind nicht perfekt. Aus dieser Antwort können Sie jedoch einige Fragen extrahieren und die KI bitten, diese nach Ihren Vorgaben zu verfeinern.
Der von der KI bereitgestellte Code hilft bei der Ermittlung der für das Projekt erforderlichen Variablen. Für unser spezielles Projekt möchten wir jedoch, dass der Nutzer die Parameter für den Sound und den Alarm eingibt. Dies wirft eine Reihe von Fragen im Zusammenhang mit Schritt zwei des Pseudocodes auf:
- Wie können die Nutzer den Sound und die Zeit auswählen, die sie für die Erinnerung bevorzugen?
- Wo werden die ausgewählten Alarmzeiten und -töne gespeichert?
Diese Fragen verdeutlichen die Notwendigkeit, eine Nutzereingabefunktion in den EA zu implementieren. Die Nutzer sollten die Möglichkeit haben, den von ihnen bevorzugten Sound für jede Erinnerung auszuwählen und die entsprechenden Alarmzeiten festzulegen. Die ausgewählten Alarmzeiten und -töne müssen in Variablen innerhalb des EA gespeichert werden, damit sie bei Bedarf abgerufen und verwendet werden können. Dadurch wird sichergestellt, dass der EA nach den Präferenzen des Nutzers arbeitet und zu den festgelegten Zeiten tatsächlich Alarme mit den angegebenen Tönen auslöst.
Die Antwort von AI:
Um den Nutzern die Möglichkeit zu geben, den von ihnen bevorzugten Sound für jede Erinnerung auszuwählen, können Sie eine Variable mit dem Schlüsselwort input definieren, wobei Sie den Typ als string angeben. In dieser Variablen wird der Dateiname der vom Nutzer ausgewählten Audiodatei gespeichert. So können Sie den Code ändern:
input string Alarm1 = "00:00:00"; input string Alarm2 = "00:00:00"; input string Alarm3 = "00:00:00"; input string Sound = ""; // User-selected sound filename
Bei dieser Einstellung können die Nutzer den Namen der Audiodatei eingeben, den sie für die Erinnerungen verwenden möchten. Sie können dann diese Sound-Variable verwenden, um den ausgewählten Sound abzuspielen, wenn die Erinnerung ausgelöst wird.
Dies zeigt, wie wichtig es ist, dem Pseudocode Schritt für Schritt zu folgen. Zunächst legen wir fest, welche Variablen wichtig sind, damit der EA wie vorgesehen funktioniert. Diese Variablen bilden die Grundlage für das Projekt. Die Komponente der Nutzerinteraktion wird dann im zweiten Schritt angegangen, wo die Nutzer die Möglichkeit haben, ihre bevorzugten Audiodateien und gewünschten Alarmzeiten einzugeben. Dieses methodische Vorgehen garantiert, dass jeder Aspekt des Projekts methodisch behandelt wird, was zu einem besseren Verständnis führt. Die Interaktion mit der KI trägt dazu bei, die Projektanforderungen zu verfeinern und zu klären, was zu einer robusteren Implementierung führt, auch wenn der in dieser Phase bereitgestellte Code möglicherweise nicht die endgültige Version ist.
Wir gehen nun zum dritten Schritt über, der darin besteht, die Zeitzone des Handels im Auge zu behalten, indem wir dem Ablauf des Pseudocodes folgen. Das bringt uns zum Nachdenken über die folgenden Fragen:
- Wie wird der EA die Zeitdifferenz zwischen den eingestellten Alarmzeiten und der aktuellen Zeit verfolgen?
- Was geschieht, wenn eine Alarmzeit erreicht wird?
Durch die Beantwortung dieser Fragen wird der Entwicklungsprozess gelenkt, und der EA ist in der Lage, die festgelegten Alarmzeiten zu überwachen und bei Bedarf die entsprechenden Maßnahmen zu ergreifen.
Die Antwort von AI:
Um die aktuelle Zeit kontinuierlich mit den festgelegten Alarmzeiten zu vergleichen, können wir eine Schleife verwenden, die bei jedem Tick der Handelsplattform läuft. In dieser Schleife wird geprüft, ob die aktuelle Zeit mit einer der vom Nutzer eingestellten Alarmzeiten übereinstimmt.
// Inside the OnTick() function // Get the current time datetime currentTime = TimeLocal(); // Check if the current time matches any of the alarm times if(currentTime == StringToTime(Alarm1) || currentTime == StringToTime(Alarm2) || currentTime == StringToTime(Alarm3)) { // Trigger the audio alert PlaySound(Sound); }
In diesem Codeschnipsel:
- Wir erhalten die aktuelle Zeit mit TimeLocal().
- Wir vergleichen die aktuelle Zeit mit jeder der vom Nutzer angegebenen Alarmzeiten mit StringToTime().
- Wenn die aktuelle Zeit mit einer der Alarmzeiten übereinstimmt, lösen wir den akustischen Alarm aus, indem wir den ausgewählten Sound mit PlaySound(Audiodatei) abspielen.
Die Antworten der KI werden immer präziser, je weiter wir die im Pseudocode beschriebenen Phasen durchlaufen. Dies zeigt, wie wichtig es ist, das Projekt methodisch in machbare Phasen zu unterteilen. Die Erklärungen der KI passen mit jedem Schritt besser zu unseren Projektzielen. Sie hilft uns, besser zu verstehen, wie wir die schwierigeren Aspekte des Projekts angehen können und wie wir den Entwicklungsprozess selbst angehen können.
Der iterative Umgang mit der KI hat sich als sehr nützlich erwiesen. Sie unterstützt uns nicht nur bei der Durchführung des Projekts, sondern erweitert auch unser Verständnis dafür, wie wir mit den Feinheiten des Projekts umgehen können. Durch die Interaktion mit der KI erhalten wir einen besseren Einblick in die verschiedenen Aspekte des Projekts.
Wenn wir zum vierten Schritt des Pseudocodes übergehen, tauchen neue Fragen auf, die berücksichtigt werden müssen:
- Wie fügen wir die aufgezeichnete Sprachnachricht zu unserem MQL5-Projekt hinzu?
- Wie wird die ausgewählte Audiodatei abgespielt, um die Händler zu warnen?
Um diese Fragen zu beantworten, müssen wir Audiodateien in unser MQL5-Projekt integrieren und die Logik implementieren, um die Wiedergabe der ausgewählten Audiodatei zu den festgelegten Alarmzeiten auszulösen. Lassen Sie uns diese Aspekte näher untersuchen, um sicherzustellen, dass unser Wecker wie vorgesehen funktioniert.
Die Antwort von AI:
Um eine Sprachnachricht zu Ihrem MQL5-Projekt hinzuzufügen, gehen Sie wie folgt vor:
- Bereiten Sie eine aufgezeichnete Sprachnachricht in einem kompatiblen Format (z. B. WAV) vor.
- Im Installationsverzeichnis von MetaTrader 5 finden Sie einen Ordner mit dem Namen „Sounds“. Öffnen Sie diesen Ordner.
- Kopieren Sie Ihre Audiodatei (im WAV-Format) in den Ordner „Sounds“ Wenn Ihre Audiodatei in einem anderen Format vorliegt (z. B. MP3), müssen Sie sie in das WAV-Format konvertieren, bevor Sie sie in den Ordner „Sounds“ kopieren.
- Sobald Sie die Audiodatei in den Ordner „Sounds“ kopiert haben, sollte sie für die Verwendung in MetaTrader 5 verfügbar sein. Sie können die Audiodatei über ihren Dateinamen referenzieren, wenn Sie Funktionen wie PlaySound() in Ihrem MQL5-Code verwenden.
- Starten Sie die Wiedergabe der Sprachnachricht mit der Funktion PlaySound().
- Wenn Sie zum Beispiel eine Audiodatei mit dem Namen „alert.wav“ in den Ordner „Sounds“ kopiert haben, können Sie diese Audiodatei in Ihrem MQL5-Code wie folgt abspielen:
PlaySound("alert.wav");
Ersetzen Sie „alert.wav“ durch den Dateinamen Ihrer Audiodatei. Stellen Sie sicher, dass der Dateiname exakt übereinstimmt (einschließlich Großschreibung), um Fehler zu vermeiden, wenn Sie in Ihrem MQL5-Code auf die Audiodatei verweisen.
Das war's! Ihre Audiodatei sollte nun erfolgreich zu MetaTrader 5 hinzugefügt worden sein und für die Verwendung in Ihren Expert Advisors oder Skripten bereitstehen.
Alle von der AI erarbeiteten Antworten zeigen Wege auf, wie die vom Projekt aufgeworfenen Fragen angegangen werden können. Anstatt von der KI zu erwarten, dass sie die ganze Arbeit erledigt, was in der Regel nicht stimmt, ist dieser methodische Ansatz der beste Weg, um mit KI in unseren Projekten zu arbeiten. Es ist wichtig zu erkennen, dass künstliche Intelligenz (KI) nicht dazu da ist, den Menschen zu ersetzen. Vielmehr kann sie helfen und Erkenntnisse liefern, die das menschliche Fachwissen und die Kreativität verbessern und die Arbeit erleichtern. Auf diese Weise können Sie KI nutzen, um mit ihnen zusammenzuarbeiten und ihre Produktivität und Problemlösungsfähigkeiten zu verbessern sowie ein besseres Verständnis für ihre Projekte zu erlangen.
3.1.3. Iterative Prüfung
Dank der KI können wir nun besser verstehen, wie wir mit unserem Projekt vorankommen können, sodass der nächste Schritt darin besteht, schrittweise Tests und Fehlerbehebungen durchzuführen. Die Verwendung von Skripten, um die Leistung Ihres Codes zu analysieren und Fehler oder Probleme zu finden, ist die effektivste Art der Fehlerbehebung. Sie können Probleme besser eingrenzen und sicherstellen, dass das gesamte Programm wie vorgesehen läuft, wenn Sie den Code in kleinere Teile aufteilen und jeden Teil separat testen. Das iterative Testen und Debuggen des Codes ist entscheidend, um seine Qualität zu verbessern und seine Zuverlässigkeit und Funktionalität in der Praxis zu gewährleisten.
Nun wollen wir zum Beispiel testen, wie die vom Nutzer geforderten Eingaben funktionieren:
// Define input variables input string Alarm1 = "00:00:00"; // Default value for first alarm input string Alarm2 = "00:00:00"; // Default value for second alarm input string Alarm3 = "00:00:00"; // Default value for third alarm input string Sound = "alert.wav"; // Default sound file //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { // Initialization function, executed once when the EA is launched return 0; // Return 0 to indicate successful initialization } //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { // Deinitialization function, executed before the EA is removed // Perform any cleanup or necessary actions here } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { // Convert alarm strings to datetime objects datetime first_Alarm = StringToTime(Alarm1); datetime second_Alarm = StringToTime(Alarm2); datetime third_Alarm = StringToTime(Alarm3); // Get current local time datetime Time = TimeLocal(); // Check if current time matches any of the alarm times if(first_Alarm == Time || second_Alarm == Time || third_Alarm == Time) { // Play sound if any alarm time is reached PlaySound(Sound); } }
Erläuterung:
Dieser Codeschnipsel dient als Test, um zu verstehen, wie Nutzereingaben in unserem Programm funktionieren werden. Sie definiert Eingangsvariablen Alarm1, Alarm2, Alarm3 und Sound, die es dem Nutzer ermöglichen, Alarmzeiten festzulegen und einen Sound auszuwählen. Während der Initialisierung werden die Werte dieser Variablen auf der Konsole ausgegeben, um eine visuelle Bestätigung der Nutzereingaben zu erhalten. OnInit() und OnDeinit() führen die Initialisierung bzw. Deinitialisierung eines EAs aus, während in OnTick() die Ticks verarbeitet werden.
Ausgabe:
Nachdem wir uns vergewissert haben, dass unser Code korrekt funktioniert, können wir mit dem Testen anderer Teile des Programms fortfahren. Nehmen wir zum Beispiel an, wir wollen mit einem Skript testen. Ein Aspekt, den wir vielleicht testen wollen, ist der Druck der Ortszeit. Mit diesem Test wird sichergestellt, dass unser Programm die aktuelle Uhrzeit korrekt abruft und anzeigt, was für die Auslösung von Alarmen zu den angegebenen Zeiten entscheidend ist.
Beispiel:
void OnStart() { // Get the current local time datetime localTime = TimeLocal(); // Print the local time to the console Print("Current Local Time: ", localTime); }
Erläuterung:
Dieser Codeschnipsel definiert eine OnStart()-Funktion, die ausgelöst wird, wenn ein Skript in MQL5 zu laufen beginnt. Sie holt die aktuelle Ortszeit mit der Funktion TimeLocal() und gibt diese Zeit zusammen mit einer beschreibenden Meldung mit der Funktion Print() auf der Konsole aus. Auf diese Weise kann der Entwickler während der Tests und der Fehlersuche schnell die Genauigkeit der Zeitabfrage- und Ausgabefunktionen überprüfen.
Mit diesem Code haben wir erfolgreich getestet, ob wir die Ortszeit genau vom Computer abrufen können. Dadurch wird sichergestellt, dass unser Programm auf lokale Zeitdaten zugreifen und diese effektiv nutzen kann, was für verschiedene zeitbasierte Funktionen in unserem Projekt unerlässlich ist. In ähnlicher Weise sollten wir diese Methode des Testens und Debuggens auf den Rest unseres Codes anwenden, um sicherzustellen, dass jede Komponente wie vorgesehen funktioniert, bevor wir sie in das größere Projekt integrieren.
Unsere Fähigkeit, die Ortszeit präzise vom Computer abzurufen, wurde mit diesem Code erfolgreich getestet. Da viele der zeitbasierten Funktionen in unserem Projekt von der Fähigkeit unseres Programms abhängen, auf lokale Zeitdaten zuzugreifen und diese zu verwenden, ist damit gewährleistet, dass es dies auch kann. Indem wir sicherstellen, dass jeder Teil wie vorgesehen funktioniert, bevor wir ihn in das Gesamtprojekt integrieren, sollten wir diesen Test- und Debugging-Ansatz auch für die übrigen Teile unseres Codes verwenden.
Sie können die KI bitten, Ihre getesteten Codesegmente in ein sinnvolles Programm zu integrieren, nachdem jeder Schritt des Codes getestet wurde. Sie können jedoch in bestimmten Situationen die erforderlichen Anpassungen selbst vornehmen, wenn die Ergebnisse nicht Ihren Erwartungen entsprechen. Durch ihre ständige Anleitung und Unterstützung hat die KI Ihre Arbeit vereinfacht und Ihnen viel Zeit erspart.Die Antwort von AI:
// Define input variables input string Alarm1 = "00:00:00"; // Default value for first alarm input string Alarm2 = "00:00:00"; // Default value for second alarm input string Alarm3 = "00:00:00"; // Default value for third alarm input string Sound = "alert.wav"; // Default sound file //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { // Initialization function, executed once when the EA is launched return 0; // Return 0 to indicate successful initialization } //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { // Deinitialization function, executed before the EA is removed // Perform any cleanup or necessary actions here } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { // Convert alarm strings to datetime objects datetime first_Alarm = StringToTime(Alarm1); datetime second_Alarm = StringToTime(Alarm2); datetime third_Alarm = StringToTime(Alarm3); // Get current local time datetime Time = TimeLocal(); // Check if current time matches any of the alarm times if(first_Alarm == Time || second_Alarm == Time || third_Alarm == Time) { // Play sound if any alarm time is reached PlaySound(Sound); } }
Dieser Block definiert die Funktion OnTick(), die bei jedem Tick des Charts ausgeführt wird. Es ist das Herzstück eines funktionierenden der EAs. Und so funktioniert es:
- Sie konvertiert die Alarmzeit-Strings (Alarm1, Alarm2, Alarm3) in Datetime-Objekte unter Verwendung der Funktion StringToTime().
- Sie holt die aktuelle Ortszeit mit der Funktion TimeLocal() und speichert sie in der Variablen Time.
- Es wird geprüft, ob die aktuelle Zeit mit einer der Alarmzeiten übereinstimmt. Ist dies der Fall, wird der angegebene Sound mit der Funktion PlaySound() abgespielt.
Anmerkung: Um Ihre Eingaben zu bearbeiten, drücken Sie die Taste F7.
Schlussfolgerung
Zusammenfassend lässt sich sagen, dass dieser Artikel einen gründlichen Überblick über projektbasiertes Lernen zur Beherrschung von MQL5 gegeben hat. Durch die Aufteilung komplexer Konzepte in überschaubare Projekte können die Lernenden ihr Verständnis und ihre Kenntnisse in der MQL5-Programmierung vertiefen. Durch den Einsatz von KI-Tools, iterativen Tests und schrittweisem Pseudocode können Entwickler effizient Expert Advisors erstellen und ihre Handelsstrategien verbessern. Erinnern Sie sich daran, dass das Erlernen von MQL5 eher ein Marathon als ein Sprint ist und dass das projektbasierte Lernen ein wesentlicher erster Schritt auf dem Weg zur Beherrschung ist. Nehmen Sie also Projekte in Angriff, probieren Sie Code aus und lernen Sie weiter und entwickeln Sie sich als Entwickler weiter.
Übersetzt aus dem Englischen von MetaQuotes Ltd.
Originalartikel: https://www.mql5.com/en/articles/14651
Scheinkorrelationen in Python
Neuronale Netze leicht gemacht (Teil 75): Verbesserung der Leistung von Modellen zur Vorhersage einer Trajektorie
Modifizierter Grid-Hedge EA in MQL5 (Teil IV): Optimierung der einfachen Grid-Strategie (I)
Statistische Arbitrage mit Vorhersagen
- Freie Handelsapplikationen
- Über 8.000 Signale zum Kopieren
- Wirtschaftsnachrichten für die Lage an den Finanzmärkte
Sie stimmen der Website-Richtlinie und den Nutzungsbedingungen zu.