Indikatoren: MACD Divergence

Stephen Paul 2020.05.05 08:39 #41

Alain Verleyen:

Sie haben den Punkt verpasst. Der Beitrag, den Sie beziehen sich auf war über WIE das Signal von einem EA zu bekommen, können Sie offensichtlich nicht haben, indem Sie nur die letzten 2 Kerzen Werte, Sie brauchen die dritte.

Es ist NICHT möglich, ein frühes Signal zu haben, denn um eine Divergenz zu erkennen, brauchen Sie einen Peak/Trough und dafür brauchen Sie eine zusätzliche Kerze, die SCHLIESSEN. Wenn also Kerze 0 gerade geöffnet hat, bedeutet das, dass Kerze 1 geschlossen ist, und das erlaubt es, den Peak/Trough bei Kerze 2 zu bestätigen. Wenn jemand den Indikator so modifizieren möchte, dass er unbestätigte Hochs/Tiefs verwendet, um ein frühes Signal zu erhalten, kann man das tun, aber ich werde nicht dabei helfen, weil es eine schlechte Idee ist, da man eine Menge schlechter Signale erhalten wird.

Was getan werden könnte, ist das Signal auf Kerze 1 oder sogar Kerze 0 zu zeichnen, aber das wird nichts ändern, und ich beschloss, das Signal auf die Kerze zu zeichnen, die tatsächlich den Peak/Trough zeigen.

Ich habe den Code geändert und Sie haben Recht. Man erhält falsche Bewegungen vor der eigentlichen Divergenz. Vielen Dank für Ihre Zeit in dieser Sache.

bk7 2021.01.16 16:31 #42

Alain Verleyen:

Sie haben den Punkt verpasst. Der Beitrag, den Sie beziehen sich auf war über WIE das Signal von einem EA zu bekommen, können Sie offensichtlich nicht haben, indem Sie nur die letzten 2 Kerzen Werte, Sie brauchen die dritte.

Es ist NICHT möglich, ein frühes Signal zu haben, denn um eine Divergenz zu erkennen, brauchen Sie einen Peak/Trough und dafür brauchen Sie eine zusätzliche Kerze, die SCHLIESSEN. Wenn also Kerze 0 gerade geöffnet hat, bedeutet das, dass Kerze 1 geschlossen ist, und das erlaubt es, den Peak/Trough bei Kerze 2 zu bestätigen. Wenn jemand den Indikator so modifizieren möchte, dass er unbestätigte Hochs/Tiefs verwendet, um ein frühes Signal zu erhalten, kann man das tun, aber ich werde nicht dabei helfen, weil es eine schlechte Idee ist, da man eine Menge schlechter Signale erhalten wird.

Was getan werden könnte, ist das Signal auf Kerze 1 oder sogar Kerze 0 zu zeichnen, aber das wird nichts ändern, und ich beschloss, das Signal auf die Kerze zu zeichnen, die tatsächlich den Peak/Trough zeigen.

Sie haben vielleicht auch einen Punkt übersehen.

Im Falle von Renko-Charts ist der aktuelle Balken (meistens) bereits geschlossen, so dass Sie eine Kerze weniger benötigen würden. Oder habe ich etwas übersehen?

Hristo 2021.04.06 23:07 #43

Hallo Alain, sehr guter Indikator, der auch ohne Anpassung der Einstellungen gut funktioniert. Es ist gut, dass es die Alerts hat, aber das Einzige, was mir fehlt, ist die Möglichkeit, Push-Benachrichtigungen an mein Telefon zu senden. Die gleiche Nachricht, die auf der Pop-up-Benachrichtigung erscheint, um sie an mein Telefon zu senden. Könnten Sie diese Funktion hinzufügen? Das wäre sehr nett von Ihnen.

Indikatoren: Fibo Pivots Jede Anfängerfrage, um das Push-Benachrichtigungen kommen mit einer

Zeke Yaeger 2021.04.12 05:14 #44

Danke Alain, das ist ein hervorragender Indikator

Vladimir Karputov 2021.09.12 13:50 #45

Forum zum Thema Handel, automatische Handelssysteme und Testen von Handelsstrategien

macd divegence

ENEZA PETER MKIRAMWENI, 2021.09.12 12:26

hallo helfen Sie mir mit diesem Indikator es Alarm nach drei bar ich will Alarm sofort nach 1 bar anzeigen

