Entwicklung eines Toolkit zur Analyse von Preisaktionen (Teil 11): Heikin Ashi Signal EA

Einführung

Mathematische Formeln dienen als Eckpfeiler der Preisaktionsanalyse und bieten eine objektive Methode zur Entschlüsselung von Marktdaten und zur Anleitung von Handelsentscheidungen. Auf dem südafrikanischen Devisenmarkt könnte ein Händler, der das Paar ZAR/USD bewertet, beispielsweise einen einfachen gleitenden 50-Tage-Durchschnitt verwenden, um Trendumkehrungen zu erkennen, während er die Standardabweichung einsetzt, um die Marktvolatilität zu messen und so potenzielle Ausbrüche zu bestätigen. Die Einbeziehung von Formeln für die Positionsgröße und das Risikomanagement, wie z. B. die Berechnung der Handelsgröße auf der Grundlage eines festgelegten Risikoprozentsatzes und einer Stop-Loss-Distanz, ermöglicht dem Händler ein effektives Risikomanagement und die Festlegung klarer Gewinnziele mithilfe von Tools wie Fibonacci-Retracements.

In diesem Artikel stellen wir Ihnen die Heikin Ashi Technik für Trendumkehrberechnungen vor und fügen damit unserer integrierten Strategie, die quantitative Analysen mit klassischen Preisaktionsmethoden kombiniert, eine weitere Ebene hinzu. Ein wesentlicher Vorteil des Heikin Ashi ist seine Fähigkeit, Marktrauschen herauszufiltern, sodass sich Händler auf den zugrunde liegenden Trend konzentrieren können, ohne sich von geringfügigen Kursschwankungen ablenken zu lassen. Dieser Ansatz gleicht Marktschwankungen aus und stellt sicher, dass die Entscheidungen datengestützt sind, und bietet einen disziplinierten Rahmen, der auf verschiedene Finanzmärkte weltweit anwendbar ist.

Zunächst werden wir Heikin Ashi definieren und seine Ursprünge erforschen. Dann werden wir ohne unnötige Umwege direkt in die Strategie einsteigen, damit Sie genau verstehen, wie sie funktioniert. Wir werden auch andere wichtige Funktionen untersuchen, den vollständigen Code bereitstellen und schließlich die Ergebnisse überprüfen, bevor wir den Artikel abschließen. Werfen wir nun einen Blick auf das Inhaltsverzeichnis.

• Heikin Ashi
• Strategie
• Andere Funktionen
• MQL5 Code
• Ergebnisse
• Schlussfolgerung

Heikin Ashi

Die Heikin Ashi Technik wurde von Munehisa Homma entwickelt, einem japanischen Reishändler aus dem 18. Jahrhundert, der auch als Pionier der Kerzen-Charts gilt, einem grundlegenden Instrument der technischen Analyse. Der aus Japan stammende Heikin Ashi wurde entwickelt, um Händlern zu helfen, eine klarere Perspektive auf Markttrends zu erhalten, indem man sich auf die durchschnittliche Preisbewegung statt auf einzelne Kerzenformationen konzentriert. Im Japanischen bedeutet Heikin „Durchschnitt“ oder „Gleichgewicht“, während Ashi mit „Balken“ oder „Kerze“ übersetzt wird. Diese Namensgebung spiegelt das Grundprinzip der Heikin Ashi Charts wider - die Glättung der Kursdaten, um eine ausgewogenere und weniger volatile Darstellung der Marktbewegungen zu ermöglichen. Das folgende Chart veranschaulicht, wie ein traditionelles Kerzen-Chart in ein glatteres Heikin Ashi Chart umgewandelt wird.

Abb. 1. Geglättetes Chart

Die nachstehende Tabelle vergleicht traditionelle Kerzen und Heikin Ashi Kerzen und hebt ihre wichtigsten Unterschiede hervor.

