Erweiterter EA-Konstruktor für MetaTrader - botbrains.app

Einführung

Im Allgemeinen lassen sich Handelsstrategien auf einen bestimmten Algorithmus reduzieren, der automatisiert werden kann. Handelsroboter können tausende Male schneller handeln als ein Mensch, aber nicht jeder Händler ist des Programmierens mächtig.

botbrains.app ist eine No-Code-Plattform für die Entwicklung von Handelsrobotern. Sie brauchen nichts zu programmieren, um einen Handelsroboter im BotBrains-Editor zu erstellen - ziehen Sie einfach die erforderlichen Blöcke auf das Schema, legen Sie ihre Parameter fest und stellen Sie Verbindungen zwischen ihnen her.

Die botbrains.app verfügt über eine Dokumentation (docs.botbrains.app), die alle Konzepte des Editors im Detail beschreibt. Dieser Artikel beschreibt die Schnittstelle des Editors, seine wichtigsten Funktionen sowie die Implementierung der Handelsstrategie "Kreuzen von gleitenden Durchschnitten".

Editor-Funktionen

In BotBrains können Sie nicht nur einfache Handelsroboter entwickeln (z.B. Handelsroboter, die auf dem Kreuzen von gleitenden Durchschnitten basieren), sondern auch komplexe Handelsalgorithmen implementieren (z.B. Handelsroboter, die auf dem Spread Trading zwischen Symbolen basieren). BotBrains ermöglicht es Ihnen, einen Handelsroboter mit Ihrem Telegrambot zu verknüpfen - mit speziellen Blöcken können Sie Nachrichten über Handelsergebnisse und sogar Screenshots von Charts in einer benutzerdefinierten Größe versenden. Sie können auf einfache Weise Aktionen erstellen und den Schaltflächen zuweisen, Eingabefelder hinzufügen, um variable Werte zu steuern, wenn der Roboter läuft, und verschiedene andere Blöcke hinzufügen, um Ihre Roboterschnittstelle aufzubauen. 

In der folgenden Tabelle sind die Kategorien der im botbrains-Editor verfügbaren Blöcke aufgeführt. Eine vollständige Liste der verfügbaren Blöcke finden Sie am Ende des Artikels.

Kategorie	Beschreibung
Ereignisse	Diese Blöcke werden aktiviert, wenn etwas passiert. Zum Beispiel wird der Ereignisblock "Start of robot work" (Beginn der Roboterarbeit) aktiviert, sobald der Roboter gestartet wird.
Bedingung	Mit dem "if"-Block können Sie verschiedene Prüfungen durchführen.
Schleife	Schleifen werden vielfach verwendet. Sie können zum Beispiel eine Schleife benutzen, um alle verfügbaren Symbole durchzugehen und das Symbol zu identifizieren, das während der letzten Handelssitzung die größte Bewegung gemacht hat.
Indikatoren	Indikatoren sind eines der wichtigsten Mittel der technischen Analyse. BotBrains bietet eine breite Palette von Indikatoren: vom einfachen Volumen bis zur Ichimoku-Wolke
Chart-Analyse	Holen Sie sich Informationen über einen bestimmten Chart-Balken, erhalten Sie den maximalen/minimalen Preis für einen bestimmten Zeitraum. Zeichnen Sie horizontale und vertikale Linien auf dem Chart.
DOM-Analyse	Informieren Sie sich über die Spanne der Markttiefe und deren Preise.
Transaktionen	Limit-/Stop-Aufträge platzieren und entfernen. Marktaufträge platzieren, Position schließen.
Variablen	Ändern Sie die Werte von Variablen. In einer Variable können Sie zum Beispiel die Anzahl der Lots speichern, mit denen Ihr Roboter handelt.
Sounds (Töne)	Mit Sound-Blöcken können Sie bestimmte Töne abspielen, wenn etwas passiert. Sie können zum Beispiel den Sound "Buy signal" (Kaufsignal) abspielen, wenn alle Bedingungen für die Eröffnung einer Kaufposition erfüllt sind.
Informationen abrufen	Hier erhalten Sie Informationen über das Handelskonto, die Handelssitzung, aktive Limit-/Stop-Aufträge, historische Limit-/Stop-Aufträge, Symbol, Zeit und historische Geschäfte.
Enumerationen	Enumerationen von Symbolen, aktiven Limit-/Stop-Orders, historischen Limit-/Stop-Orders und historischen Geschäften.
Telegram	Senden Sie Nachrichten und Charts-Screenshots an Ihr Telegram.
Schnittstelle	Erstellen Sie eine vollwertige Schnittstelle für einen Handelsroboter. Einzelne Elemente der Oberfläche können mit Modifikationsblöcken verändert werden. Sie können Aktionen an Schnittstellenschaltflächen binden. Der Schnittstellenblock "Eingabefeld" kann verwendet werden, um Variablenwerte zu ändern, während der Roboter läuft. Mit all diesen Blöcken lassen sich dynamische Benutzeroberflächen erstellen.
Vordefinierte Konstanten	Grundsätzlich werden vordefinierte Konstanten für Vergleiche verwendet. Zum Beispiel gibt es 3 vordefinierte Konstanten für die Positionsrichtung: Kaufen, Verkaufen und keine Richtung. Sie können die Richtung der aktuellen offenen Position abfragen und sie mit einer der vordefinierten Konstanten vergleichen.
Debuggen	Mit dem "Debug"-Block können Sie Debug-Informationen in das Terminaljournal ausgeben. Mit diesem Block können Sie zum Beispiel überprüfen, ob Variablen oder Konstanten korrekte Werte enthalten.
Andere Blöcke	Terminal schließen, Roboterarbeit stoppen, Roboterarbeit pausieren. Log in Datei, Benachrichtigung im Terminal, Kommentar zum Chart.
Mathematische Operatoren	Addition, Subtraktion, Multiplikation, Division, Rest der Division, Quadratwurzel, Potenzierung. Vergleiche: kleiner als, größer als, kleiner oder gleich als, größer oder gleich als.
Logische Operatoren	Es gibt logische Operatoren zur Bildung von Bedingungen: UND, ODER, NICHT.
Teleports	Es gibt Blöcke für das Betreten und Verlassen des Teleports. Manchmal muss man schnell und bequem zur Ausführung eines anderen Abschnitts des Schemas wechseln - mit Teleports kann dies in Sekundenschnelle geschehen.
Blöcke zur Typkonvertierungen	Standardmäßig werden alle Nutzerdaten als Zahl gespeichert. Mit Blöcken zu Typkonvertierung können Sie explizit angeben, in welchem Format die Daten dargestellt werden sollen. Es gibt 4 Typen: Ganzzahl, Dezimalzahl, Zeichenkette, Datum und Uhrzeit.
Variable oder Konstante auswählen	Variable oder Konstante auswählen
Variablen- oder Konstantenauswahl	Variablen- oder Konstantenauswahl

Schnittstelle des BotBrains Editors

BotBrains-Editor hat 3 Modi: Logic (Logik), Interface (Schnittstelle), Code (Programmcode).

Modus "Logic" (Logik):

Im Modus "logic" kann man das Logikschema des Roboters erstellen. In diesem Modus können Sie die meisten Blöcke verwenden: vom "if"-Block und Transaktionsblöcken bis hin zu Blöcken für das Senden von Nachrichten an Telegram und Blöcken für die Erstellung von Roboterprotokollen. In diesem Modus entwickeln Sie die Logik Ihres Handelsroboters. Mit einfachen Blöcken legen Sie fest, was Ihr Roboter tun soll - wann er kaufen, wann er verkaufen, wann er Nachrichten an Telegram senden, wann er den Handel beenden soll und so weiter. Insgesamt gibt es mehr als 140 Blöcke im botbrains-Editor, mit denen Sie fast jede Handelsstrategie umsetzen können.

