Wie Smart-Money-Konzepte (SMC) zusammen mit dem Fibonacci-Indikator einen optimalen Handelseinstieg signalisieren.

Einführung

Smart Money Konzepte (SMC) und Orderblöcke sind kritische Bereiche auf dem Chart, in denen institutionelle Händler in der Regel große Kauf- oder Verkaufsaufträge ausführen. Diese Zonen markieren häufig den Ursprung bedeutender Kursbewegungen und sind daher für Händler, die ihre Strategien auf das institutionelle Marktgeschehen abstimmen wollen, von entscheidender Bedeutung. Wenn man versteht, wie diese Schlüsselniveaus das Kursgeschehen beeinflussen, können Kleinhändler einen tieferen Einblick in die zugrunde liegende Marktdynamik gewinnen und so sehr wahrscheinliche Bewegungen vorhersehen.

In Kombination mit Tools wie dem Fibonacci-Retracement können Händler ihre Einstiegsstrategien weiter verfeinern. Das Fibonacci-Retracement identifiziert potenzielle Pullback-Niveaus zwischen einem kürzlichen Swing-Hoch und einem Swing-Tief und bietet eine Möglichkeit zu messen, wie weit der Preis zurückgehen kann, bevor er seinen Trend fortsetzt. Dieser Ansatz hilft den Händlern, optimale Einstiegspunkte zu finden, indem er den institutionellen Auftragsfluss mit den Bereichen des Marktinteresses in Einklang bringt und so die Präzision ihrer Geschäfte erhöht.

Expertenlogik

Orderblock zum Kaufen:

Ein Orderblock (OB) zum Kaufen kann auf den Charts erkannt werden, wenn auf eine Abwärtskerze eine Aufwärtskerze folgt, die die vorherige Abwärtskerze verschlingt und den Beginn eines signifikanten Abwärts-Momentums markiert. Damit die Formation als Orderblock zum Kaufen eingestuft werden kann, müssen die auf die Abwärtskerze folgenden Kerzen aus mindestens zwei Aufwärtskerze oder einer Reihe von Aufwärtskerzen bestehen. Der richtige Ansatz für den Handel mit einem Orderblock zum Kaufen besteht darin, abzuwarten, bis der Kurs zurückgeht und wieder in die identifizierte Zone des Orderblocks zum Kaufen eintaucht; erst dann kann eine Kaufposition ausgeführt werden.

Aufwärts Fibonacci Retracement:

Um einen optimalen Handelseinstieg zu finden, nachdem ein Orderblock zum Kaufen identifiziert wurde, wird das Fibonacci-Retracement-Tool verwendet. Sobald der Orderblock zum Kaufen gefunden ist, sucht der Händler nach dem jüngsten Swing-Hoch und Swing-Tief, die mit dem Orderblock verbunden sind. Das Fibonacci-Retracement wird dann vom Swing-Tief zum Swing-Hoch auf dem Chart eingezeichnet. Das Retracement bestätigt, dass der Orderblock zum Kaufen bei oder unter der 61,8%-Marke liegt, einer wichtigen Retracement-Zone, die auf eine potenzielle Kaufgelegenheit im Einklang mit dem institutionellen Auftragsfluss hinweist.

Orderblock zum Verkaufen:

Ein Orderblock zum Verkaufen wird identifiziert, wenn auf eine Aufwärtskerze eine Abwärtskerze folgt, die die vorherige Aufwärtskerze verschlingt und den Beginn eines signifikanten Abwärts-Momentums signalisiert. Damit das Muster als Orderblock zum Verkaufen betrachtet werden kann, müssen mindestens zwei Abwärtskerze oder eine Reihe von Abwärtskerzen auf die Aufwärtskerze folgen. Die richtige Art und Weise, mit einem Orderblock zum Verkaufen zu handeln, besteht darin, zu warten, bis der Kurs zurückkehrt und die Zone des Orderblock zum Verkaufens erneut testet, wo dann eine Verkaufsposition ausgeführt werden kann.

Abwärts Fibonacci Retracement:

Bei einem Order-Block zum Verkaufen wird das Fibonacci-Retracement-Tool verwendet, um optimale Handelseinträge zu finden. Nachdem der Händler den Orderblock zum Verkaufen identifiziert hat, sucht er nach dem jüngsten Swing-Hoch und Swing-Tief. In diesem Fall wird das Fibonacci-Retracement vom Swing-Hoch zum Swing-Tief gezogen, da der Schwerpunkt auf einem Verkaufsauftrag liegt. Das Retracement bestätigt, dass der Orderblock zum Verkaufen bei oder über der 61,8%-Marke liegt, was einen wahrscheinlichen Einstiegspunkt für eine Verkaufsposition darstellt.

Erste Schritte

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

#include  <Trade/Trade.mqh>
CTrade trade;

#define BullOB clrLime
#define BearOB clrRed

„# include <Trade/Trade.mqh>“ Diese Zeile enthält die MQL5 Bibliothek Trade, die integrierte Funktionen zur Verwaltung von Handelsgeschäften, Aufträgen und Positionen bietet. Die Datei „Trade.mqh“ enthält vordefinierte Klassen und Funktionen, die Handelsoperationen wie Öffnen, Schließen und Ändern von Aufträgen vereinfachen. Wir erstellen eine Instanz von „CTrade“ mit dem Namen „trade“. Die Klasse „CTrade“ kapselt Handelsoperationen (wie z.B. das Erteilen von Kauf-/Verkaufsaufträgen, das Schließen von Positionen und das Ändern von Abschlüssen). Durch die Erstellung dieses Objekts können Sie Handelsgeschäfte mit objektorientierten Methoden in Ihrem Expert Advisor (EA) einfach verwalten.

Dann definieren wir zwei Konstanten für die Farben, die wir zur Visualisierung von Orderblock zum Kaufen und Orderblock zum Verkaufen verwenden werden. „BullOB“ wird die Farbe „clrLime“ (grün) für Kauf-Orderblöcke zugewiesen, was auf Bereiche hinweist, in denen Käufer in den Markt eingetreten sein könnten. „BearOB“ erhält die Farbe „clrRed“ (rot) für Verkaufs-Orderblöcke, was auf Bereiche hinweist, in denen Verkäufer in den Markt eingetreten sein könnten.

//+------------------------------------------------------------------+
//|                           Global vars                            |
//+------------------------------------------------------------------+
double Lots = 0.01;
int takeProfit = 170;
//int stopLoss = 200;
int length = 100;

input double stopLoss = 350;
input double Mgtn = 00.85;

bool isBullishOB = false; 
bool isBearishOB = false;

input int Time1Hstrt = 3;
input int Time1Hend = 4;

„isBullishOB“ und „isBearishOB“ sind die booleschen Flags, die wir verwenden, um die Erkennung von Orderblöcken (OB) zu verfolgen. Zu den globalen Variablen gehören die Eingabeparameter „Time1Hstrt“ und „Time2Hend“ für die Zeiteinstellungen. „Time1Hstrt“ steht für die Anfangsstunde eines bestimmten Handelsfensters, in unserem Fall für die New Yorker Handelssitzung. Time1Hend“ steht für die Endstunde dieses Zeitfensters.

class COrderBlock : public CObject {
public:
   int direction;
   datetime time;//[]
   double high;
   double low;
   
   void draw(datetime tmS, datetime tmE, color clr){
      string objOB = " OB REC" + TimeToString(time);
      ObjectCreate( 0, objOB, OBJ_RECTANGLE, 0, time, low, tmS, high);
      ObjectSetInteger( 0, objOB, OBJPROP_FILL, true);
      ObjectSetInteger( 0, objOB, OBJPROP_COLOR, clr);
      
      string objtrade = " OB trade" + TimeToString(time);
      ObjectCreate( 0, objtrade, OBJ_RECTANGLE, 0, tmS, high, tmE, low); // trnary operator
      ObjectSetInteger( 0, objtrade, OBJPROP_FILL, true);
      ObjectSetInteger( 0, objtrade, OBJPROP_COLOR, clr);
   }  
};