Merkmal	Traditionelle Kerze	Heikin Ashi Kerze
Berechnungsgrundlage	Verwendet die aktuellen Eröffnungs-, Höchst-, Tiefst- und Schlusskurse.	Verwendet eine modifizierte Formel zur Mittelung von Preisdaten.
Volatilitätsanzeige	Zeigt reale Preisschwankungen und Lücken.	Glättet das Kursgeschehen und reduziert das Rauschen.
Klarheit des Trends	Kann bewegt sein, mit abwechselnd roten und grünen Kerzen auch in Trends.	Sorgt für gleichmäßigere Trends mit weniger Farbveränderungen.
Sichtbarkeit der Lücke	Zeigt Kurslücken zwischen Kerzen.	Aufgrund der Mittelungsformel sind nur selten Lücken zu erkennen.
Umkehrsignale	Zeigt schnelle Umkehrsignale und Dochte.	Umkehrungen sind langsamer, aber stärker, wenn sie bestätigt werden.
Preisdarstellung	Spiegelt die tatsächlichen Marktpreise wider.	Durchschnittspreise, d. h. der letzte Preis entspricht nicht dem tatsächlichen Marktpreis.

Strategie

Diese Strategie basiert auf vier Hauptfunktionen im MQL5 EA: Heikin Ashi Berechnung, Trendbestätigung, Identifizierung von Umkehrsignalen und Signalbestätigung mittels RSI. Im Folgenden werden sie im Einzelnen erläutert.

Berechnung des Heikin Ashi

Heikin Ashi Charts werden anhand von vier wichtigen Datenpunkten erstellt: Eröffnungs-, Höchst-, Tiefst- und Schlusskurs für jeden Zeitraum. Diese Werte werden verarbeitet, um Heikin Ashi Kerzen zu generieren, die sich von traditionellen Kerzen unterscheiden. Heikin Ashi Kerzen spiegeln nicht das reine Kursgeschehen wider, sondern verwenden gemittelte Kursberechnungen, bei denen die Eröffnungs- und Schlusskurse sowie die Höchst- und Tiefstkurse gemischt werden, um eine flüssigere Darstellung der Markttrends zu erhalten. 

Dieser Glättungseffekt minimiert die Auswirkungen plötzlicher Preisschwankungen, reduziert das Marktrauschen und macht Trends leichter erkennbar. Infolgedessen weisen Heikin Ashi Kerzen oft kleinere Körper und längere Dochte auf, die die Marktdynamik hervorheben und gleichzeitig die kurzfristige Volatilität herausfiltern. Zur Umsetzung der Heikin Ashi Strategie zeigt das folgende Flussdiagramm, wie traditionelle Kerzen-Daten in ein glattes, trendorientiertes Heikin Ashi Chart umgewandelt werden. Dieses Verfahren filtert Marktgeräusche heraus und ermöglicht einen klareren Blick auf den vorherrschenden Trend. Im Folgenden wird Schritt für Schritt erklärt, wie das funktioniert:

Abb. 2. Flussdiagramm

Das Flussdiagramm veranschaulicht, wie traditionelle OHLC-Daten in Heikin Ashi Kerzen umgewandelt werden. Der Prozess beginnt mit rohen Marktdaten, die dann durch Berechnung eines Durchschnitts für den Schlusskurs (haClose) geglättet werden. Der Eröffnungskurs (haOpen) wird anhand der Werte der vorherigen Kerze ermittelt, um Kontinuität zu schaffen, während haHigh und haLow sicherstellen, dass die Kerze die gesamte Bandbreite der Kursbewegungen widerspiegelt. Das Ergebnis ist eine Kerze, die die kurzfristige Volatilität reduziert und die allgemeinen Trends besser sichtbar macht. Nachfolgend finden Sie den MQL5-Codeausschnitt für die Funktion, die Heikin Ashi Kerzen berechnet.