Modus "Interface" (Schnittstelle):

Im Modus "Interface" können Sie, wie der Name schon sagt, die Schnittstelle eines Handelsroboters erstellen. In nur wenigen Minuten können Sie eine vollwertige Schnittstelle für Ihren Handelsroboter erstellen. Jedes Schnittstellenelement verfügt über einen kompletten Satz von Einstellungen. Mit dem Block "Modify interface element" (Schnittstellenelement ändern) können Sie die Eigenschaften der Schnittstellenelemente im Handumdrehen ändern.

Der Modus "Code":

In diesem Modus können Sie den generierten Code Ihres Handelsroboters sehen. Um den Code eines Handelsroboters zu generieren, drücken Sie einfach die Taste ~ oder klicken Sie auf die entsprechende Schaltfläche in der rechten Symbolleiste.

Starten eines Handelsroboters

Der gesamte Code Ihres Handelsroboters wird innerhalb von Sekunden generiert, nachdem Sie eine Taste auf Ihrer Tastatur gedrückt haben. Um einen mit BotBrains erstellten Roboter zu starten, müssen Sie sicherstellen, dass alle erforderlichen Abhängigkeiten installiert sind:

1. Die Bibliothek botbrains_lib.ex5
2. Einbinden (include) der Datei botbrains_lib.mqh
3. Einbinden (include) der Datei botbrains_constants.mqh.
4. Sound-Dateien

Wenn die oben genannten Abhängigkeiten nicht installiert sind, können die in BotBrains erstellten Roboter nicht gestartet werden oder funktionieren nicht richtig.

Sie können alle notwendigen Dateien hier herunterladen. Die Installation der notwendigen Dateien wird in dem entsprechenden Dokumentationsartikel ausführlich behandelt.

Beispiel eines gleitenden Durchschnittskreuzes

Schauen wir uns die Implementierung der Handelsstrategie "Moving Average Intersection" (Kreuzen gleitender Durchschnitte) im botbrains-Editor an. Sie können das komplette Schema direkt im Editor öffnen, indem Sie auf den Link klicken.

Öffnen Sie den Editor und erstellen Sie 5 Konstanten:

1. slow_ma_period - Periodenlänge des langsamen gleitenden Durchschnitts (konstanter Wert: 60)
2. fast_ma_period - Periodenlänge des schnellen gleitenden Durchschnitts (konstanter Wert: 30)
3. Symbol - Code des zu handelnden Symbols (konstanter Wert: MGCV21 oder ein beliebiges anderes in Ihrem Handelsterminal verfügbares Symbol)
4. admin_id - ID des Telegram-Benutzers, an den unser Roboter Nachrichten mit Handelsinformationen und Chart-Screenshots senden wird (konstanter Wert: Ihre Telegram-ID)
5. Lot - Größe der gehandelten Lots

Um die Tatsache zu erkennen, dass sich zwei gleitende Durchschnitte gekreuzt haben, müssen wir 4 Variablen erstellen:

1. ma_slow - aktueller Wert des langsamen gleitenden Durchschnitts
2. ma_fast - aktueller Wert des schnellen gleitenden Durchschnitts
3. ma_slow_prev - Wert des langsamen gleitenden Durchschnitts des vorherigen Balkens
4. ma_fast_prev - Wert des schnellen gleitenden Durchschnitts des vorherigen Balkens

Auf diese Weise können wir den Übergang zwischen dem langsamen und dem schnellen gleitenden Durchschnitt feststellen, indem wir einfach die Werte dieser Variablen vergleichen. Bitte beachten Sie, dass wir keine Anfangswerte für die Variablen festlegen - die Werte dieser Variablen werden aktualisiert, sobald ein neuer Tick für das gehandelte Symbol empfangen wird.

Drucken wir die Meldung "Robot is launched" (Roboter ist gestartet), wenn der Roboter gestartet wird. Um dies zu implementieren, ziehen Sie einfach zwei Blöcke auf das Roboterlogikschema: den Ereignisblock "Roboterstart" und den Block "Journalmeldung". Verbinden Sie dann diese Blöcke:

Legen Sie in den Einstellungen des Blocks "Journalmeldung" die Meldung fest, die angezeigt werden soll:

Wenn ein neuer Tick für ein gehandeltes Symbol empfangen wird, sollte unser Roboter die Variablenwerte aktualisieren. Dazu ziehen wir den "New Tick"-Ereignisblock und 4 Blöcke "Set variable complex value" (Komplex zum Setzen der Variablen) in das Logikschema des Roboters. Legen Sie den Block "Moving average" (Gleitender Durchschnitt) in den Körper jedes Blocks "Set variable complex value" und wählen Sie die entsprechende Variable in jedem dieser Blöcke aus. Stellen Sie dann Verbindungen zwischen diesen Blöcken her:

Mit Hilfe des Blocks "Moving average" können wir den Wert des Indikators "Moving average" ermitteln. Dieser Block hat 6 Parameter:

1. Symbol
2. Zeitrahmen
3. Periode
4. Glättungsverfahren
5. Applied price - verwendeter Preis
6. Shift (Verschiebung)

Mit dem Parameter "shift" (Verschiebung) können wir den Wert des Indikators "gleitender Durchschnitt" für einen bestimmten Balken ermitteln. Ein Shift-Wert von 0 bedeutet beispielsweise den Wert des letzten verfügbaren Balkens (keine Verschiebung), während der Wert 1 den Wert des vorherigen Balkens bedeuten würde. Auf diese Weise können wir die Werte des langsamen und des schnellen gleitenden Durchschnitts für den aktuellen und den vorhergehenden Balken erhalten, indem wir einfach die unterschiedlichen Werte für die Parameter "shfit" und "period" festlegen.

Geben wir nun die Parameter für den ersten "MA"-Block an:

Beachten Sie, dass die entsprechenden Konstanten als Werte für die Parameter "symbol" und "period" verwendet werden. Sie können auch Variablen als Parameterwerte verwenden.

Weitere Informationen zur Arbeit mit Variablen und Konstanten finden Sie im entsprechenden Dokumentationsartikel.

Auf diese Weise wird der Wert der Variable "ma_slow" jedes Mal aktualisiert, wenn ein neuer Tick für das gehandelte Symbol empfangen wird. 

Dasselbe gilt für die Variable "ma_fast":

In diesem Stadium aktualisieren wir die aktuellen Werte der gleitenden Durchschnitte, aber um die Tatsache der Kreuzung zu bestimmen, müssen wir den Wert der gleitenden Durchschnitte des vorherigen Balkens kennen. Der aktuelle Balken hat die Verschiebung 0, der vorherige Balken hat die Verschiebung 1 usw. Deshalb werden wir in den letzten 2 Blöcken von "Set variable complex value" alles ähnlich machen, aber dieses Mal sollten wir den Parameter "shift" der Blöcke "Moving Average" auf 1 setzen, so dass die Variablen "ma_slow_prev" und "ma_fast_prev" die Werte des gleitenden Durchschnitts des vorherigen Balkens enthalten werden.

Machen Sie dasselbe für die Variable "ma_fast_prev".

Stellen wir sicher, dass unsere Variablen auf die richtigen Werte gesetzt sind. Fügen Sie den Block "Timer" in das Schema ein. Dieser Block hat nur 1 Parameter - "Intervall (sec)". Dieser Parameter ist standardmäßig auf 1 gesetzt, so dass dieser Block standardmäßig jede Sekunde ausgeführt wird. Fügen Sie dann 4 Blöcke "Print debug info (Ausdruck von Debug-Info) in das Schema ein - dieser Block druckt einfach die angegebene Nachricht in das Terminaljournal. Mit Hilfe dieses Blocks können wir sehen, welche Werte unsere Variablen enthalten. In jedem der Blöcke "Print debug info" platzieren Sie 3 Blöcke in der folgenden Reihenfolge:

1. Value input - dieser Block ist ein einfaches Eingabefeld, in das wir einen beliebigen Text eingeben können. In unserem Fall sollten wir Variablennamen eingeben, damit wir verstehen können, welche Variablen sich auf welche Werte beziehen.
2. "+" Operator - mit diesem Block können wir 2 Strings zusammenfügen.
3. Variable select - mit Hilfe dieses Blocks können wir den Wert der angegebenen Variable ermitteln.

In diesem Stadium sollte unser Schema wie folgt aussehen:

In BotBrains werden alle Benutzerwerte als Zahlen gespeichert. In diesem Fall müssen wir explizit angeben, dass die "Werteingabe"-Blöcke Text enthalten, damit der Text selbst ausgegeben wird und nicht seine numerische Darstellung.

Dazu wird einfach der Konvertierungsblock vom Typ "Regular string" (reguläre Zeichenkette) auf jeden der "value input"-Blöcke gesetzt:

Jetzt können wir den Code des Roboters kompilieren und ihn sogar ausführen - die Werte der angegebenen Variablen werden jede Sekunde in das Terminaljournal ausgedruckt. Allerdings wird eine Warnung "implicit conversion from 'number' to 'string'" (implizite Konvertierung von 'Zahl' nach 'Text') während der Kompilierung erscheinen:

In unserem Schema versuchen wir nämlich, einen Text-Wert ("Werteingabe"-Blöcke, die in eine Zeichenkette umgewandelt wurden) mit einem numerischen Wert (Variablen, die die numerischen Werte der gleitenden Durchschnitte enthalten) zu addieren. Um dies zu beheben, müssen wir einfach alle Variablen in Zeichenketten umwandeln. Dies kann auf zwei Arten geschehen:

1. Mit dem Typkonvertierungsblock "Regular string" (Reguläre Zeichenkette).
2. Die Verwendung des Konvertierungsblocks vom Typ "Fraction" (Bruch) - dieser Block unterscheidet sich vom Block "Regular string" nur durch die Möglichkeit, die Anzahl der Stellen nach dem Dezimalpunkt zu begrenzen.

Verwenden wir die zweite Möglichkeit. Dazu platzieren Sie den Konvertierungsblock vom Typ "Bruch" auf jedem der Blöcke "variable select":

In den Einstellungen jedes Blocks "Fraction" geben Sie als einzigen Parameter 2 an - "Dezimalstellen":

Die Arbeit mit den Typen wird in dem entsprechenden Dokumentationsartikel ausführlich beschrieben.

Öffnen Sie das Terminal und fügen Sie 2 "Moving Average"-Indikatoren auf dem Chart des gehandelten Symbols hinzu, mit den gleichen Parametern wie in unserem Roboter, so dass wir die Werte der Variablen mit den Werten der Indikatoren auf dem Chart vergleichen können:

Generieren Sie dann den Code des Roboters mit der Taste "~" oder über die entsprechende Schaltfläche in der rechten Toolbox.

Starten Sie unseren Roboter im Terminal und vergleichen Sie die Ausgabewerte im Termialjournal mit den tatsächlichen Werten der Indikatoren im Chart:

Alle Werte stimmen überein, so dass wir mit unserer Arbeit fortfahren können.

Das Einzige, was noch zu tun ist, ist, die Werte der Variablen zu vergleichen, wenn ein neuer Tick empfangen wird, um einen Crossover des gleitenden Durchschnitts zu erkennen und einen Handel zu tätigen, wenn alle Bedingungen für einen Handel erfüllt sind.

Bestimmen wir zunächst die Bedingungen für den Abschluss eines Geschäfts. Es gibt 3 Bedingungen, die erfüllt sein müssen, damit eine Kaufposition eröffnet werden kann:

1. Der aktuelle Wert des schnellen gleitenden Durchschnitts ist größer als der aktuelle Wert des langsamen gleitenden Durchschnitts.
2. Der Wert des schnellen gleitenden Durchschnitts des vorherigen Balkens ist kleiner als der Wert des langsamen gleitenden Durchschnitts des vorherigen Balkens.
3. Die Richtung der aktuellen Position ist nicht "Kaufen".

Bitte beachten Sie, dass, wenn wir die letzte Bedingung weglassen, unser Roboter viele Positionen in kurzer Zeit ausführen kann, weil die erste und die zweite Bedingung mehrmals in einer Sekunde erfüllt werden können. Als Ergebnis der dritten Bedingung wird unser Roboter keine neue Kaufposition zusätzlich zur bestehenden Kaufposition eröffnen.

Beachten Sie, dass Sie im BotBrains-Editor die maximale und verdächtige Transaktionshäufigkeit für alle Roboter festlegen können. Wenn die maximale Handelshäufigkeit erreicht ist, schließt der Roboter sofort alle offenen Positionen und entfernt alle erteilten Aufträge. Der Roboter benachrichtigt Sie außerdem per Telegram und/oder gibt eine Meldung direkt im Terminal aus, je nach den in den Sicherheitseinstellungen des Roboters festgelegten Parametern. Wenn die verdächtige Häufigkeit der Transaktionen erreicht ist, wird der Roboter keine Positionen schließen oder Aufträge entfernen, sondern Sie nur per Telegram und/oder direkt im Terminal benachrichtigen.

Die folgenden Bedingungen müssen erfüllt sein, um eine Verkaufsauftrag zu erteilen:

1. Der aktuelle Wert des schnellen gleitenden Durchschnitts ist niedriger als der aktuelle Wert des langsamen gleitenden Durchschnitts.
2. Der Wert des schnellen gleitenden Durchschnitts des vorherigen Barrens ist größer als der Wert des langsamen gleitenden Durchschnitts des vorherigen Balkens.
3. Die Richtung der aktuellen Position ist nicht "Verkaufen".

Erstellen wir nun eine Bedingung für die Eröffnung einer Kaufposition:

Der Block "Position info" (Positionsinfo) hat 2 Parameter:

1. Symbol - Symbol über die Position, über die man Informationen erhalten möchte
2. Block value - Parameter der Zielposition. Verfügbare Optionen: Positionsvolumen, Position Eröffnungszeit, Eröffnungspreis, Position aktueller Gewinn und Positionsrichtung

Wir verwenden die Konstante "Symbol" als Wert für den Parameter "Symbol". Wählen Sie "Position direction" (Positionsrichtung) als Wert für den zweiten Parameter.

Auf diese Weise wird der Wert des Blocks "Positionsinfo" gleich der Richtung der aktuellen offenen Position um das angegebene Symbol sein.

Nach diesem Block gibt es drei Blöcke: "Not" (nicht), "Equals" (gleich) und "Position direction" (Positionsrichtung). Der Block "Positionsrichtung" enthält alle möglichen Richtungen: "Buy direction" (Kaufrichtung), "Verkaufsrichtung" (Sell direction) und "No direction" (Keine Richtung). Wir prüfen, ob die Richtung der aktuellen Position nicht "Kaufen" ist.

Dann fügen wir einen Block "Market order" (Marktorder) in das Schema ein und verknüpfen diesen Block mit dem "Yes"-Konnektor unseres "If"-Blocks:

Der Block "Market order" hat drei Parameter:

1. Symbol - das Symbol, für das eine Marktorder platziert werden soll
2. Direction - Richtung der Order (Kauf/Verkauf)
3. Volume- Auftragsvolumen

Beachten Sie, dass wir für viele Parameter Konstanten als Werte verwenden. Dadurch können wir unseren Roboter leicht konfigurieren - wir können einfach den Wert einer Konstante an einer Stelle ändern und der neue Wert wird automatisch an allen Stellen verwendet, an denen diese Konstante verwendet wird.