Wir definieren eine Klasse namens „OrderBlock“, die wir zur Modellierung eines Orderblocks (OB) im Handelschart verwenden werden. Er enthält Eigenschaften für die Richtung des Orderblocks, die Zeit, die Höchst- und Tiefstwerte sowie eine Methode („draw“) zum Zeichnen des Orderblocks auf dem Chart. Die Klasse „COrderBlock“ erbt von der Basisklasse „CObject“, einer Allzweckklasse in MQL5, die zur Erstellung von Objekten verwendet wird. Dadurch erhält „COrderblock“ Zugang zu den Methoden und Eigenschaften von „CObject“.

Die Mitgliedsvariablen (Eigenschaften) „direction“ ein int-Datentyp, der die Richtung des Auftragsblocks angibt. Wir verwenden ihn, um anzuzeigen, ob der Auftragsblock Aufwärts (up ist 1) oder Abwärts (down ist -1) ist. „time“ Gibt die Zeit an, zu der der Orderblock gebildet oder entdeckt wurde. Er enthält den Zeitstempel des Orderblock-Ereignisses. „high“ steht für den Höchstpreis des Auftragsblocks (die obere Grenze der Zone). „low“ Stellt den niedrigen Preis des Orderblocks dar (die untere Grenze der Zone). Diese vier Variablen sind die Hauptmerkmale eines Auftragsblocks (OB).

Anschließend wird eine String-Variable „objOB“ erstellt, die den eindeutigen Namen des Rechteckobjekts enthält, das den Auftragsblock im Chart darstellt. Der Name wird aus dem Präfix „OB REC“ in Verbindung mit der Uhrzeit des Auftragsblocks generiert (mit „TimeToString()“ in einen String umgewandelt). ObjectCreate()“ Diese Funktion erzeugt ein Rechteck-Objekt („OBJ-RECTANGLE“) auf dem Chart. Die Chart-ID „0“ (0 bedeutet das aktuelle Chart) und „objOB“ ist der Name des Rechteckobjekts. time, „low“ Die Koordinaten für die linke untere Ecke des Rechtecks (der Beginn des Orderblocks auf der Zeitachse und das Preisniveau des Low). tmS, „high“ Die Koordinaten für die rechte obere Ecke des Rechtecks (die Endzeit und das Preisniveau des High).

COrderBlock* OB;
color OBClr;
datetime T1;
datetime T2;

• „COrderBlock* OB“: Ein Zeiger auf ein „Orderblock“-Objekt, das wir zum Verwalten und Zeichnen von Orderblöcken im Chart verwenden werden.
• „color OBClr“:  Eine Variable, die die Farbe enthält, die für den Orderblock verwendet werden soll, je nachdem, ob ein auf- oder ein abwärts Orderblock erkannt wurde.
• „datetime T1“: Eine Variable, die die Startzeit des Auftragsblocks angibt.
• „datetime T2“: Eine Variable, die die Endzeit des Auftragsblocks angibt.

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit(){
   trade.SetExpertMagicNumber(MagicNumber);

   return(INIT_SUCCEEDED);
}

Die Funktion „OnInit()“ wird aufgerufen, wenn der EA zum ersten Mal in einen Chart geladen wird. Wir stellen einfach die magische Zahl des Expert Advisors ein, die einfach eine eindeutige Kennung für die vom EA getätigten Geschäfte ist.

const int len = 5;
int left_bars, right_bars;
int bar_Now = len;
bool isSwingH = true, isSwingL = true;

• „len“: Legt die Anzahl der Balken (Kerzen) links und rechts fest, die bei der Bestimmung, ob ein Balken ein Swing-Punkt ist, berücksichtigt werden.
• „left-bars, right-bars“: In diesen Variablen werden die Indizes des linken und rechten Balkens relativ zum aktuellen Balken (bar-Now) gespeichert.
• „bar-Now = len“: Der aktuell analysierte Takt wird auf len gesetzt (in diesem Fall 5 Takte zurück).
• „isSwingH, isSwingL“: Diese booleschen Variablen werden auf „true“ initialisiert und werden verwendet, um zu prüfen, ob der aktuelle Bar ein Swing High oder Swing Low ist.