void CalculateHeikinAshi()
{
   MqlRates rates[];
   int copied = CopyRates(_Symbol, _Period, 0, Bars(_Symbol, _Period), rates);

   if(copied < TrendCandles + 2)
   {
      Print("Failed to copy rates. Copied: ", copied);
      return;
   }

   ArraySetAsSeries(rates, true);

   // Resize arrays to match the number of copied bars
   ArrayResize(haClose, copied);
   ArrayResize(haOpen, copied);
   ArrayResize(haHigh, copied);
   ArrayResize(haLow, copied);

   // Calculate Heikin-Ashi values for each bar
   for(int i = copied - 1; i >= 0; i--)
   {
      haClose[i] = (rates[i].open + rates[i].high + rates[i].low + rates[i].close) / 4.0;
      haOpen[i] = (i == copied - 1) ? (rates[i].open + rates[i].close) / 2.0
                                   : (haOpen[i + 1] + haClose[i + 1]) / 2.0;
      haHigh[i] = MathMax(rates[i].high, MathMax(haOpen[i], haClose[i]));
      haLow[i] = MathMin(rates[i].low, MathMin(haOpen[i], haClose[i]));
   }

   Print("Heikin-Ashi Calculation Complete");
}

Das Ergebnis ist eine Reihe von Heikin Ashi Kerzen, die einen Großteil des Marktrauschens herausfiltern, sodass der zugrunde liegende Trend deutlicher zu erkennen ist.

Trendbestätigung

Bevor er versucht, Umkehrsignale zu erkennen, führt der EA eine Trendbestätigung durch, um sicherzustellen, dass eine starke Richtungsbewegung vorliegt. Dabei wird eine bestimmte Anzahl aufeinanderfolgender Heikin Ashi Kerzen analysiert. Bei einem Aufwärtstrend prüft der EA, ob der haClose-Wert jeder Kerze höher ist als der der nachfolgenden Kerze, während er bei einem Abwärtstrend prüft, ob die haClose-Werte aufeinanderfolgend niedriger sind. Die Anzahl der Kerzen, die zur Bestätigung des Trends erforderlich sind, wird durch Eingabeparameter gesteuert, sodass nur gut etablierte Trends berücksichtigt werden. Diese strenge Prüfung minimiert das Risiko von Fehlsignalen, indem sie bestätigt, dass sich der Markt in einem eindeutigen Trend befindet, bevor sie zur Erkennung einer Umkehrung übergeht.

int consecutive = 0;
for(int i = 2; i <= TrendCandles + 1; i++)
{
   if((haClose[i] > haClose[i + 1] && isBullish) || (haClose[i] < haClose[i + 1] && !isBullish))
      consecutive++;
   else
      break;
}
if(consecutive < ConsecutiveCandles)
   return false;

Dieser Schritt stellt sicher, dass ein Signal nur dann berücksichtigt wird, wenn es eindeutige Hinweise auf einen anhaltenden Trend gibt, wodurch die Wahrscheinlichkeit von Fehlsignalen aufgrund zufälliger Marktschwankungen verringert wird.

Identifizierung des Umkehrsignals

Nach der Bestätigung eines etablierten Trends geht der EA dazu über, potenzielle Umkehrsignale zu identifizieren, indem er die Struktur der nächsten Heikin Ashi Kerze genau untersucht. In dieser Phase berechnet der EA den Kerzenkörper als absolute Differenz zwischen haClose und haOpen, und er misst den Schatten auf der Grundlage der Interessensrichtung, wobei er sich auf den unteren Schatten für eine Umkehr nach oben und den oberen Schatten für eine Umkehr nach unten konzentriert. Eine wichtige Bedingung ist, dass das Verhältnis zwischen dem Schatten und dem Körper einen bestimmten Schwellenwert überschreiten muss. Dieses hohe Verhältnis von Schatten zu Körper deutet darauf hin, dass der Markt den vorherrschenden Trend stark abgelehnt hat, was durch einen langen Docht im Verhältnis zu einem kleinen Körper belegt wird. Ein solches Muster ist ein zuverlässiger Indikator dafür, dass eine Trendwende im Gange sein könnte.

// Check for a strong reversal candlestick
double body = MathAbs(haClose[1] - haOpen[1]);
double shadow = (direction > 0) ? MathAbs(haLow[1] - haOpen[1])
                                : MathAbs(haHigh[1] - haOpen[1]);

// Avoid division by zero and confirm shadow-to-body ratio
if(body == 0.0 || (shadow / body) < ShadowToBodyRatio)
   return false;

Bei diesem Schritt werden schwache oder mehrdeutige Signale herausgefiltert, indem ein starkes Umkehrmerkmal in der Kerzenstruktur verlangt wird, bevor man fortfährt.

Signalbestätigung mit RSI