Wenn ein mit dem BotBrains-Editor erstellter Handelsroboter Konstanten enthält, werden diese ganz oben im generierten Code aufgeführt:

/********** <ROBOT CONSTANTS> **********/

const double __slow_ma_period = user_value("60");
const double __fast_ma_period = user_value("30");
const double __symbol         = user_value("MGCG22");
const double __admin_id       = user_value("744875082");
const double __lot            = user_value("1");

/********** </ROBOT CONSTANTS> **********/

Sie können sich die Konstanten als Robotereinstellungen vorstellen. Wenn Sie zum Beispiel ein anderes Symbol handeln möchten, ändern Sie einfach den Wert der Konstante "Symbol". Oder Sie können den Wert der Konstante direkt im BotBrains-Editor ändern und den Code neu generieren, wenn Sie nicht direkt mit dem Code arbeiten möchten. 

An dieser Stelle wird der Handelsroboter also eine Kaufposition eröffnen, wenn der schnelle gleitende Durchschnitt den langsamen gleitenden Durchschnitt von unten nach oben kreuzt. Lassen Sie uns eine Benachrichtigung erstellen, wenn unser Roboter eine Kaufposition eröffnet:

1. Ausdruck im Terminal-Journal
2. Erstellen eines Alarms im Terminal
3. Hinzufügen des Eintrags über die Ausführung des Geschäfts in die Logdatei des Roboters
4. Abspielen des "Kaufsignal"-Tons
5. Senden von Nachrichten an Telegram
6. Senden eines Bildschirmfotos des Charts an Telegram

Bitte beachten Sie, dass, wenn wir den Ton für ein Kaufsignal direkt nach einem Handel abspielen, es aber sein könnte, dass unser Ton nicht abgespielt wird, da MetaTrader automatisch seinen eigenen Ton abspielt, wenn eine Transaktion durchgeführt wird. Daher müssen wir den Ton nicht sofort abspielen, sondern mit einer gewissen Verzögerung, z.B. 1 Sekunde, nachdem die Transaktion erfolgt ist. 

Es mag den Anschein erwecken, als würde es sehr lange dauern, alle 6 Schritte zu implementieren; tatsächlich gibt es für alle diese Schritte spezielle Blöcke. Es wird buchstäblich 20-30 Sekunden dauern, um alle 6 Schritte zu implementieren. Alles, was wir bisher getan haben, kann auch in wenigen Minuten erledigt werden - um ein Vielfaches schneller als das Schreiben von Code per Hand.

Damit Telegram-Blöcke richtig funktionieren, müssen Sie Ihren Bot im @BotFather-Bot registrieren, den Token Ihres Bots erhalten und ihn in den Einstellungen Ihres Bots im BotBrains-Editor angeben. Sie müssen auch deine Telegram ID kennen, die Sie von @getmyid_bot bekommen haben. All dies wird in dem entsprechenden Dokumentationsartikel ausführlich beschrieben. Blöcke für die Arbeit mit Telegram sind nur für Pro-Benutzer verfügbar.

In ähnlicher Weise implementieren wir eine Logik für die Eröffnung von Short-Positionen. Markieren Sie dazu einfach alle Blöcke, die sich auf die Eröffnung einer Kaufposition beziehen, kopieren Sie sie (STRG + C), fügen Sie sie ein (STRG + V) und nehmen Sie die erforderlichen Änderungen vor.

Generieren Sie den Code des Roboters, kompilieren Sie ihn und führen Sie ihn im Terminal aus, um die Leistung unseres Handelsroboters zu überprüfen.

Testen Sie den Handelsroboter nur auf einem Demokonto! Die Sicherheitseinstellungen aller im BotBrains-Editor erstellten Handelsroboter verbieten standardmäßig den Handel auf einem echten Konto! Wechseln Sie erst dann zum Handel auf einem echten Konto, wenn Ihr Handelsroboter vollständig auf einem Demokonto getestet wurde!

Lassen Sie uns zufällige gleitende Durchschnittsperioden einrichten und den Handelsroboter auf einem einminütigen Zeitrahmen laufen. Zu diesem Zeitpunkt ist es wichtig, die Leistung unseres Handelsroboters zu testen und mögliche Fehler zu erkennen und zu korrigieren. Nach 80 Minuten Handelszeit hat der Handelsroboter 4 Positionen eröffnet. Nach dem Öffnen jeder Position hat der Roboter erfolgreich eine Benachrichtigung im Terminal erstellt, die entsprechenden Töne abgespielt und die entsprechenden Aufzeichnungen in der Protokolldatei des Roboters und im Journal des Terminals vorgenommen. Der Roboter sendete auch ohne Probleme Nachrichten und Screenshots von Charts direkt an Telegram. Und für all das haben wir nicht eine einzige Zeile Code geschrieben. Ein solch einfacher Roboter kann in nur wenigen Minuten gebaut werden.

Es mag den Anschein haben, dass alles in Ordnung ist. Wenn Sie jedoch einen genaueren Blick auf die von unserem Handelsroboter getätigten Geschäfte werfen, werden Sie feststellen, dass unser Handelsroboter in jeder Position außer der ersten zwei Geschäfte getätigt hat: das erste Geschäft, um die aktuelle offene Position zu beenden, und das zweite Geschäft, um die nächste Position zu eröffnen. Es ist leicht, dies zu erkennen - schauen Sie sich einfach den Chart an, prüfen Sie die Protokolldatei, sehen Sie sich die Nachrichten an, die der Handelsroboter an Telegram sendet, oder hören Sie einfach zu, wie oft der Handelsroboter nach der Ausführung des Handels einen Audioalarm erzeugt. Wir können auch die Historie der Transaktionen im Terminal analysieren.

Im BotBrains-Editor können Sie in den Sicherheitseinstellungen des Roboters die verdächtige und die maximale Handelshäufigkeit festlegen. Standardmäßig beträgt die maximale Handelshäufigkeit 2 Handelstätigkeiten pro 10 Sekunden. Wenn die maximale Handelshäufigkeit erreicht wird, schließt der Handelsroboter sofort alle von ihm eröffneten Positionen, entfernt alle erteilten Aufträge und benachrichtigt Sie per Live-Chat und/oder erstellt eine Benachrichtigung im Terminal.

Das Problem ist nicht nur, dass unser Roboter am Ende doppelt so oft gehandelt hat wie nötig hat und die meisten Positionen zu einem schlechteren Preis eingeht, sondern auch, dass unser Roboter irgendwann seine maximale Handelsfrequenz erreicht und den Handel einstellt. Genau das ist in diesem Fall passiert. Achten Sie auf die letzten Einträge in der Protokolldatei:

Lassen Sie uns dieses Problem beheben. Erstellen Sie die Variable full_lot :

Wenn der Roboter gestartet wird, setzen Sie die Variable full_lot auf den Wert der Konstante lot:

In Transaktionsblöcken sollten wir dann die Variable full_lot verwenden, anstatt die Konstante lot zu benutzen:

Dann, nach der Eingabe der Position, setzen Sie den Wert der full_lot Variable auf das Doppelte des Wertes der Konstanten lot. Nach dem ersten Handel wird der Roboter mit dem doppelten Volumen handeln. Er schließt also eine bestehende Position und eröffnet eine neue mit nur einer Position:

Der Handelsroboter wird nun alle Positionen mit einem Handel eingehen. Wir werden dies überprüfen, indem wir den Roboter im Terminal ausführen. Wenn wir uns den Handelsverlauf ansehen, werden wir feststellen, dass der erste Handel mit 1 Lot eröffnet wurde, während die folgenden mit 2 Lots eröffnet wurden:

Lassen Sie uns eine Schnittstelle für den Handelsroboter erstellen. Gehen Sie dazu in den Modus "Schnittstelle" des Editors und verwenden Sie die speziellen Blöcke, um die Schnittstelle zu erstellen:

Um eine solche Schnittstelle zu erstellen, ist es ausreichend, die folgenden Schnittstellenblöcke zu verwenden:

1. Rechteck
2. Tasten
3. Text

Die aktuellen Werte der schnellen und langsamen gleitenden Durchschnitte sollten anstelle der Gedankenstriche verwendet werden. Um dies zu implementieren, verwenden Sie den Block "Schnittstellenelement ändern" - dieser Block kann verwendet werden, um die Eigenschaften des Blocks mit der angegebenen ID zu ändern.

Verschieben wir die 4 Blöcke "Modify interface element" in das Logikschema des Roboters:

Um die Block-ID zu kopieren, gehen Sie wie folgt vor

1. Drücken Sie STRG
2. Ohne die STRG-Taste loszulassen, doppelklicken Sie auf den Zielblock

Kopieren Sie die ID des ersten Gedankenstrichs:

Öffnen Sie die Einstellungen des ersten Blocks "Oberflächenelement ändern" und stellen Sie die Parameterwerte ein. Als Erstes müssen wir die ID des Blocks angeben, dessen Eigenschaften wir ändern wollen. In unserem Fall ist es die kopierte ID des ersten Gedankenstrichs. Als Art der Änderung sollten wir "Text" wählen. Geben Sie die Variable ma_fast_prev als neuen Text an. Wenn Sie möchten, können Sie auch die Anzahl der Dezimalstellen im neuen Text festlegen (diese Einstellung sollte nur verwendet werden, wenn eine Zahl als Textinhalt eines Schnittstellentextes verwendet wird).

In ähnlicher Weise stellen wir die Parameter der verbleibenden 3 Blöcke "Oberflächenelement ändern" ein. Auf diese Weise werden, wenn ein neuer Tick für ein gehandeltes Symbol empfangen wird, die entsprechenden Werte der gleitenden Durchschnitte in die Variablen ma_fast, ma_slow, ma_fast_prev und ma_slow_prev geschrieben und dann werden die Werte dieser Variablen in die entsprechenden Textelemente der Schnittstelle geschrieben.

Weisen wir nun den Schaltflächen der Schnittstelle die entsprechenden Aktionen zu. Dazu verschieben wir drei Blöcke in das Logikdiagramm des Roboters: die 2 Blöcke "Market Order" und 1 Block "Close Position":

Setzen Sie dann die Einstellungen dieser Blöcke:

Kopieren Sie die ID des ersten Blocks "Market Order" und geben Sie die kopierte ID als Wert für den Parameter "Linked block ID" der ersten Schaltfläche an:

Auf diese Weise wird der entsprechende Block aufgerufen, wenn die Schaltfläche "Kaufen" gedrückt wird. Weisen Sie den anderen Schaltflächen auf ähnliche Weise Aktionen zu. Generieren wir nun den Robotercode und führen ihn im Terminal aus, um seine Funktionalität zu überprüfen:

Bitte beachten Sie, dass die Schnittstelle, die wir im Editor erstellt haben, vollständig auf das Handelsterminal übertragen wurde. Die Schaltflächen der Schnittstelle funktionieren und anstelle der Striche sehen wir die tatsächlichen Werte der gleitenden Durchschnitte.

Der generierte Code des Handelsroboters wird im Folgenden gezeigt:

//+------------------------------------------------------------------+
//|                                      moving_average_cross_en.mq5 |
//|                                                    botbrains.app |
//+------------------------------------------------------------------+

#include <botbrains_constants.mqh>
#include <botbrains_lib.mqh>

/********** <ROBOT CONSTANTS> **********/

const double __slow_ma_period = user_value("60");
const double __fast_ma_period = user_value("30");
const double __symbol         = user_value("MGCG22");
const double __admin_id       = user_value("744875082");
const double __lot            = user_value("1");

/********** </ROBOT CONSTANTS> **********/

/********** <ROBOT VARIABLES> **********/

double __ma_slow      = user_value("");
double __ma_fast      = user_value("");
double __ma_slow_prev = user_value("");
double __ma_fast_prev = user_value("");
double __full_lot     = user_value("");

/********** </ROBOT VARIABLES> **********/

int OnInit(){

  //Is autotrading allowed:
  if(!TerminalInfoInteger(TERMINAL_TRADE_ALLOWED)){
    MessageBox("Autotrading is not allowed, expert will be removed");
    ExpertRemove();
    return(-1);
  }

  //Is trading on live account allowed:
  if(AccountInfoInteger(ACCOUNT_TRADE_MODE) == ACCOUNT_TRADE_MODE_REAL){
    MessageBox("Expert is not allowd to trade on live account!");
    ExpertRemove();
    return(-1);
  }

  //Set robot name:
  set_robot_name("moving_average_cross_en");

  //Set license key:
  set_license_key("2L5J7K-K986ND-KMPT94-1Q");

  //Set language:
  set_lang("en");

  //Generate robot magic number:
  generate_magic();

  //Set initial trading account balance:
  set_init_account_balance();

  //Set suspicious deals frequency params:
  set_suspicous_deals_frequency(60, 3, false, true);

  //Set maximal deals frequency params:
  set_max_deals_frequency(10, 2, false, true);

  //Set the timer with an interval of 1 second:
  EventSetTimer(1);

  //Blocks executed when the robot is launched:
  block_bYi6ikfde();
  block_bYUS6GLT0();

  //Create interface elements:
  create_rectangle("b1ELCu5iq", 0, 0, CORNER_LEFT_UPPER, 15, 15, 390, 195, C'20,20,20', BORDER_FLAT, STYLE_SOLID, C'10,191,254', 2, 0, false, false, false);
  create_button("b4rh5uKlb", 0, 0, CORNER_LEFT_UPPER, 195, 165, 150, 30, "Sell", "Ubuntu Mono", 8, C'255,255,255', C'20,20,20', C'255,51,0', false, 0, false, false, false);
  create_text("b5BGSldua", 0, 0, CORNER_LEFT_UPPER, 120, 135, "-", "Ubuntu Mono", 9, C'255,255,255', 0, ANCHOR_LEFT_UPPER, 0, false, false, false);
  create_text("b9EjNpibO", 0, 0, CORNER_LEFT_UPPER, 30, 30, "\"MA Cross\" trading robot", "Ubuntu Mono", 14, C'255,255,255', 0, ANCHOR_LEFT_UPPER, 0, false, false, false);
  create_button("bBTrBQlkS", 0, 0, CORNER_LEFT_UPPER, 30, 165, 150, 30, "Buy", "Ubuntu Mono", 8, C'255,255,255', C'20,20,20', C'51,255,0', false, 0, false, false, false);
  create_text("bEncRhDIR", 0, 0, CORNER_LEFT_UPPER, 285, 75, "Current bar:", "Ubuntu Mono", 9, C'255,255,255', 0, ANCHOR_LEFT_UPPER, 0, false, false, false);
  create_text("bI0vadsS2", 0, 0, CORNER_LEFT_UPPER, -195, 270, "Text", "Ubuntu Mono", 9, C'255,255,255', 0, ANCHOR_LEFT_UPPER, 0, false, false, false);
  create_text("bK1cW1i6s", 0, 0, CORNER_LEFT_UPPER, 30, 135, "MA slow:", "Ubuntu Mono", 9, C'255,255,255', 0, ANCHOR_LEFT_UPPER, 0, false, false, false);
  create_text("bLcIIkYqO", 0, 0, CORNER_LEFT_UPPER, 285, 135, "-", "Ubuntu Mono", 9, C'255,255,255', 0, ANCHOR_LEFT_UPPER, 0, false, false, false);
  create_text("bSDWBsxbk", 0, 0, CORNER_LEFT_UPPER, 285, 105, "-", "Ubuntu Mono", 9, C'255,255,255', 0, ANCHOR_LEFT_UPPER, 0, false, false, false);
  create_text("bTK8r1zb1", 0, 0, CORNER_LEFT_UPPER, 30, 105, "MA fast:", "Ubuntu Mono", 9, C'255,255,255', 0, ANCHOR_LEFT_UPPER, 0, false, false, false);
  create_text("bhKcJ2pwx", 0, 0, CORNER_LEFT_UPPER, 120, 75, "Previous bar:", "Ubuntu Mono", 9, C'255,255,255', 0, ANCHOR_LEFT_UPPER, 0, false, false, false);
  create_text("bj6MtjhZF", 0, 0, CORNER_LEFT_UPPER, 120, 105, "-", "Ubuntu Mono", 9, C'255,255,255', 0, ANCHOR_LEFT_UPPER, 0, false, false, false);
  create_button("bympSPhAp", 0, 0, CORNER_LEFT_UPPER, 360, 165, 30, 30, "X", "Ubuntu Mono", 8, C'255,255,255', C'20,20,20', C'255,51,0', false, 0, false, false, false);

  ChartRedraw();

  //Robot initialization was successful:
  return(INIT_SUCCEEDED);

}