//+------------------------------------------------------------------+
//|MACD_Divergenz.mq5 |
//|Alain Verleyen |
//| http://www.alamga.be |
//+------------------------------------------------------------------+
#property copyright     "Alain Verleyen (mql5) - Original author FX5 (mql4)"
#property link          "http://codebase.mql4.com/1115"
#property version       "1.01"
#property description   "The original indicator was totally rewrite to improve performance and"
#property description   "to correct a little bug. Also it's more funny that simply converting it."

#property indicator_separate_window
#property indicator_buffers 4
#property indicator_plots   4

//--- Plot 1 : Bullisch 
#property indicator_type1   DRAW_ARROW
#property indicator_color1  clrGreen
#property indicator_label1  "Bullish divergence"
//--- Plot 2: Baisse
#property indicator_type2   DRAW_ARROW
#property indicator_color2  clrRed
#property indicator_label2  "Bearish divergence"
//--- Diagramm 3: MACD Haupt
#property indicator_type3   DRAW_LINE
#property indicator_style3  STYLE_SOLID
#property indicator_width3   2
#property indicator_color3  clrMagenta
#property indicator_label3  "Main"
//--- Abbildung 4: MACD-Signal
#property indicator_type4   DRAW_LINE
#property indicator_style4  STYLE_SOLID
#property indicator_width4   1
#property indicator_color4  clrNONE
#property indicator_label4  "Signal"
//--- Eingabeparameter
input string s1="-----------------------------------------------";      ----------- MACD-Einstellungen ----------------------
input int    fastEMA                 = 12;
input int    slowEMA                 = 26;
input int    signalSMA               = 9;
input string s2="-----------------------------------------------";      ----------- Indikatoreinstellungen -----------------
input bool   drawIndicatorTrendLines = true;
input bool   drawPriceTrendLines     = true;
input bool   displayAlert            = true;
//--- Konstanten
#define  OBJECT_PREFIX       "MACD_DivergenceLine"
#define  ARROWS_DISPLACEMENT 0.0001
//--- Puffer
double bullishDivergence[];
double bearishDivergence[];
double macdBuffer[];
double signalBuffer[];
//--- Griffe
int    macdHandle=INVALID_HANDLE;
//--- Globale Variablen
static datetime lastAlertTime;
//+------------------------------------------------------------------+
//| Benutzerdefinierte Initialisierungsfunktion für Indikatoren |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Indikatorgriff 
   macdHandle=iMACD(NULL,0,fastEMA,slowEMA,signalSMA,PRICE_CLOSE);
   if(macdHandle==INVALID_HANDLE)
     {
      Print("The iMACD handle is not created: Error ",GetLastError());
      return(INIT_FAILED);
     }
//--- Zuordnung von Indikatorpuffern
   SetIndexBuffer(0,bullishDivergence);
   SetIndexBuffer(1,bearishDivergence);
   SetIndexBuffer(2,macdBuffer);
   SetIndexBuffer(3,signalBuffer);
//--- Pfeilcode siehe http://www.mql5.com/en/docs/constants/objectconstants/wingdings
   PlotIndexSetInteger(0,PLOT_ARROW,233);
   PlotIndexSetInteger(1,PLOT_ARROW,234);
//--- Indikatoreigenschaften
   string indicatorName=StringFormat("MACD_Divergence(%i, %i, %i)",fastEMA,slowEMA,signalSMA);
   PlotIndexSetInteger(3,PLOT_DRAW_BEGIN,signalSMA);
   IndicatorSetInteger(INDICATOR_DIGITS,_Digits+2);
   IndicatorSetString(INDICATOR_SHORTNAME,indicatorName);
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Reinigung der Karte|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   ObjectDeleteByName("MACD_DivergenceLine");
  }
//+------------------------------------------------------------------+
//| Benutzerdefinierte Indikator-Iterationsfunktion|
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//--- Der Indikator wird nur bei einer neuen Kerze aktualisiert, außer bei einem Total Redraw
   static datetime lastCandleTime=0;
   if(lastCandleTime==time[rates_total-1])
      return(rates_total);
   else
      lastCandleTime=time[rates_total-1];
//--- erste Berechnung oder Anzahl der Balken wurde geändert
   int start;
   if(prev_calculated<=0)
     {
      start=slowEMA;
      ArrayInitialize(bullishDivergence,EMPTY_VALUE);   // Divergenzpuffer müssen initialisiert werden
      ArrayInitialize(bearishDivergence,EMPTY_VALUE);
     }
   else
     {
      start=prev_calculated-2;
      bullishDivergence[rates_total-1]=EMPTY_VALUE;
      bearishDivergence[rates_total-1]=EMPTY_VALUE;
     }