Der letzte Schritt der Strategie besteht darin, das Umkehrsignal mit Hilfe des Relative Strength Index (RSI) zu bestätigen, was eine zusätzliche Validierungsebene darstellt. Sobald ein potenzieller Umschwung anhand der Heikin Ashi Kriterien identifiziert wurde, ruft der EA den letzten RSI-Wert ab, um das Marktmomentum zu bewerten. Für ein Umkehrsignal nach oben muss der RSI unter einer bestimmten Kaufschwelle liegen, was darauf hindeutet, dass der Vermögenswert überverkauft ist; umgekehrt muss der RSI für eine Umkehr nach unten eine bestimmte Verkaufsschwelle überschreiten, was darauf hindeutet, dass der Vermögenswert überkauft ist. Nur wenn sowohl das Heikin Ashi Muster als auch die RSI-Bedingung erfüllt sind, generiert der EA ein Handelssignal, indem er beispielsweise einen Kauf- oder Verkaufspfeil auf dem Chart zeichnet. Dieser doppelte Bestätigungsansatz trägt dazu bei, Fehlsignale zu reduzieren, und stellt sicher, dass nur dann gehandelt wird, wenn mehrere Indikatoren eine Marktumkehr bestätigen.

// Get RSI Value
double rsiValue;
if(!GetRSIValue(rsiValue))
{
   Print("Failed to retrieve RSI value.");
   return;
}

// Detect potential reversals with RSI confirmation
if(DetectReversal(true) && rsiValue < RSI_Buy_Threshold)  // Bullish reversal with RSI confirmation
{
   DrawArrow("BuyArrow", iTime(NULL, 0, 0), SymbolInfoDouble(_Symbol, SYMBOL_BID), 233, BuyArrowColor);
   Print("Bullish Reversal Detected - RSI:", rsiValue);
}
else if(DetectReversal(false) && rsiValue > RSI_Sell_Threshold)  // Bearish reversal with RSI confirmation
{
   DrawArrow("SellArrow", iTime(NULL, 0, 0), SymbolInfoDouble(_Symbol, SYMBOL_ASK), 234, SellArrowColor);
   Print("Bearish Reversal Detected - RSI:", rsiValue);
}

Die RSI-Bestätigung fügt eine weitere Ebene der Momentum-Analyse hinzu. Durch die Kombination von Price Action (Heikin Ashi) und Momentum (RSI) verbessert der EA die Zuverlässigkeit der Signale und stellt sicher, dass nur dann gehandelt wird, wenn mehrere Indikatoren übereinstimmen.

Andere Funktionen

Eingabeparameter

Bevor wir in die Kernlogik eintauchen, müssen wir eine Reihe von Eingabeparametern definieren, die es uns ermöglichen, das Verhalten des EA fein abzustimmen. Mit diesen Parametern lassen sich Trendbestätigungsregeln, Umkehrbedingungen, Volumenschwellen, RSI-Einstellungen und die Signalvisualisierung steuern, ohne den Code zu verändern.

input int TrendCandles = 3;                 // Number of candles for trend detection
input double ShadowToBodyRatio = 1.5;       // Shadow-to-body ratio for reversal detection
input int ConsecutiveCandles = 2;           // Consecutive candles to confirm trend
input int RSI_Period = 14;                  // RSI Period
input double RSI_Buy_Threshold = 34.0;      // RSI level for buy confirmation
input double RSI_Sell_Threshold = 65.0;     // RSI level for sell confirmation
input color BuyArrowColor = clrGreen;       // Buy signal color
input color SellArrowColor = clrRed;        // Sell signal color

Diese Parameter geben uns die Kontrolle über wichtige Aspekte der Strategie. Die Einstellung TrendCandles legt fest, wie viele Kerzen des Heikin Ashi wir bei der Identifizierung von Trends berücksichtigen. ShadowToBodyRatio stellt sicher, dass wir nur starke Kerzen für eine Umkehr berücksichtigen. ConsecutiveCandles filtert schwache Trends heraus, indem mindestens zwei Kerzen zur Bestätigung einer Richtung erforderlich sind. RSI_Buy_Threshold und RSI_Sell_Threshold fügen eine weitere Ebene der Bestätigung durch den RSI hinzu. BuyArrowColor und SellArrowColor ermöglichen es uns, die Darstellung der Signale im Chart anzupassen.