for(int i = 1; i <= len; i++){
   right_bars = bar_Now - i;
   left_bars = bar_Now + i;

Die „for“-Schleife durchläuft den Bereich der Balken (len = 5) und analysiert sowohl die linke als auch die rechte Seite des aktuellen Balkens (bar-Now).

• „right-bars = bar-Now - i“: Bezieht sich auf die Balken, die rechts vom aktuellen Balken liegen.
• „left-bars = bar-Now + i“: Bezieht sich auf die Balken, die links vom aktuellen Balken liegen.

if((getHigh(bar_Now) <= getHigh(right_bars)) ||(getHigh(bar_Now) < getHigh(left_bars))){
   isSwingH = false;
}

Diese Bedingung prüft, ob der Höchststand des aktuellen Balkens (bar-Now) kleiner oder gleich dem Höchststand der umliegenden Balken (sowohl links als auch rechts) ist. Wenn ein Balken auf einer der beiden Seiten ein höheres oder gleiches Hoch hat, dann ist der aktuelle Balken kein Swing-Hoch, und „isSwingH“ wird auf „false“ gesetzt.

if((getLow(bar_Now) >= getLow(right_bars)) || getLow(bar_Now) > getLow(left_bars)){
   isSwingL = false;
}

Ähnlich wie bei der Swing-High-Logik wird bei dieser Bedingung geprüft, ob das Tief des aktuellen Balkens größer oder gleich dem Tief der umliegenden Balken ist. Wenn ein Balken auf einer der beiden Seiten ein niedrigeres oder gleiches Tief hat, dann ist der aktuelle Balken kein Swing-Tief, und „isSwingL“ wird auf false gesetzt.

if(isSwingH){
   Print("We have a swing high at index: ", bar_Now, "at price: ", getHigh(bar_Now));
   fib_high = getHigh(bar_Now);
   fib_t1 = getTime(bar_Now);
}

Wenn „isSwingH“ wahr bleibt, bedeutet dies, dass ein Swing-Hoch gefunden wurde. Die Funktion gibt den Bar-Index und den Swing-Preis aus. „fib-high“ und „fib-t1“ sind globale Variablen, die den Höchstkurs und die entsprechende Zeit speichern. Diese Werte werden als Parameter an das FIBO-Objekt übergeben.

if(isSwingL){
   Print("We have a swing low at index: ", bar_Now," at price: ", getLow(bar_Now));
   fib_low = getLow(bar_Now);
   fib_t2 = getTime(bar_Now);
}

Ähnlich verhält es sich mit der Erkennung eines Swing-Lows: Die Variable „isSwingL“ bleibt wahr, wenn ein Swing-Low erkannt wird. Die Funktion gibt den Balkenindex und den Tiefstkurs aus. „fib-low“ und „fib-t2“ speichern den Tiefstkurs und die Zeit. Diese Werte werden als Parameter an das FIBO-Objekt übergeben.

//+------------------------------------------------------------------+
//|                      Function to find OB                         |
//+------------------------------------------------------------------+
void getOrderB(){

   static int prevDay = 0;
   
   MqlDateTime structTime;
   TimeCurrent(structTime);
   structTime.min = 0;
   structTime.sec = 0;
   
   structTime.hour = Time1Hstrt;
   datetime timestrt = StructToTime(structTime);
   
   structTime.hour = Time1Hend;
   datetime timend = StructToTime(structTime);

   if(TimeCurrent() >= timestrt && TimeCurrent() < timend){
      if(prevDay != structTime.day_of_year){
         delete OB;
         
         for(int i = 1; i < 100; i++){
            if(getOpen(i) < getClose(i)){ // index is i since the loop starts from i which is = 1 "for(int i = 1)..."
               if(getOpen(i + 2) < getClose(i + 2)){
                  if(getOpen(i + 3) > getClose(i + 3) && getOpen(i + 3) < getClose(i + 2)){
                     Print("Bullish Order Block confirmed at: ", TimeToString(getTime(i + 2), TIME_DATE||TIME_MINUTES));
                     //isBullishOB = true;
                     OB = new COrderBlock();
                     OB.direction = 1;
                     OB.time = getTime(i + 3);
                     OB.high = getHigh(i + 3);
                     OB.low = getLow(i + 3);
                     isBullishOB = true;
                     
                     OBClr = isBullishOB ? BullOB : BearOB;
                     
                     // specify strt time
                     T1 = OB.time;
                     
                     // reset BULL OB flag
                     isBullishOB = false;
                     prevDay = structTime.day_of_year;
                     break;
                     
                     delete OB;
                  }
               }
            }
            if(getOpen(i) > getClose(i)){
               if(getOpen(i + 2) > getClose(i + 2)){
                  if(getOpen(i + 3) < getClose(i + 3) && getOpen(i + 3) < getClose(i + 2)){
                     Print("Bearish Order Block confirmed at: ", TimeToString(getTime(i + 2), TIME_DATE||TIME_MINUTES));
                     //isBearishOB = true;
                     OB = new COrderBlock();
                     OB.direction = -1;
                     OB.time = getTime(i + 3);
                     OB.high = getHigh(i + 3);
                     OB.low = getLow(i + 3);
                     isBearishOB = true;
                     
                     OBClr = isBearishOB ? BearOB : BullOB;
                     
                     T1 = OB.time;
                     
                     // reset the BEAR OB flag
                     isBearishOB = false;
                     prevDay = structTime.day_of_year;
                     break;
                     
                     delete OB;
                  }
               }
            }
         }
      }
   }
}

Die Funktion sucht nach einem auf- oder abwärts Oder Block in den Kursdaten innerhalb einer bestimmten Zeitspanne (in diesem Fall von „Time1Hstrt“ bis „Time1end“). Sobald er identifiziert ist, erstellt er ein Orderblock-Objekt (OrderBlock) mit relevanten Attributen wie Richtung, Zeit, Höchst- und Tiefstpreis. Anschließend werden die Farben und Flags für die Visualisierung und Verarbeitung festgelegt. „prevDay“ ist eine statische Variable, die ihre Werte zwischen den Funktionsaufrufen beibehält. Dadurch wird sichergestellt, dass die Auftragssperre nur einmal pro Tag erkannt wird.

Wenn die Funktion den aktuellen Tag („prevDay“) bereits verarbeitet hat, überspringt sie die Erkennung, um eine Neuberechnung der Auftragsblöcke zu vermeiden. Sie wird zurückgesetzt, sobald der Tag wechselt. Die Funktion prüft die Kursentwicklung auf Auf- und Abwärts-Orderblockmuster.

• Bedingungen: Er sucht nach einer Reihe von Kerzen, die ein Aufwärts-Muster bilden. Die erste Kerze ist eine Aufwärtskerze (der Eröffnungskurs ist niedriger als der Schlusskurs). Die zweite Kerze ist ebenfalls eine Aufwärtskerze und bestätigt dies. Die dritte Kerze ist eine Abwärtskerze, aber ihr Eröffnungskurs ist niedriger als der Schlusskurs der zweiten Kerze.
• Wenn alle Bedingungen erfüllt sind, wird ein Orderblock zum Kaufen bestätigt.
• Ein neues „OrderBlock“-Objekt wird mit den Eigenschaften Richtung (Aufwärts), Zeit, Höchst- und Tiefstpreis erstellt.
• Eine ähnliche Logik gilt für einen Orderblock zum Verkaufen. Die erste Kerze ist eine Abwärtskerze (der Eröffnungskurs ist höher als der Schlusskurs). Die zweite Kerze ist ebenfalls eine Abwärtskerze und bestätigt dies. Die dritte Kerze ist eine Aufwärtskerze, aber ihr Eröffnungskurs ist niedriger als der Schlusskurs der zweiten Kerze.
• Wenn die Bedingungen erfüllt sind, wird ein Orderblock zum Verkaufen bestätigt.
• Nach der Verarbeitung wird das Objekt „OB“ gelöscht, um Speicherplatz freizugeben.
• „pervDay“ wird aktualisiert, um sicherzustellen, dass die Funktion nur einmal pro Tag ausgeführt wird.

bool isNewBar() {
   // Memorize the time of opening of the last bar in the static variable
   static datetime last_time = 0;
   
   // Get current time
   datetime lastbar_time = (datetime)SeriesInfoInteger(Symbol(), Period(), SERIES_LASTBAR_DATE);

   // First call
   if (last_time == 0) {
      last_time = lastbar_time;
      return false;
   }

   // If the time differs (new bar)
   if (last_time != lastbar_time) {
      last_time = lastbar_time;
      return true;
   }

   // If no new bar, return false
   return false;
}

Diese Funktion prüft, ob ein neuer Balken im Chart erschienen ist, um einige Funktionen einmal pro Balken auszuführen.

double getHigh(int index) {
    return iHigh(_Symbol, _Period, index);
}

double getLow(int index) {
    return iLow(_Symbol, _Period, index);
}

double getOpen(int index){
   return iOpen(_Symbol, _Period, index);
}

double getClose(int index){
   return iClose(_Symbol, _Period, index);
}

datetime getTime(int index) {
    return iTime(_Symbol, _Period, index);
}

Dieser Abschnitt des Codes bietet eine Reihe von Dienstfunktionen, um spezifische Preisdaten und Zeitinformationen für einen bestimmten Balken (oder Kerzen) mit dem angegebenen Index abzurufen. Jede Funktion greift auf den jeweiligen Preis oder Zeitwert für ein Symbol und einen Zeitraum zu, indem sie eingebaute MQL5-Funktionen wie „iHigh()“, „iLow()“, „iOpen()“, „iClose()“ und „iTime()“ verwendet.

void OnTick(){
    if(isNewBar()){
      getOrderB();
      getSwings();
      
      double Bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
      double Ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
      
      if(CheckPointer(OB) != POINTER_INVALID  && OB.direction > 0 && Ask < OB.high){
         double entry = Ask;
         double tp = getHigh(iHighest(_Symbol, PERIOD_CURRENT, MODE_HIGH, iBarShift(_Symbol, PERIOD_CURRENT, OB.time)));
         double sl = NormalizeDouble(OB.low - Mgtn, _Digits);
        // double sl = getLow(iLowest(_Symbol, PERIOD_CURRENT, MODE_LOW, 2,iBarShift(_Symbol, PERIOD_CURRENT, OB.time)));
         
         ObjectCreate( 0, FIBO_OBJ, OBJ_FIBO, 0, fib_t1, fib_low, fib_t2, fib_high);
         double entLvl = fib_high - (fib_high - fib_low) * Fib_Trade_lvls / 100; // check this if non
         
         if(OB.high <= entLvl){
            T2  = getTime(0);
            OB.draw(T1, T2, OBClr);
            trade.Buy(Lots, _Symbol, entry, sl, tp, "OB buy");
            delete OB;
         }else{
            delete OB;
         }        
      }

      if(CheckPointer(OB) != POINTER_INVALID && OB.direction < 0 && Bid > OB.low){
         double entry = Bid;
         double tp = getLow(iLowest(_Symbol, PERIOD_CURRENT, MODE_LOW, iBarShift(_Symbol, PERIOD_CURRENT, OB.time)));
         double sl = NormalizeDouble(OB.high + Mgtn, _Digits);
        // double sl = getHigh(iHighest(_Symbol, PERIOD_CURRENT, MODE_HIGH, iBarShift(_Symbol, PERIOD_CURRENT, OB.time)));
         
         ObjectCreate( 0, FIBO_OBJ, OBJ_FIBO, 0, fib_t2, fib_high, fib_t1, fib_low);
         double entLvl = fib_low + (fib_low - fib_high) * Fib_Trade_lvls / 100;
         
         if(OB.low >= entLvl){
            T2 = getTime(0);
            OB.draw(T1, T2, OBClr);
            trade.Sell(Lots, _Symbol, entry, sl, tp, "OB sell");
            delete OB;
         }else{
            delete OB;
         }         
      }
      
      ObjectSetInteger( 0, FIBO_OBJ, OBJPROP_COLOR, clrBlack);
      for(int i = 0; i < ObjectGetInteger( 0, FIBO_OBJ, OBJPROP_LEVELS); i++){
         ObjectSetInteger( 0, FIBO_OBJ, OBJPROP_LEVELCOLOR, i, clrBlack);
      }
    }   
}

Da die Funktion „OnTick()“ jedes Mal ausgeführt wird, wenn ein neuer Tick (Preisaktualisierung) auftritt, verwenden wir die Funktion „isNewBar()“, um zu prüfen, ob ein neuer Balken gebildet wurde. Die Funktion „getOrderB()“ identifiziert potenzielle Auf- und Abwärts-Orderblöcke (Zonen, in denen institutionelle Händler große Kauf-/Verkaufsaufträge platzieren). Die Funktion „getSwing()“ identifiziert die Swing-Punkte (Höchst- und Tiefstwerte) in der Kursbewegung, die zum Zeichnen der Fibonacci-Retracement-Levels verwendet werden.

Wenn die Auftragssperre erkannt wurde und der Kurs in die Zone der Auftragssperre zurückgeht, prüfen wir zunächst, ob der aktuelle Kurs innerhalb dieser Zone liegt. Wenn dies der Fall ist, überprüfen wir, ob der Preis mit dem 61,8 % Fibonacci-Retracement-Level übereinstimmt, um das Setup zu bestätigen. Dieses Niveau ist von entscheidender Bedeutung, da es bei institutionellen Handelsstrategien häufig einen starken Umkehrpunkt signalisiert. Nur wenn beide Bedingungen erfüllt sind - Preis innerhalb des Orderblocks und Übereinstimmung mit dem 61,8% Fibonacci-Retracement - führen wir eine Position aus (Kauf oder Verkauf). Andernfalls, wenn eine der beiden Bedingungen nicht erfüllt ist, löschen wir einfach den Auftragsblock und vermeiden es, den Handel einzugehen.

Orderblock zum Kaufen wenn bestätigt:

Orderblock zum Verkaufen wenn bestätigt:

Die Logik des Systems basiert auf der Abhängigkeit zwischen dem Orderblock und den Fibonacci-Retracement-Levels. Wenn ein Orderblock erkannt wird, prüft das System, ob er mit dem 61,8%-Fibonacci-Retracement-Level übereinstimmt. Für einen Orderblock zum Kaufen muss der Kurs unter das 61,8%-Retracement-Niveau fallen, während er für einen Orderblock zum Verkaufen über dem 61,8%-Niveau liegen muss. Wenn der Orderblock diese Fibonacci-Bedingungen nicht erfüllt, wird keine Handelsposition ausgeführt. Das Fibonacci-Objekt wird jedoch weiterhin auf dem Chart eingezeichnet, um das Retracement-Level zu visualisieren und dem Händler zu helfen, das potenzielle Setup zu überwachen, ohne eine Position einzugehen, bis die richtigen Bedingungen erfüllt sind.

Schlussfolgerung

Zusammenfassend lässt sich sagen, dass wir wichtige Konzepte der technischen Analyse wie Orderblöcke, Swing Highs/Lows und Fibonacci-Retracement integriert haben, um Handelsentscheidungen zu automatisieren. Wir haben Funktionen entwickelt, um Auf- und Abwärts-Orderblöcke zu erkennen, die Bereiche darstellen, in denen institutionelle Händler typischerweise große Kauf- oder Verkaufsorders platzieren. Durch die Einbeziehung von Fibonacci-Levels bestätigt der EA vor der Ausführung von Trades, ob der Preisrückgang mit Zonen hoher Wahrscheinlichkeit übereinstimmt. Die Funktion „OnTick()“ überwacht den Markt kontinuierlich auf neue Ticks und prüft, ob die Bedingungen für die Eröffnung von Positionen erfüllt sind. Dabei werden automatisch Einstiegs-, Stop-Loss- und Take-Profit-Levels auf der Grundlage von Echtzeitkursen festgelegt.

Zusammenfassend lässt sich sagen, dass dieser Expert Advisor Privatanlegern dabei helfen soll, ihre Geschäfte mit dem institutionellen Orderflow abzustimmen und ihnen einen systematischen Ansatz für die Eingabe von Geschäften mit hoher Wahrscheinlichkeit zu bieten. Durch das Erkennen und Reagieren auf wichtige Marktstrukturen wie Orderblöcke und Preisrückgänge ermöglicht der EA Händlern, auf eine Art und Weise zu handeln, die die strategischen Schritte großer Finanzinstitute widerspiegelt. Diese Abstimmung kann die Genauigkeit des Handels verbessern, emotionale Entscheidungen reduzieren und letztlich die Rentabilität für Einzelhändler erhöhen.