void OnDeinit(const int reason){

  Comment("");
  PlaySound(NULL);

  //Remove all graphical objects from the chart on which the robot was launched:
  remove_all_objects(0);

}

void OnTimer(){

  //Timer with 1 sec. interval (bgP4YbxaQ):
  block_bTonyumSN();
  block_bO7LNEs4m();
  block_bS1JODjZj();
  block_bM4s77Wvc();

  //Every 10 sec. reset the counter of the performed deals number (max deals frequency):
  if(get_timer_tick_index() % 10 == 0){

    deals_max_frequency_counter_reset();

  }

  //Every 60 sec. reset the counter of the performed deals number (suspicious deals frequency):
  if(get_timer_tick_index() % 60 == 0){

    deals_suspicious_frequency_counter_reset();

  }

  timer_tick_index_increment();

}

void OnTick(void){

  //Blocks executed when a new tick is received on the symbol on the chart of which the robot was launched:
  block_bHxbWWtwW();
  block_bvIvs7SMe();
  block_boHVNlqnO();

}

void OnTrade(){

  //Check deals frequency:
  check_deals_frequency();

}

void OnChartEvent(
  const int      id,      // event identificator
  const long&    lparam,  // event parameter of type long
  const double&  dparam,  // event parameter of type double
  const string&  sparam   // event parameter of type string
){

  if(id == CHARTEVENT_OBJECT_CLICK){

    string object_name = sparam;

    if(ObjectGetInteger(0, object_name, OBJPROP_TYPE) == OBJ_BUTTON){

      if(object_name == "b4rh5uKlb"){

        block_bYGEhpZDM();

      }

      if(object_name == "bBTrBQlkS"){

        block_bCa4uSC92();

      }

      if(object_name == "bympSPhAp"){

        block_bXRrICVna();

      }

      Sleep(100);
      ObjectSetInteger(0, object_name, OBJPROP_STATE, false);
      ChartRedraw();

    }

  }

}

//Function of the block b0Wkfq6OD (set_complex_variable_value):
void block_b0Wkfq6OD(){

  vset(__ma_fast, ( moving_average(to_string(__symbol), PERIOD_CURRENT, (int)__fast_ma_period, MODE_SMA, PRICE_CLOSE, 0) ));

  block_b6LYVQGej();

}

//Function of the block b1VYatoxs (interface_element_modify):
void block_b1VYatoxs(){

  modify_text("b5BGSldua", DoubleToString(__ma_slow_prev, 2) );

}

//Function of the block b3UJfY74N (interface_element_modify):
void block_b3UJfY74N(){

  modify_text("bSDWBsxbk", DoubleToString(__ma_fast, 2) );

}

//Function of the block b3crj4ayK (log):
void block_b3crj4ayK(){

  log_to_file("Open short!");

  block_bzVyOb4tW();

}

//Function of the block b6LYVQGej (set_complex_variable_value):
void block_b6LYVQGej(){

  vset(__ma_slow_prev, ( moving_average(to_string(__symbol), PERIOD_CURRENT, (int)__slow_ma_period, MODE_SMA, PRICE_CLOSE, 1) ));

  block_bQMre45Bd();

}

//Function of the block bCa4uSC92 (place_market_order):
void block_bCa4uSC92(){

  place_market_order(to_string(__symbol), "BUY", __lot);

}

//Function of the block bHxbWWtwW (condition):
void block_bHxbWWtwW(){

  if (( __ma_fast > __ma_slow ) && ( __ma_fast_prev < __ma_slow_prev ) && ( get_position_info(to_string(__symbol), "POSITION_DIRECTION") != BUY_DIRECTION )){

    block_bUySCvh6M();

  }

}

//Function of the block bM4s77Wvc (print_debug_info):
void block_bM4s77Wvc(){

  print_debug_info(( to_string(to_double("ma_fast_prev = ")) + DoubleToString(__ma_fast_prev, 2) ));

}

//Function of the block bMgaVnT74 (pause):
void block_bMgaVnT74(){

  pause(1000);

  block_bT8xv0qGj();

}

//Function of the block bO7LNEs4m (print_debug_info):
void block_bO7LNEs4m(){

  print_debug_info(( to_string(to_double("ma_fast = ")) + DoubleToString(__ma_fast, 2) ));

}

//Function of the block bPlXoF1uA (set_complex_variable_value):
void block_bPlXoF1uA(){

  vset(__full_lot, ( __lot * to_double("2") ));

}

//Function of the block bQ4zsFoIh (log):
void block_bQ4zsFoIh(){

  log_to_file("Open long!");

  block_bMgaVnT74();

}

//Function of the block bQMre45Bd (set_complex_variable_value):
void block_bQMre45Bd(){

  vset(__ma_fast_prev, ( moving_average(to_string(__symbol), PERIOD_CURRENT, (int)__fast_ma_period, MODE_SMA, PRICE_CLOSE, 1) ));

  block_bRUr8MnXh();
  block_b1VYatoxs();
  block_b3UJfY74N();
  block_bofgi9HOT();

}

//Function of the block bRUr8MnXh (interface_element_modify):
void block_bRUr8MnXh(){

  modify_text("bj6MtjhZF", DoubleToString(__ma_fast_prev, 2) );

}

//Function of the block bS1JODjZj (print_debug_info):
void block_bS1JODjZj(){

  print_debug_info(( to_string(to_double("ma_slow_prev = ")) + DoubleToString(__ma_slow_prev, 2) ));

}

//Function of the block bT8xv0qGj (buy_signal_sound):
void block_bT8xv0qGj(){

  play_sound("buy_signal");

  block_bPlXoF1uA();

}

//Function of the block bTonyumSN (print_debug_info):
void block_bTonyumSN(){

  print_debug_info(( to_string(to_double("ma_slow = ")) + DoubleToString(__ma_slow, 2) ));

}

//Function of the block bTs8fZtAO (telegram_send_chart_screenshot):
void block_bTs8fZtAO(){

  telegram_send_chart_screenshot(to_string(__symbol), 2160, 720, (int)__admin_id);

}

//Function of the block bUySCvh6M (place_market_order):
void block_bUySCvh6M(){

  place_market_order(to_string(__symbol), "BUY", __full_lot);

  block_bfrp6ajWk();
  block_bjBTLJMym();
  block_boX0sSwri();
  block_bQ4zsFoIh();

}

//Function of the block bWkG0nSQa (telegram_send_message):
void block_bWkG0nSQa(){

  telegram_send_message("Open short!", (int)__admin_id);

}