Globale Variablen

Um sicherzustellen, dass unsere Berechnungen effizient ablaufen, deklarieren wir globale Arrays zum Speichern von Heikin Ashi Werten sowie ein Handle für den RSI-Indikator.

double haClose[], haOpen[], haHigh[], haLow[];
int rsiHandle;

Wir verwenden diese Variablen, um die berechneten Heikin Ashi Werte zu speichern und die RSI-Werte dynamisch in unserem EA abzurufen.

Initialisierung (OnInit)

Wenn wir den EA mit dem Chart verbinden, wird zuerst die Funktion OnInit() ausgeführt. Es richtet unsere Heikin Ashi Arrays ein und initialisiert den RSI-Indikator.

int OnInit()
{
   ArraySetAsSeries(haClose, true);
   ArraySetAsSeries(haOpen, true);
   ArraySetAsSeries(haHigh, true);
   ArraySetAsSeries(haLow, true);

   if(Bars(_Symbol, _Period) < TrendCandles + 2)
   {
      Print("Not enough bars for initialization.");
      return INIT_FAILED;
   }

   rsiHandle = iRSI(_Symbol, _Period, RSI_Period, PRICE_CLOSE);
   if(rsiHandle == INVALID_HANDLE)
   {
      Print("Failed to create RSI indicator.");
      return INIT_FAILED;
   }

   Print("EA Initialized Successfully");
   return INIT_SUCCEEDED;
}

Hier setzen wir unsere Arrays in umgekehrter Reihenfolge, sodass die letzte Kerze immer bei Index 0 steht. Wir prüfen, ob genügend Balken vorhanden sind, bevor wir Berechnungen durchführen. Wir initialisieren den RSI-Indikator und behandeln eventuelle Fehler, falls er fehlschlägt. Wenn alles korrekt eingerichtet ist, gibt der EA eine Bestätigungsmeldung aus und beginnt mit der Ausführung.

Tick-Verarbeitung (OnTick)

Diese Funktion wird bei jedem neuen Preistick ausgeführt, um sicherzustellen, dass wir den Markt kontinuierlich analysieren und potenzielle Handelssignale identifizieren.

void OnTick()
{
   if(Bars(_Symbol, _Period) < TrendCandles + 2)
   {
      Print("Not enough bars for tick processing.");
      return;
   }

   CalculateHeikinAshi();

   double rsiValue;
   if(!GetRSIValue(rsiValue))
   {
      Print("Failed to retrieve RSI value.");
      return;
   }

   if(DetectReversal(true) && rsiValue < RSI_Buy_Threshold)
   {
      DrawArrow("BuyArrow", iTime(NULL, 0, 0), SymbolInfoDouble(_Symbol, SYMBOL_BID), 233, BuyArrowColor);
      Print("Bullish Reversal Detected - RSI:", rsiValue);
   }
   else if(DetectReversal(false) && rsiValue > RSI_Sell_Threshold)
   {
      DrawArrow("SellArrow", iTime(NULL, 0, 0), SymbolInfoDouble(_Symbol, SYMBOL_ASK), 234, SellArrowColor);
      Print("Bearish Reversal Detected - RSI:", rsiValue);
   }
}

Wir generieren für jeden Pfeil einen eindeutigen Namen, der auf dem Zeitstempel des Signals basiert. Wenn ein bestehender Pfeil mit demselben Namen gefunden wird, löschen wir ihn, um Unordnung zu vermeiden. Dann erstellen wir ein neues Pfeilobjekt und legen seine Eigenschaften fest (Farbe, Größe und Typ). Bei Erfolg wird eine Meldung gedruckt, die bestätigt, dass der Pfeil platziert wurde.

Bereinigung bei Deinitialisierung (OnDeinit)

Wenn wir den EA aus dem Chart entfernen, müssen wir die Indikatorressourcen freigeben, um Speicherprobleme zu vermeiden.

void OnDeinit(const int reason)
{
   if(rsiHandle != INVALID_HANDLE)
      IndicatorRelease(rsiHandle);
}