//--- Anzahl der zu kopierenden Daten (Macd-Puffer) 
   int toCopy=rates_total-prev_calculated+(prev_calculated<=0 ? 0 : 1);
//--- nicht alle Daten können berechnet werden
   int calculated=BarsCalculated(macdHandle);
   if(calculated<rates_total)
     {
      Print("Not all data of macdHandle is calculated (",calculated,"bars ). Error",GetLastError());
      return(0);
     }
//--- Haupt-MACD-Puffer abrufen
   if(IsStopped()) return(0); //Prüfung auf Stop-Flag
   if(CopyBuffer(macdHandle,MAIN_LINE,0,toCopy,macdBuffer)<=0)
     {
      Print("Getting MACD Main is failed! Error : ",GetLastError());
      return(0);
     }
//--- Signal MACD-Puffer abrufen
   if(IsStopped()) return(0); //Prüfung auf Stop-Flag
   if(CopyBuffer(macdHandle,SIGNAL_LINE,0,toCopy,signalBuffer)<=0)
     {
      Print("Getting MACD Signal is failed! Error : ",GetLastError());
      return(0);
     }
//--- Hauptschleife der Berechnungen
   for(int shift=start; shift<rates_total-2; shift++)
     {
      int currentExtremum,lastExtremum;
      bool isBullishDivergence,isBearishDivergence;
      string divergenceMsg;
      ENUM_LINE_STYLE divergenceStyle=0;

      //--- Bullische Divergenz einfangen
      isBullishDivergence=false;

      if(macdBuffer[shift]<=macdBuffer[shift-1] && 
         macdBuffer[shift]<macdBuffer[shift-2] && 
         macdBuffer[shift]<macdBuffer[shift+1])
         //--- wenn der aktuelle macd main ein Tiefpunkt ist (niedriger als 2 vorherige und 1 nächste)
        {
         currentExtremum=shift;
         lastExtremum=GetIndicatorLastTrough(shift);
         //--- 
         if(macdBuffer[currentExtremum]>macdBuffer[lastExtremum] && 
            low[currentExtremum]<low[lastExtremum])
           {
            isBullishDivergence=true;
            divergenceMsg="Classical bullish divergence on: ";
            divergenceStyle=STYLE_SOLID;
           }
         //--- 
         if(macdBuffer[currentExtremum]<macdBuffer[lastExtremum] && 
            low[currentExtremum]>low[lastExtremum])
           {
            isBullishDivergence=true;
            divergenceMsg="Reverse bullish divergence on: ";
            divergenceStyle=STYLE_DOT;
           }
         //--- Bullische Divergenz gefunden
         if(isBullishDivergence)
           {
            bullishDivergence[currentExtremum]=macdBuffer[currentExtremum]-ARROWS_DISPLACEMENT;
            //---
            if(drawPriceTrendLines==true)
               DrawTrendLine(TRENDLINE_MAIN,time[currentExtremum],time[lastExtremum],low[currentExtremum],low[lastExtremum],Green,divergenceStyle);
            //---
            if(drawIndicatorTrendLines==true)
               DrawTrendLine(TRENDLINE_INDICATOR,time[currentExtremum],time[lastExtremum],macdBuffer[currentExtremum],macdBuffer[lastExtremum],Green,divergenceStyle);
            //---
            if(displayAlert==true && shift>=rates_total-3 && time[currentExtremum]!=lastAlertTime)
               DisplayAlert(divergenceMsg,time[currentExtremum]);
           }
        }
      //--- Fangen Sie die bärische Divergenz
      isBearishDivergence=false;

      if(macdBuffer[shift]>=macdBuffer[shift-1] && 
         macdBuffer[shift]>macdBuffer[shift-2] && 
         macdBuffer[shift]>macdBuffer[shift+1])
         //--- wenn der aktuelle macd main ein Top ist (höher als 2 vorherige und 1 nächste)
        {
         currentExtremum=shift;
         lastExtremum=GetIndicatorLastPeak(shift);
         //--- 
         if(macdBuffer[currentExtremum]<macdBuffer[lastExtremum] && 
            high[currentExtremum]>high[lastExtremum])
           {
            isBearishDivergence=true;
            divergenceMsg="Classical bearish divergence on: ";
            divergenceStyle=STYLE_SOLID;
           }
         if(macdBuffer[currentExtremum]>macdBuffer[lastExtremum] && 
            high[currentExtremum]<high[lastExtremum])
           {
            isBearishDivergence=true;
            divergenceMsg="Reverse bearish divergence on: ";
            divergenceStyle=STYLE_DOT;
           }
         //--- Bärenhafte Divergenz wird festgestellt
         if(isBearishDivergence)
           {
            bearishDivergence[currentExtremum]=macdBuffer[currentExtremum]+ARROWS_DISPLACEMENT;
            //---
            if(drawPriceTrendLines==true)
               DrawTrendLine(TRENDLINE_MAIN,time[currentExtremum],time[lastExtremum],high[currentExtremum],high[lastExtremum],Red,STYLE_SOLID);
            //---
            if(drawIndicatorTrendLines==true)
               DrawTrendLine(TRENDLINE_INDICATOR,time[currentExtremum],time[lastExtremum],macdBuffer[currentExtremum],macdBuffer[lastExtremum],Red,STYLE_SOLID);
            //---
            if(displayAlert==true && shift>=rates_total-3 && time[currentExtremum]!=lastAlertTime)
               DisplayAlert(divergenceMsg,time[currentExtremum]);
           }
        }
     }