//Function of the block bX2tY0y68 (terminal_print):
void block_bX2tY0y68(){

  terminal_print("Open short!");

}

//Function of the block bXRrICVna (close_position):
void block_bXRrICVna(){

  close_position(to_string(__symbol));

}

//Function of the block bYGEhpZDM (place_market_order):
void block_bYGEhpZDM(){

  place_market_order(to_string(__symbol), "SELL", __lot);

}

//Function of the block bYUS6GLT0 (set_complex_variable_value):
void block_bYUS6GLT0(){

  vset(__full_lot, ( __lot ));

}

//Function of the block bYi6ikfde (terminal_print):
void block_bYi6ikfde(){

  terminal_print("Робот запущен!");

}

//Function of the block bfrp6ajWk (terminal_print):
void block_bfrp6ajWk(){

  terminal_print("Open long!");

}

//Function of the block biLE3RJAD (sell_signal_sound):
void block_biLE3RJAD(){

  play_sound("sell_signal");

  block_bPlXoF1uA();

}

//Function of the block bjBTLJMym (telegram_send_message):
void block_bjBTLJMym(){

  telegram_send_message("Open long!", (int)__admin_id);

}

//Function of the block boHVNlqnO (set_complex_variable_value):
void block_boHVNlqnO(){

  vset(__ma_slow, ( moving_average(to_string(__symbol), PERIOD_CURRENT, (int)__slow_ma_period, MODE_SMA, PRICE_CLOSE, 0) ));

  block_b0Wkfq6OD();

}

//Function of the block boX0sSwri (telegram_send_chart_screenshot):
void block_boX0sSwri(){

  telegram_send_chart_screenshot(to_string(__symbol), 2160, 720, (int)__admin_id);

}

//Function of the block bofgi9HOT (interface_element_modify):
void block_bofgi9HOT(){

  modify_text("bLcIIkYqO", DoubleToString(__ma_slow, 2) );

}

//Function of the block bugmLdNsU (place_market_order):
void block_bugmLdNsU(){

  place_market_order(to_string(__symbol), "SELL", __full_lot);

  block_bX2tY0y68();
  block_bWkG0nSQa();
  block_bTs8fZtAO();
  block_b3crj4ayK();

}

//Function of the block bvIvs7SMe (condition):
void block_bvIvs7SMe(){

  if (( __ma_fast < __ma_slow ) && ( __ma_fast_prev > __ma_slow_prev ) && ( get_position_info(to_string(__symbol), "POSITION_DIRECTION") != SELL_DIRECTION )){

    block_bugmLdNsU();

  }

}

//Function of the block bzVyOb4tW (pause):
void block_bzVyOb4tW(){

  pause(1000);

  block_biLE3RJAD();

}

Im BotBrains-Editor kann ein solcher Handelsroboter innerhalb von Minuten erstellt werden, während die Code-Generierung Bruchteile von Sekunden dauert.

Verfügbare Blöcke

Es gibt mehr als 140 Blöcke im BotBrains-Editor verfügbar. Nachfolgend finden Sie eine vollständige Tabelle aller verfügbaren Blöcke. Bitte beachten Sie, dass es sehr empfehlenswert ist, die Dokumentation zu lesen, um zu verstehen, wie man den Editor benutzt.

Ereignis-Blöcke:

Block	Beschreibung
Beginn der Roboterarbeit	Der Block wird aktiviert, sobald der Roboter gestartet ist.
Ende der Arbeit des Roboters	Der Block wird aktiviert, sobald der Roboter ausgeschaltet wird.
Änderung der Markttiefe (depth of market)	Der Block wird jedes Mal aktiviert, wenn sich die Markttiefe des angegebenen Symbols ändert.
Neuer Tick	Der Block wird jedes Mal aktiviert, wenn ein neuer Tick für das Symbol im Chart, in dem der Roboter gestartet wurde, empfangen wird.
Änderung des offenen Volumens	Der Block wird jedes Mal aktiviert, wenn sich das offene Volumen für das angegebene Symbol ändert.
Änderung der Limit-Order-Nummer	Der Block wird jedes Mal aktiviert, wenn sich die Anzahl der aktiven Limit-Orders für das angegebene Symbol ändert.
Änderung der Anzahl der Stop-Orders	Der Block wird jedes Mal aktiviert, wenn sich die Anzahl der aktiven Stop-Orders für das angegebene Symbol ändert.
Timer	Der Block wird einmal pro angegebener Anzahl von Sekunden aktiviert.
Tastendruck	Der Block wird aktiviert, wenn die Taste mit dem angegebenen Code gedrückt wird.

Bedingung:

Der "if"-Block wird verwendet, um bestimmte Bedingungen zu prüfen.

Block	Beschreibung
"If"-Block	Dieser Block dient zur Durchführung verschiedener Prüfungen. Dieser Block hat 1 Eingang und 2 Ausgänge.

Schleife:

Der Schleifenblock wird hauptsächlich zur Aufzählung bestimmter Werte verwendet. Der Schleifenblock kann zum Beispiel verwendet werden, um die Liste der aktiven Limit-Orders aufzuzählen.

Block	Beschreibung
Schleife "While"	Der Block wird so lange aktiviert, wie die angegebene Bedingung erfüllt ist.

Trendindikatoren:

Block
Adaptive Moving Average
Average Directional Movement Index (ADX)
Average Directional Movement Index (ADX) von Welles Wilder
Bollinger Bänder
Double Exponential Moving Average
Envelopes
Fractal Adaptive Moving Average
Ichimoku
Gleitender Durchschnitt
Parabolic SAR
Standardabweichung
Triple Exponential Moving Average
Variable Index Dynamic Average

Oszillatoren:

Block
Average True Range
Bears Power
Bulls Power
Chaikin Oszillator
Commodity Channel Index
DeMarker
Force Index
MACD
Momentum
Gleitender Durchschnitt von Oszillatoren
RSI (Relative Strength Index)
Relative Vigor Index
Stochastik Oszillator
TRIX (Triple Exponential Moving Averages Oscillator)
Larry Williams' Percent Range
Accumulation / Distribution
Money Flow Index
On Balance Volume
Volumina

Bill Williams:

Block
Accelerator Oszillator
Alligator
Awesome Oszillator
Fraktale
Gator
Market Facilitation Index

Chart-Analyse:

Abrufen von Informationen über den Chart und einzelne Balken. Zeichnen von vertikalen und horizontalen Linien im Chart.

Block	Beschreibung
Balkeninformationen	Abrufen von Informationen zu einem bestimmten Chart-Balken.
Chart-Informationen	Abrufen von Informationen zu einem bestimmten Chart. Sie können beispielsweise die Anzahl der verfügbaren Balken, die Zeit des ersten verfügbaren Balkens oder die Zeit des letzten Balkens abrufen.
Max price	Ermittelt den Höchstpreis eines Symbols für den angegebenen Zeitraum.
Min price	Ermittelt den Tiefstpreis eines Symbols für den angegebenen Zeitraum.
Average price	Ermittelt den Durchschnittspreis eines Symbols für den angegebenen Zeitraum.
Draw horizontal line	Zeichnet eine horizontale Linie in den Chart eines Symbols.
Draw vertical line	Zeichnet eine vertikale Linie in den Chart eines Symbols.
Remove all lines	Entfernt alle horizontalen und vertikalen Linien aus dem Chart.

Chart-Analyse:

Informationen über die Tiefe des Marktes (depth of market) und seine spezifischen Notierungen erhalten.

Block	Beschreibung
Quote info	Abrufen von Informationen über einen bestimmten Kurs des DOM (depth of market bzw. Markttiefe)
Spread	Ermittelt die Spanne (in Ticks) des DOM für das angegebene Symbol.

Transaktionen:

Platzieren von Markt-, Limit- und Stop-Aufträgen. Entfernen Sie Limit- oder Stop-Aufträge. Positionen schließen.

Block	Beschreibung
Market order	Platzieren eines Marktauftrages.
Limit order	Platzieren einer Limit-Order.
Remove limit order	Eine Limit-Order entfernen
Remove all limit orders	Entfernt alle Limit-Orders für das angegebene Symbol.
Stop order	Platzieren einer Stop-Order.
Remove stop order	Entfernen einer Stop-Order.
Remove all stop orders	Entfernen aller Stop-Orders für das angegebene Symbol.
Close position	Schließen einer Position mit dem angegebenen Symbol.
Close all open positions	Schließen aller vom Roboter geöffneten Positionen.

Variablen:

Block	Beschreibung
Set variable simple value	Der neue Wert der Variable wird durch ein einziges Eingabefeld festgelegt. Das heißt, mit diesem Block können Sie etwas Bestimmtes in die Variable schreiben - einfach eine Zahl oder einen Text.
Set variable complex value	Der neue Wert der Variable wird durch den berechneten Wert bestimmt. Mit diesem Block können Sie zum Beispiel den aktuellen Depotwert oder den aktuellen Kurs des gehandelten Symbols in eine Variable schreiben.
Variable select	Auswahl einer Variablen. Der Block "variable select" kann z.B. innerhalb eines Bedingungsblocks verwendet werden, um den Wert einer Variablen zu überprüfen.

Töne:

Block	Beschreibung
Smooth sound	Abspielen von "Smooth sound"
Alarm	Abspielen von "Alarm"
Buy signal	Abspielen von "Buy signal" (Kaufsignal)
Sell signal	Abspielen von "Sell signal" (Verkaufsignal)

Informationen:

Abrufen von Informationen über das Konto, Positionen, aktive und historische Limit/Stop-Orders, historische Geschäfte. Abrufen von Informationen über die Handelssitzung, Symbolangabe und Uhrzeit.

Block
Account information
Position information
Limit order information
All limit orders information
Stop order information
All stop orders information
History limit order information
History stop order information
History deal information
Trading session information
Symbol information
Time information

Enumerationen:

Enum-Blöcke werden für Aufzählungen verwendet. Sie können zum Beispiel Enum-Blöcke verwenden, um eine Liste von Symbolen oder eine Liste von aktiven Limit-/Stop-Aufträgen aufzulisten.

Block	Beschreibung
Symbolname	Abfrage des Symbolnamens.
Request active orders list	Liste der aktiven Orders abfragen.
Active limit order ticket	Ticketabfrage der aktiven Limit-Order.
Active stop order ticket	Ticketabfrage der aktiven Stop-Order.

Stellen Sie sicher, dass Sie den Block "Request list active orders list" vor der Auflistung der aktiven Aufträge verwenden. Andernfalls würden Sie mit irrelevanten Daten arbeiten.

Historie:

Block	Beschreibung
Request history	Abrufen der Historie für den angegebenen Zeitraum.
History deal ticket	Abrufen der Historie der Deal-Tickets.
History limit order ticket	Abrufen der Historie der Limit-Order-Tickets
History stop order ticket	Abrufen der Stop-Order-Tickets.

Stellen Sie sicher, dass Sie den Block "Request history" aufrufen, bevor Sie die Liste der historischen Orders und Deals erstellen. Andernfalls würden Sie mit irrelevanten Daten arbeiten.

Telegram:

Mit speziellen Blöcken kann Ihr Roboter Nachrichten und Charts-Screenshots direkt an Ihr Telegram senden.

Block	Beschreibung
Send message	Senden Sie eine Telegramnachricht an den Nutzer mit der angegebenen ID.
Send chart screenshot	Sendet einen Chart-Screenshot an den Nutzer mit der angegebenen ID.
New line	Dieser Block wird verwendet, um einen Zeilenumbruch in einer Telegramnachricht zu erstellen.

Andere Blöcke:

Block	Beschreibung
Journal message	Druckt eine Nachricht in das Terminaljournal.
Terminal alert	Einen Hinweis im Terminal erstellen.
Chart comment	Zeigt einen Kommentar zum Chart des angegebenen Symbols an.
Log to file	Erstellt ein Protokoll in der Protokolldatei des Roboters.
Pause	Hält den Roboter für die angegebene Anzahl von Millisekunden an.
Turn the robot off	Abschalten des Roboters
Close terminal	Terminal schließen.

Elemente der Schnittstelle:

Block	Beschreibung
Rechteck	Schnittstellenelement "Rechteck".
Tasten	Schnittstellenelement "Schaltfläche".
Text	Schnittstellenelement "Text".
Value input	Schnittstellenelement "Werteingabe".

Änderungen der Schnittstellenelemente:

Block	Beschreibung
Modify interface element	Ändern einer bestimmten Eigenschaft eines Schnittstellenelements.

Informationen zu Schnittstellenelementen:

Block	Beschreibung
Interface element info	Dieser Block gibt den Wert der angegebenen Eigenschaft des Schnittstellenelementblocks mit der angegebenen ID zurück.

Vordefinierte Konstanten:

Vordefinierte Konstanten sind mögliche Werte für bestimmte Eigenschaften. Zum Beispiel enthält der Block "direction" (Richtung) vordefinierte Konstanten für mögliche Richtungen: buy, sell, no direction (Kauf, Verkauf, keine Richtung).

Block	Beschreibung
Direction	Mögliche Positionsrichtungen (Kauf, Verkauf, keine Richtung).
Deal entry	Mögliche Geschäftseingaben (Einstieg, Ausstieg, Umkehrung, Schließen einer Position durch eine andere)
Deal type	Mögliche Deal-Typen (Kauf, Verkauf, Saldo, Gutschrift, Korrektur, etc.).

Fehlersuche (Debug):

Die Funktion "print debug info" (Debug-Infos drucken) ist vielseitig einsetzbar. Sie wird hauptsächlich verwendet, um die Werte der Variablen und die Werte, die die Blöcke zurückgeben, zu überprüfen.

Block	Beschreibung
Print debug info	Druckt die angegebene Meldung in das Terminaljournal.

Mathematische Operatoren:

Block	Beschreibung
+	Addition
-	Subtraktion
/	Division
*	Multiplikation
√	Wurzel
^	Potenzierung
%	Rest einer Division
(	Öffnende Klammer
)	Schließende Klammer
>	Größer als
<	Kleiner als
>=	Größer oder gleich als
<=	Kleiner oder gleich als

Logische Operatoren:

Block	Beschreibung
AND	Logisches "UND"
OR	Logisches "OR"
NOT	Logisches "NOT"

Teleports:

Block
Teleport IN
Teleport OUT

Variable oder konstante Auswahl:

Block
Variable select
Constant select

Werteingabe:

Block	Beschreibung
Value input	Dieser Block kann verwendet werden, um bestimmte Werte direkt im Schema einzustellen.

Typkonvertierung:

Standardmäßig werden alle Daten als Zahl dargestellt. Mit Typkonvertierungsblöcken können Sie explizit angeben, in welchem Format ein bestimmter Wert dargestellt werden muss.

Block	Beschreibung
Regular string	Konvertiert den Wert in eine reguläre Zeichenkette.
Date and time format string	Konvertiert den Wert in ein Datums- und Zeitformat.
Integer	Konvertiert den Wert in eine ganze Zahl.
Fraction	Wandelt den Wert in einen Bruch um.

Schlussfolgerung

Es hat Monate gedauert, dieses Projekt fertigzustellen. Wenn Sie Ideen oder Vorschläge zur Arbeit des Herausgebers haben, senden Sie bitte eine E-Mail an [e-mail]. Wir werden Ihre Meinung berücksichtigen.