Diese Funktion stellt sicher, dass der RSI-Indikator ordnungsgemäß entfernt wird, wenn der EA aufhört zu laufen.

MQL5 Code

//+------------------------------------------------------------------+
//|                                        Heikin Ashi Signal EA.mq5 |
//|                              Copyright 2025, Christian Benjamin. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Christian Benjamin."
#property link      "https://www.mql5.com/en/users/lynnchris"
#property version   "1.00"
#property strict

//--- Input parameters
input int TrendCandles = 3;                 // Number of candles for trend detection
input double ShadowToBodyRatio = 1.5;       // Shadow-to-body ratio for reversal detection
input int ConsecutiveCandles = 2;           // Consecutive candles to confirm trend
input int RSI_Period = 14;                  // RSI Period
input double RSI_Buy_Threshold = 34.0;      // RSI level for buy confirmation
input double RSI_Sell_Threshold = 65.0;     // RSI level for sell confirmation
input color BuyArrowColor = clrGreen;       // Buy signal color
input color SellArrowColor = clrRed;        // Sell signal color

//--- Global variables
double haClose[], haOpen[], haHigh[], haLow[];
int rsiHandle;

//+------------------------------------------------------------------+
//| Expert initialization                                            |
//+------------------------------------------------------------------+
int OnInit()
  {
   ArraySetAsSeries(haClose, true);
   ArraySetAsSeries(haOpen, true);
   ArraySetAsSeries(haHigh, true);
   ArraySetAsSeries(haLow, true);

   if(Bars(_Symbol, _Period) < TrendCandles + 2)
     {
      Print("Not enough bars for initialization.");
      return INIT_FAILED;
     }

// Initialize RSI indicator
   rsiHandle = iRSI(_Symbol, _Period, RSI_Period, PRICE_CLOSE);
   if(rsiHandle == INVALID_HANDLE)
     {
      Print("Failed to create RSI indicator.");
      return INIT_FAILED;
     }

   Print("EA Initialized Successfully");
   return INIT_SUCCEEDED;
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   if(Bars(_Symbol, _Period) < TrendCandles + 2)
     {
      Print("Not enough bars for tick processing.");
      return;
     }

// Calculate Heikin-Ashi
   CalculateHeikinAshi();

// Get RSI Value
   double rsiValue;
   if(!GetRSIValue(rsiValue))
     {
      Print("Failed to retrieve RSI value.");
      return;
     }

// Detect potential reversals with RSI confirmation
   if(DetectReversal(true) && rsiValue < RSI_Buy_Threshold)  // Bullish reversal with RSI confirmation
     {
      DrawArrow("BuyArrow", iTime(NULL, 0, 0), SymbolInfoDouble(_Symbol, SYMBOL_BID), 233, BuyArrowColor);
      Print("Bullish Reversal Detected - RSI:", rsiValue);
     }
   else
      if(DetectReversal(false) && rsiValue > RSI_Sell_Threshold)  // Bearish reversal with RSI confirmation
        {
         DrawArrow("SellArrow", iTime(NULL, 0, 0), SymbolInfoDouble(_Symbol, SYMBOL_ASK), 234, SellArrowColor);
         Print("Bearish Reversal Detected - RSI:", rsiValue);
        }
  }

//+------------------------------------------------------------------+
//| Calculate Heikin-Ashi                                            |
//+------------------------------------------------------------------+
void CalculateHeikinAshi()
  {
   MqlRates rates[];
   int copied = CopyRates(_Symbol, _Period, 0, Bars(_Symbol, _Period), rates);

   if(copied < TrendCandles + 2)
     {
      Print("Failed to copy rates. Copied: ", copied);
      return;
     }

   ArraySetAsSeries(rates, true);

// Resize arrays to match the number of copied bars
   ArrayResize(haClose, copied);
   ArrayResize(haOpen, copied);
   ArrayResize(haHigh, copied);
   ArrayResize(haLow, copied);

// Calculate Heikin-Ashi
   for(int i = copied - 1; i >= 0; i--)
     {
      haClose[i] = (rates[i].open + rates[i].high + rates[i].low + rates[i].close) / 4.0;
      haOpen[i] = (i == copied - 1) ? (rates[i].open + rates[i].close) / 2.0 : (haOpen[i + 1] + haClose[i + 1]) / 2.0;
      haHigh[i] = MathMax(rates[i].high, MathMax(haOpen[i], haClose[i]));
      haLow[i] = MathMin(rates[i].low, MathMin(haOpen[i], haClose[i]));
     }

   Print("Heikin-Ashi Calculation Complete");
  }