//--- Rückgabewert von prev_calculated für den nächsten Aufruf
   return(rates_total);
  }
//+------------------------------------------------------------------+
//| Letzte Mulde suchen|
//+------------------------------------------------------------------+
int GetIndicatorLastTrough(int shift)
  {
   for(int i=shift-5; i>=2; i--)
     {
      if(signalBuffer[i] <= signalBuffer[i-1] && signalBuffer[i] <= signalBuffer[i-2] &&
         signalBuffer[i] <= signalBuffer[i+1] && signalBuffer[i] <= signalBuffer[i+2])
        {
         for(int j=i; j>=2; j--)
           {
            if(macdBuffer[j] <= macdBuffer[j-1] && macdBuffer[j] < macdBuffer[j-2] &&
               macdBuffer[j] <= macdBuffer[j+1] && macdBuffer[j] < macdBuffer[j+2])
               return(j);
           }
        }
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Suche nach letztem Peak|
//+------------------------------------------------------------------+
int GetIndicatorLastPeak(int shift)
  {
   for(int i=shift-5; i>=2; i--)
     {
      if(signalBuffer[i] >= signalBuffer[i-1] && signalBuffer[i] >= signalBuffer[i-2] &&
         signalBuffer[i] >= signalBuffer[i+1] && signalBuffer[i] >= signalBuffer[i+2])
        {
         for(int j=i; j>=2; j--)
           {
            if(macdBuffer[j] >= macdBuffer[j-1] && macdBuffer[j] > macdBuffer[j-2] &&
               macdBuffer[j] >= macdBuffer[j+1] && macdBuffer[j] > macdBuffer[j+2])
               return(j);
           }
        }
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| ENUM_TRENDLINE_TYPE verwendet von DrawTrendLine |
//+------------------------------------------------------------------+
enum ENUM_TRENDLINE_TYPE
  {
   TRENDLINE_MAIN,
   TRENDLINE_INDICATOR
  };
//+------------------------------------------------------------------+
//| Zeichnen einer Trendlinie im Hauptdiagramm oder im Indikator |
//+------------------------------------------------------------------+
void DrawTrendLine(ENUM_TRENDLINE_TYPE window,datetime x1,datetime x2,double y1,double y2,color lineColor,ENUM_LINE_STYLE style)
  {
   string label=OBJECT_PREFIX+"#"+IntegerToString(window)+DoubleToString(x1,0);
   int subwindow=(window==TRENDLINE_MAIN) ? 0 : ChartWindowFind();
   ObjectDelete(0,label);
   ObjectCreate(0,label,OBJ_TREND,subwindow,x1,y1,x2,y2,0,0);
   ObjectSetInteger(0,label,OBJPROP_RAY,false);
   ObjectSetInteger(0,label,OBJPROP_COLOR,lineColor);
   ObjectSetInteger(0,label,OBJPROP_STYLE,style);
  }
//+------------------------------------------------------------------+
//| Warnung anzeigen, wenn Divergenz gefunden wird|
//+------------------------------------------------------------------+
void DisplayAlert(string message,const datetime alertTime)
  {
   lastAlertTime=alertTime;
   Alert(message,Symbol()," , ",EnumToString(Period())," minutes chart");
  }
//+------------------------------------------------------------------+
//| Alle vom Indikator gezeichneten Objekte löschen
//+------------------------------------------------------------------+
void ObjectDeleteByName(string prefix)
  {
   int total=ObjectsTotal(0),
   length=StringLen(prefix);

//--- Löschung aller vom Indikator verwendeten Objekte
   for(int i=total-1; i>=0; i--)
     {
      string objName=ObjectName(0,i);
      if(StringSubstr(objName,0,length)==prefix)
        {
         ObjectDelete(0,objName);
        }
     }
  }
//+------------------------------------------------------------------+

Indicators: MACD Divergence Indikatoren: CandleColorCounter Indikatoren: RSIWithFlat

Alain Verleyen 2021.09.12 13:55 #46

Forum zum Thema Handel, automatisierte Handelssysteme und Testen von Handelsstrategien

Indikatoren: MACD-Divergenz

Alain Verleyen, 2013.11.05 19:14

So freundlich.

Das Signal wird beim Schließen einer Kerze gegeben, 1 Kerze in der Vergangenheit (2, wenn Sie die offene Kerze zählen und nicht 3). Das ist normal und so muss es auch funktionieren. Die Divergenz basiert auf der Suche nach einem Extremum (oben/unten). Wenn Sie eine Möglichkeit haben, ein Extremum an der aktuellen Kerze zu erkennen, schlage ich vor, dass Sie programmieren lernen und uns diese großartige Innovation kostenlos zur Verfügung stellen.

Ich danke Ihnen für Ihren Beitrag.

Expert Advisors: AscTrend Expert Multi-Timeframe-Indikatoren Indikatoren: Vertical line

lego9955 2021.12.14 01:18 #47

Hallo Alain. Sehr guter Indikator. Er liefert korrekte Signale.

BTW im Teil "//--- Bearish divergence is found" sollte es "divergenceStyle" anstelle von "STYLE_SOLID" sein.

Indikator totalaly nicht neu zu zeichnen. Für meinen Zweck entschied ich mich, eine kleine Änderung vorzunehmen, um den letzten Balken des Indikators sowie das Divergenzsignal redrawable zu machen.

Es wird ein Divergenzsignal auf dem vorherigen Balken angezeigt, das sicher neu gezeichnet werden kann. Auf schnellen Timeframes wird es hilfreich sein, das Signal kurz vor dem Schließen eines Balkens zu verwenden.

Ich habe Änderungen vorgenommen:

- den ganzen Teil "//--- Indikator wird nur bei neuer Kerze aktualisiert, außer bei totalem Redraw" entfernt

- "start=prev_calculated-2;" wurde geändert in "start=prev_calculated-1;"

- Im Teil "//--- Hauptschleife der Berechnungen" wurde "for(int shift=start; shift<rates_total-2; shift++)" geändert in "for(int shift=start; shift<rates_total-1; shift++)"

Das Divergenzsignal erscheint jetzt auf dem vorherigen Balken, aber es friert im Moment des Erscheinens ein und folgt nicht der Indikatorlinie auf diesem Balken.

Können Sie mir helfen, dieses Problem zu lösen?

Fragen von Anfängern MQL5 ASCTrend-System Jede Anfängerfrage, um das

lego9955 2021.12.15 21:10 #48

Ich habe diesen Teil geändert und das Problem gelöst. Vielleicht könnte es besser und einfacher gemacht werden, aber es funktioniert. Die Pfeile sind um 1 Takt vorgerückt. Linien ohne Pfeile sind unbestätigte Signale.

//--- Der Indikator wird nur bei einer neuen Kerze aktualisiert, außer bei einem Total Redraw
 // static datetime lastCandleTime=0;
 // if(lastCandleTime==time[rates_total-1])
 // return(rates_total);
 // sonst
 // lastCandleTime=time[rates_total-1];
//--- erste Berechnung oder Anzahl der Balken wurde geändert
   int start;
   if(prev_calculated<=0)
     {
      start=slowEMA;
      ArrayInitialize(bullishDivergence,EMPTY_VALUE);   // Divergenzpuffer müssen initialisiert werden
      ArrayInitialize(bearishDivergence,EMPTY_VALUE);
     }
   else
     { 
      start=prev_calculated-1;
      bullishDivergence[rates_total-1]=EMPTY_VALUE;
      bearishDivergence[rates_total-1]=EMPTY_VALUE;
     }
//--- Anzahl der zu kopierenden Daten (Macd-Puffer) 
   int toCopy=rates_total-prev_calculated+(prev_calculated<=0 ? 0 : 1);
//--- nicht alle Daten können berechnet werden
   int calculated=BarsCalculated(macdHandle);
   if(calculated<rates_total)
     {
      Print("Not all data of macdHandle is calculated (",calculated,"bars ). Error",GetLastError());
      return(0);
     }
//--- Haupt-MACD-Puffer abrufen
   if(IsStopped()) return(0); //Prüfung auf Stop-Flag
   if(CopyBuffer(macdHandle,MAIN_LINE,0,toCopy,macdBuffer)<=0)
     {
      Print("Getting MACD Main is failed! Error : ",GetLastError());
      return(0);
     }
//--- Signal MACD-Puffer abrufen
   if(IsStopped()) return(0); //Prüfung auf Stop-Flag
   if(CopyBuffer(macdHandle,SIGNAL_LINE,0,toCopy,signalBuffer)<=0)
     {
      Print("Getting MACD Signal is failed! Error : ",GetLastError());
      return(0);
     }
//--- Hauptschleife der Berechnungen
   for(int shift=start; shift<rates_total; shift++)
     {
      int currentExtremum,lastExtremum;
      bool isBullishDivergence,isBearishDivergence;
      string divergenceMsg;
      ENUM_LINE_STYLE divergenceStyle=0;
      
      //--- Bullische Divergenz einfangen
      isBullishDivergence=false;
               
      if(macdBuffer[shift-1]<=macdBuffer[shift-2] && 
         macdBuffer[shift-1]<macdBuffer[shift-3] && 
         macdBuffer[shift-1]<macdBuffer[shift])
         //--- wenn der aktuelle macd main ein Tiefpunkt ist (niedriger als 2 vorherige und 1 nächste)
        {
         currentExtremum=shift;
         lastExtremum=GetIndicatorLastTrough(shift);
         //--- 
         if(macdBuffer[currentExtremum-1]>macdBuffer[lastExtremum] && 
            low[currentExtremum-1]<low[lastExtremum])
           {
            isBullishDivergence=true;
            divergenceMsg="Classical bullish divergence on: ";
            divergenceStyle=STYLE_SOLID;
           }
         //--- 
         if(macdBuffer[currentExtremum-1]<macdBuffer[lastExtremum] && 
            low[currentExtremum-1]>low[lastExtremum])
           {
            isBullishDivergence=true;
            divergenceMsg="Reverse bullish divergence on: ";
            divergenceStyle=STYLE_DOT;
           }
         //--- Bullische Divergenz gefunden
         if(isBullishDivergence)
           {
            bullishDivergence[currentExtremum]=macdBuffer[currentExtremum]-ARROWS_DISPLACEMENT;
            //---
            if(drawPriceTrendLines==true)
               DrawTrendLine(TRENDLINE_MAIN,time[currentExtremum-1],time[lastExtremum],low[currentExtremum-1],low[lastExtremum],Green,divergenceStyle);
            //---
            if(drawIndicatorTrendLines==true)
               DrawTrendLine(TRENDLINE_INDICATOR,time[currentExtremum-1],time[lastExtremum],macdBuffer[currentExtremum-1],macdBuffer[lastExtremum],Green,divergenceStyle);
            //---
            if(displayAlert==true && shift>=rates_total-3 && time[currentExtremum-1]!=lastAlertTime)
               DisplayAlert(divergenceMsg,time[currentExtremum-1]);
           }
        }
      //--- Fangen Sie die bärische Divergenz
      isBearishDivergence=false;

      if(macdBuffer[shift-1]>=macdBuffer[shift-2] && 
         macdBuffer[shift-1]>macdBuffer[shift-3] && 
         macdBuffer[shift-1]>macdBuffer[shift])
         //--- wenn der aktuelle macd main ein Top ist (höher als 2 vorherige und 1 nächste)
        {
         currentExtremum=shift;
         lastExtremum=GetIndicatorLastPeak(shift);
         //--- 
         if(macdBuffer[currentExtremum-1]<macdBuffer[lastExtremum] && 
            high[currentExtremum-1]>high[lastExtremum])
           {
            isBearishDivergence=true;
            divergenceMsg="Classical bearish divergence on: ";
            divergenceStyle=STYLE_SOLID;
           }
         if(macdBuffer[currentExtremum-1]>macdBuffer[lastExtremum] && 
            high[currentExtremum-1]<high[lastExtremum])
           {
            isBearishDivergence=true;
            divergenceMsg="Reverse bearish divergence on: ";
            divergenceStyle=STYLE_DOT;
           }
         //--- Bärenhafte Divergenz wird festgestellt
         if(isBearishDivergence)
           {
            bearishDivergence[currentExtremum]=macdBuffer[currentExtremum]+ARROWS_DISPLACEMENT;
            //---
            if(drawPriceTrendLines==true)
               DrawTrendLine(TRENDLINE_MAIN,time[currentExtremum-1],time[lastExtremum],high[currentExtremum-1],high[lastExtremum],Red,divergenceStyle);
            //---
            if(drawIndicatorTrendLines==true)
               DrawTrendLine(TRENDLINE_INDICATOR,time[currentExtremum-1],time[lastExtremum],macdBuffer[currentExtremum-1],macdBuffer[lastExtremum],Red,divergenceStyle);
            //---
            if(displayAlert==true && shift>=rates_total-3 && time[currentExtremum-1]!=lastAlertTime)
               DisplayAlert(divergenceMsg,time[currentExtremum-1]);
           }
        }
     }
//--- Rückgabe des Wertes von prev_calculated für den nächsten Aufruf
   return(rates_total);
  }
//+------------------------------------------------------------------+
//| Letzte Mulde suchen|
//+------------------------------------------------------------------+
int GetIndicatorLastTrough(int shift)
  {
   for(int i=shift-6; i>=2; i--)
     {
      if(signalBuffer[i] <= signalBuffer[i-1] && signalBuffer[i] <= signalBuffer[i-2] &&
         signalBuffer[i] <= signalBuffer[i+1] && signalBuffer[i] <= signalBuffer[i+2])
        {
         for(int j=i; j>=2; j--)
           {
            if(macdBuffer[j] <= macdBuffer[j-1] && macdBuffer[j] < macdBuffer[j-2] &&
               macdBuffer[j] <= macdBuffer[j+1] && macdBuffer[j] < macdBuffer[j+2])
               return(j);
           }
        }
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| Suche nach letztem Peak|
//+------------------------------------------------------------------+
int GetIndicatorLastPeak(int shift)
  {
   for(int i=shift-6; i>=2; i--)
     {
      if(signalBuffer[i] >= signalBuffer[i-1] && signalBuffer[i] >= signalBuffer[i-2] &&
         signalBuffer[i] >= signalBuffer[i+1] && signalBuffer[i] >= signalBuffer[i+2])
        {
         for(int j=i; j>=2; j--)
           {
            if(macdBuffer[j] >= macdBuffer[j-1] && macdBuffer[j] > macdBuffer[j-2] &&
               macdBuffer[j] >= macdBuffer[j+1] && macdBuffer[j] > macdBuffer[j+2])
               return(j);
           }
        }
     }
   return(0);
  }
//+------------------------------------------------------------------+
//| ENUM_TRENDLINE_TYPE verwendet von DrawTrendLine |
//+------------------------------------------------------------------+

Vraja Sudhakar 2021.12.16 05:40 #49

Vladimir Karputov #:

wenn Divergenz Nulllinie unten auch Preis Bildung HL Boden ( Preis, wenn nicht wieder LL gemacht) Histogramm jede andere 5 30 60 240 tf 3 tf unterzeichnet, um fruchtbar

Tony Sampietro 2022.05.27 01:19 #50

Hallo Alain,

Vielen Dank für diesen tollen Indikator!

Ich versuche, die Werte des Datenfensters dieses Indikators in einem EA zu verwenden (siehe Anhang).

Ich verwende die gleiche Logik für alle vier Indizes, aber ich kann die korrekten Werte nur für die letzten beiden (Main und Signal) erhalten.

Für die ersten beiden sehe ich immer eine feste Zahl

wenn, wie im beigefügten Beispiel, einer einen korrekten Wert haben sollte und der andere 0/blank sein sollte

Wissen Sie, warum ich dieses Problem habe?

Ich danke Ihnen.

Dateien:

Screenshot.PNG 85 kb

Elite-Indikatoren :) AMA SLOPE - Neue Diskussion zum Artikel "Prinzipien

Indikatoren: MACD Divergence - Seite 5