//+------------------------------------------------------------------+
//| Detect Reversals with Trend Confirmation                         |
//+------------------------------------------------------------------+
bool DetectReversal(bool isBullish)
  {
   int direction = isBullish ? 1 : -1;

// Confirm trend location: Check for consecutive candles in the same direction
   int consecutive = 0;
   for(int i = 2; i <= TrendCandles + 1; i++)
     {
      if((haClose[i] > haClose[i + 1] && isBullish) || (haClose[i] < haClose[i + 1] && !isBullish))
         consecutive++;
      else
         break;
     }
   if(consecutive < ConsecutiveCandles)
      return false;

// Check for a strong reversal candlestick
   double body = MathAbs(haClose[1] - haOpen[1]);
   double shadow = (direction > 0) ? MathAbs(haLow[1] - haOpen[1]) : MathAbs(haHigh[1] - haOpen[1]);

// Avoid division by zero and confirm shadow-to-body ratio
   if(body == 0.0 || (shadow / body) < ShadowToBodyRatio)
      return false;

// Confirm the reversal with the next candlestick (opposite direction)
   return ((haClose[0] - haOpen[0]) * direction < 0);
  }

//+------------------------------------------------------------------+
//| Get RSI Value                                                    |
//+------------------------------------------------------------------+
bool GetRSIValue(double &rsiValue)
  {
   double rsiBuffer[];
   if(CopyBuffer(rsiHandle, 0, 0, 1, rsiBuffer) > 0)
     {
      rsiValue = rsiBuffer[0];
      return true;
     }
   return false;
  }

//+------------------------------------------------------------------+
//| Draw Arrow                                                       |
//+------------------------------------------------------------------+
void DrawArrow(string name, datetime time, double price, int code, color clr)
  {
   name += "_" + IntegerToString(time);
   if(ObjectFind(0, name) != -1)
      ObjectDelete(0, name);

   if(ObjectCreate(0, name, OBJ_ARROW, 0, time, price))
     {
      ObjectSetInteger(0, name, OBJPROP_ARROWCODE, code);
      ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
      ObjectSetInteger(0, name, OBJPROP_WIDTH, 2);
      Print("Arrow Drawn: ", name, " at ", price);
     }
   else
     {
      Print("Failed to create arrow: ", GetLastError());
     }
  }

//+------------------------------------------------------------------+
//| Expert deinitialization                                          |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   if(rsiHandle != INVALID_HANDLE)
      IndicatorRelease(rsiHandle);
  }
//+------------------------------------------------------------------+

Ergebnisse

In meinem Testprozess habe ich sowohl den Backtest als auch Live-Markttests verwendet, um die Leistung des EAs zu bewerten.

• Backtests

Ich habe den EA mit historischen Daten getestet, um seine grundsätzliche Funktionsfähigkeit zu überprüfen und seine Stärken und Schwächen aufzudecken. Diese Phase bestätigt, dass der Ansatz unter bekannten Marktbedingungen funktioniert, obwohl er reale Faktoren wie Slippage oder variable Spreads nicht vollständig nachbilden kann. Werfen wir einen Blick auf das folgende GIF.

Abb. 3. V100 Index Backtest

Nachfolgend habe ich zusätzliche Backtest-Ergebnisse für drei verschiedene Paare über einen Zeitraum von 27 Tagen präsentiert, um die Signalgenauigkeit zu bewerten. Ein Signal galt als erfolgreich, wenn der Markt nach der Bestätigung seine Richtung änderte.

• EURUSD

Signal	Total	Erfolg	% Genauigkeit
Kaufen (buy)	20	17	85%
Verkaufen (sell)	10	8	80%

• Crash 900 Index

Signal	Total	Erfolg	% Genauigkeit
Kaufen (buy)	18	14	77.8%
Verkaufen (sell)	25	15	60%

• Step Index

Signal	Total	Erfolg	% Genauigkeit
Kaufen (buy)	18	15	83.3.%
Verkaufen (sell)	22	14	63.6%

Der EA hat sich als äußerst effektiv erwiesen, da er bei den getesteten Paaren eine Genauigkeit von mindestens 77,8 % bei Kaufsignalen und mindestens 60 % bei Verkaufssignalen erreichte.

• Live-Markttests

Live-Tests gaben Aufschluss über die Leistung des EA unter aktuellen Marktbedingungen. Diese Echtzeitbewertung zeigte, wie gut der EA mit Marktvolatilität und Ausführungsproblemen umgehen kann. Angesichts der damit verbundenen Risiken habe ich mit einer kleinen Allokation begonnen, um das Risiko zu kontrollieren.

Abb. 4. V25 Index Live Markttest

Wichtigste Erkenntnisse

Backtest validiert die Strategie in der Theorie, während Live-Tests ihre praktische Leistung demonstrieren. Beide Phasen sind entscheidend, um den EA zu verfeinern und sicherzustellen, dass er robust genug für den realen Handel ist.

Schlussfolgerung

Die Heikin Ashi Technik ist besonders effektiv bei der Filterung von Marktschwankungen. Ich habe es auch als nützlich für die Identifizierung von Marktumkehrpunkten empfunden. Nachdem ich es wie jedes andere Instrument getestet hatte, stellte ich fest, dass es effizienter arbeitet, wenn es zusammen mit anderen Strategien eingesetzt wird. Es ist wichtig, mit den Code-Eingaben zu experimentieren und auf einem Demokonto oder durch Backtestzu testen, bis Sie die beste Performance nach Ihren Wünschen erzielen. Ihre Vorschläge sind sehr willkommen.

Datum	Name des Werkzeugs	Beschreibung	Version	Aktualisierungen	Hinweis
01/10/24	Chart Projector	Skript zur Überlagerung der Kursentwicklung des Vortages mit Geistereffekt.	1.0	Erste Veröffentlichung	Erstes Werkzeug in Lynnchris Tool Chest
18/11/24	Analytical Comment	Er liefert Informationen zum Vortag in Tabellenform und nimmt die zukünftige Marktentwicklung vorweg.	1.0	Erste Veröffentlichung	Zweites Werkzeug in Lynnchris Tool Chest
27/11/24	Analytics Master	Regelmäßige Aktualisierung der Marktmetriken alle zwei Stunden.	1.01	Zweite Veröffentlichung	Drittes Werkzeug in Lynnchris Tool Chest
02/12/24	Analytics Forecaster	Regelmäßige Aktualisierung der Marktmetriken alle zwei Stunden mit Telegram-Integration.	1.1	Dritte Auflage	Werkzeug Nummer 4
09/12/24	Volatility Navigator	Der EA analysiert die Marktbedingungen anhand der Indikatoren Bollinger Bands, RSI und ATR.	1.0	Erste Veröffentlichung	Werkzeug Nummer 5
19/12/24	Mean Reversion Signal Reaper	Analysiert den Markt anhand der Strategie „Umkehr zur Mitte“ und liefert Signale.	1.0	Erste Veröffentlichung	Werkzeug Nummer 6
9/01/25	Signal-Impuls	Analysator für mehrere Zeitrahmen.	1.0	Erste Veröffentlichung	Werkzeug Nummer 7
17/01/25	Metrics Board	Bedienfeld mit Taste für die Analyse.	1.0	Erste Veröffentlichung	Werkzeug Nummer 8
21/01/25	External Flow	Analytik durch externe Bibliotheken.	1.0	Erste Veröffentlichung	Werkzeug Nummer 9
27/01/25	VWAP	Volumen Gewichteter Durchschnittspreis	1.3	Erste Veröffentlichung	Werkzeug Nummer 10
02/02/25	Heikin Ashi Signal EA	Trendglättung und Identifizierung von Umkehrsignalen	1.0	Erste Veröffentlichung	Werkzeug Nummer 11