Indicadores: Divergencia MACD

Stephen Paul 2020.05.05 08:39 #41

Alain Verleyen:

No has entendido nada. El post que se está refiriendo a era acerca de cómo obtener la señal de un EA, es obvio que no se puede tener por sólo conseguir el último 2 valores de las velas, se necesita la tercera.

NO es posible tener una señal temprana porque para detectar una divergencia necesitas un pico/trófico y para eso necesitas una vela adicional que CIERRE. Así que cuando la vela 0 acaba de abrir, eso significa que la vela 1 está cerca, y permite confirmar el pico/trough en la vela 2. Si alguien quiere modificar el indicador para usar un pico/trough no confirmado para tener una señal temprana, uno puede hacerlo, pero no ayudaré a eso porque es una mala idea ya que obtendrá muchas señales malas.

Lo que se podría hacer es DIBUJAR la señal en la vela 1 o incluso en la vela 0, pero eso no cambiaría nada, y decidí dibujar la señal en la vela que realmente muestra el pico / valle.

He cambiado el código y tienes razón. Usted consigue falsos movimientos antes de la divergencia real. Gracias por su tiempo en esto.

bk7 2021.01.16 16:31 #42

Alain Verleyen:

No has entendido nada. El post que se está refiriendo a era acerca de cómo obtener la señal de un EA, es obvio que no se puede tener por sólo conseguir el último 2 valores de las velas, se necesita la tercera.

NO es posible tener una señal temprana porque para detectar una divergencia necesitas un pico/trófico y para eso necesitas una vela adicional que CIERRE. Así que cuando la vela 0 acaba de abrir, eso significa que la vela 1 está cerca, y permite confirmar el pico/trough en la vela 2. Si alguien quiere modificar el indicador para usar un pico/trough no confirmado para tener una señal temprana, uno puede hacerlo, pero no ayudaré a eso porque es una mala idea ya que obtendrá muchas señales malas.

Lo que se podría hacer es DIBUJAR la señal en la vela 1 o incluso en la vela 0, pero eso no cambiaría nada, y decidí dibujar la señal en la vela que realmente muestra el pico / valle.

es posible que se perdió un punto también.

En el caso de los gráficos renko, la barra actual (en su mayoría) ya está cerrada, por lo que necesitaría una vela menos. ¿O me estoy perdiendo algo?

Preguntas de los principiantes FOREX - Tendencias, previsiones Indicadores de élite :)

Hristo 2021.04.06 23:07 #43

Hola Alain, muy buen indicador, funciona bien incluso sin ajustar la configuración. Es bueno que tiene las alertas, pero la única cosa que falta para mí es la capacidad de enviar notificaciones push a mi teléfono. El mismo mensaje que aparece en la alerta emergente para que lo envíe a mi teléfono. ¿Podéis añadirle esta función? Sería muy amable de su parte.

Indicadores Multi Timeframe Errores, fallos, preguntas Indicadores: MACD_Divergence

Zeke Yaeger 2021.04.12 05:14 #44

Gracias Alain, es un indicador excelente.

Vladimir Karputov 2021.09.12 13:50 #45

Foro sobre trading, sistemas automatizados de trading y prueba de estrategias de trading

macd divegence

ENEZA PETER MKIRAMWENI, 2021.09.12 12:26

hola ayudenme con este indicador muestra alerta despues de tres barras quiero mostrar alerta inmediatamente despues de 1 barra

//+------------------------------------------------------------------+
//|MACD_Divergence.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

//--- Parcela 1 : Alcista 
#property indicator_type1   DRAW_ARROW
#property indicator_color1  clrGreen
#property indicator_label1  "Bullish divergence"
//--- Parcela 2 : Bajista
#property indicator_type2   DRAW_ARROW
#property indicator_color2  clrRed
#property indicator_label2  "Bearish divergence"
//--- Gráfico 3 : MACD Principal
#property indicator_type3   DRAW_LINE
#property indicator_style3  STYLE_SOLID
#property indicator_width3   2
#property indicator_color3  clrMagenta
#property indicator_label3  "Main"
//--- Gráfico 4 : Señal MACD
#property indicator_type4   DRAW_LINE
#property indicator_style4  STYLE_SOLID
#property indicator_width4   1
#property indicator_color4  clrNONE
#property indicator_label4  "Signal"
//--- parámetros de entrada
input string s1="-----------------------------------------------";      // ----------- Configuración MACD ----------------------
input int    fastEMA                 = 12;
input int    slowEMA                 = 26;
input int    signalSMA               = 9;
input string s2="-----------------------------------------------";      // ----------- Configuración del indicador -----------------
input bool   drawIndicatorTrendLines = true;
input bool   drawPriceTrendLines     = true;
input bool   displayAlert            = true;
//--- constantes
#define  OBJECT_PREFIX       "MACD_DivergenceLine"
#define  ARROWS_DISPLACEMENT 0.0001
//--- buffers
double bullishDivergence[];
double bearishDivergence[];
double macdBuffer[];
double signalBuffer[];
//--- asas
int    macdHandle=INVALID_HANDLE;
//--- variables globales
static datetime lastAlertTime;
//+------------------------------------------------------------------+
//| Función de inicialización del indicador personalizada |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- tirador indicador 
   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);
     }
//--- asignación de búferes indicadores
   SetIndexBuffer(0,bullishDivergence);
   SetIndexBuffer(1,bearishDivergence);
   SetIndexBuffer(2,macdBuffer);
   SetIndexBuffer(3,signalBuffer);
//--- código de flecha ver http://www.mql5.com/en/docs/constants/objectconstants/wingdings
   PlotIndexSetInteger(0,PLOT_ARROW,233);
   PlotIndexSetInteger(1,PLOT_ARROW,234);
//--- propiedades del indicador
   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);
  }
//+------------------------------------------------------------------+
//| Limpieza del gráfico|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   ObjectDeleteByName("MACD_DivergenceLine");
  }
//+------------------------------------------------------------------+
//| Función de iteración del indicador personalizada|
//+------------------------------------------------------------------+
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[])
  {
//--- indicador actualizado solo en nueva vela excepto redibujo total
   static datetime lastCandleTime=0;
   if(lastCandleTime==time[rates_total-1])
      return(rates_total);
   else
      lastCandleTime=time[rates_total-1];
//--- se modificó el primer cálculo o el número de compases
   int start;
   if(prev_calculated<=0)
     {
      start=slowEMA;
      ArrayInitialize(bullishDivergence,EMPTY_VALUE);   // los buffers de divergencia deben ser inicializados
      ArrayInitialize(bearishDivergence,EMPTY_VALUE);
     }
   else
     {
      start=prev_calculated-2;
      bullishDivergence[rates_total-1]=EMPTY_VALUE;
      bearishDivergence[rates_total-1]=EMPTY_VALUE;
     }
//--- datos (macd buffers) cuenta a copiar 
   int toCopy=rates_total-prev_calculated+(prev_calculated<=0 ? 0 : 1);
//--- no todos los datos pueden ser calculados
   int calculated=BarsCalculated(macdHandle);
   if(calculated<rates_total)
     {
      Print("Not all data of macdHandle is calculated (",calculated,"bars ). Error",GetLastError());
      return(0);
     }
//--- obtener el buffer principal MACD
   if(IsStopped()) return(0); //Comprobación de la bandera de parada
   if(CopyBuffer(macdHandle,MAIN_LINE,0,toCopy,macdBuffer)<=0)
     {
      Print("Getting MACD Main is failed! Error : ",GetLastError());
      return(0);
     }
//--- obtener señal MACD buffer
   if(IsStopped()) return(0); //Comprobación de la bandera de parada
   if(CopyBuffer(macdHandle,SIGNAL_LINE,0,toCopy,signalBuffer)<=0)
     {
      Print("Getting MACD Signal is failed! Error : ",GetLastError());
      return(0);
     }
//--- bucle principal de cálculos
   for(int shift=start; shift<rates_total-2; shift++)
     {
      int currentExtremum,lastExtremum;
      bool isBullishDivergence,isBearishDivergence;
      string divergenceMsg;
      ENUM_LINE_STYLE divergenceStyle=0;

      //--- Atrapar Divergencia Alcista
      isBullishDivergence=false;

      if(macdBuffer[shift]<=macdBuffer[shift-1] && 
         macdBuffer[shift]<macdBuffer[shift-2] && 
         macdBuffer[shift]<macdBuffer[shift+1])
         //--- si el macd principal actual es un mínimo (inferior a 2 anterior y 1 siguiente)
        {
         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;
           }
         //--- Se encuentra una divergencia alcista
         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]);
           }
        }
      //--- Captura Divergencia Bajista
      isBearishDivergence=false;

      if(macdBuffer[shift]>=macdBuffer[shift-1] && 
         macdBuffer[shift]>macdBuffer[shift-2] && 
         macdBuffer[shift]>macdBuffer[shift+1])
         //--- si el macd principal actual es un máximo (mayor que 2 anteriores y 1 siguiente)
        {
         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;
           }
         //--- Se encuentra divergencia bajista
         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]);
           }
        }
     }
//--- valor de retorno de prev_calculado para la siguiente llamada
   return(rates_total);
  }
//+------------------------------------------------------------------+
//| Buscar última depresión|
//+------------------------------------------------------------------+
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);
  }
//+------------------------------------------------------------------+
//| Buscar último pico|
//+------------------------------------------------------------------+
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 utilizado por DrawTrendLine ||
//+------------------------------------------------------------------+
enum ENUM_TRENDLINE_TYPE
  {
   TRENDLINE_MAIN,
   TRENDLINE_INDICATOR
  };
//+------------------------------------------------------------------+
//| Dibujar una línea de tendencia en el gráfico principal o en el indicador.
//+------------------------------------------------------------------+
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);
  }
//+------------------------------------------------------------------+
//| Mostrar alerta cuando se encuentra divergencia|
//+------------------------------------------------------------------+
void DisplayAlert(string message,const datetime alertTime)
  {
   lastAlertTime=alertTime;
   Alert(message,Symbol()," , ",EnumToString(Period())," minutes chart");
  }
//+------------------------------------------------------------------+
//| Borrar todos los objetos dibujados por el indicador |
//+------------------------------------------------------------------+
void ObjectDeleteByName(string prefix)
  {
   int total=ObjectsTotal(0),
   length=StringLen(prefix);

//--- Borrado de todos los objetos utilizados por el indicador
   for(int i=total-1; i>=0; i--)
     {
      string objName=ObjectName(0,i);
      if(StringSubstr(objName,0,length)==prefix)
        {
         ObjectDelete(0,objName);
        }
     }
  }
//+------------------------------------------------------------------+

Características del lenguaje mql5, Indicadores: Ergodic MACD Oscillator Bibliotecas: MT4Orders

Alain Verleyen 2021.09.12 13:55 #46

Foro sobre trading, sistemas automatizados de trading y prueba de estrategias de trading

Indicadores: Divergencia MACD

Alain Verleyen, 2013.11.05 19:14

Muy amigable.

La señal se da al cierre de una vela, 1 vela en el pasado (2 si cuentas vela abierta y no 3). Es normal y es como tiene que funcionar. Divergencia se basa en la investigación de extremum (superior/inferior). Si usted tiene una manera de detectar un extremo en la vela actual, le sugiero que aprender a programar y nos proporcionan, de forma gratuita, esta gran innovación.

Gracias por su aportación.

Asesores Expertos: Asesor Experto Solicitud de EA Preguntas de los principiantes

lego9955 2021.12.14 01:18 #47

Hola Alain. Muy buen indicador. Hace señales correctas.

BTW en parte "//--- divergencia bajista se encuentra" se suponía que era "divergenceStyle" en lugar de "STYLE_SOLID" .

Indicador totaly no redibujar. Para mi propósito decidí hacer una pequeña modificación para hacer la última barra del indicador redibujable así como la señal de divergencia.

Mostrará la señal de divergencia en la barra anterior, señal redibujable con seguridad. Será útil en timeframes rápidos para usar la señal justo antes de cerrar una barra.

He hecho cambios:

- quite toda la parte "//--- indicator updated only on new candle except total redraw"

- "start=prev_calculated-2;" fue cambiado a "start=prev_calculated-1;"

- En la parte "//--- bucle principal de cálculos" "for(int shift=start; shift<rates_total-2; shift++)" se cambió por "for(int shift=start; shift<rates_total-1; shift++)"

La señal de divergencia ahora aparece en la barra anterior, pero se congela en el momento de la aparición y no seguir la línea del indicador en esta barra.

¿Me podéis ayudar a solucionar esto?

Cualquier pregunta de novato, Indicators: MACD Divergence Indicadores Multi Timeframe

lego9955 2021.12.15 21:10 #48

He cambiado esta parte y lo he solucionado. Tal vez se podría hacer mejor y más simple, pero funciona. Las flechas se adelantaron 1 barra. Las líneas sin flechas son señales no confirmadas.

//--- indicador actualizado solo en nueva vela excepto redibujo total
 // static datetime lastCandleTime=0;
 // if(lastCandleTime==time[rates_total-1])
 // return(tarifas_total);
 // si no
 // lastCandleTime=tiempo[rates_total-1];
//--- se modificó el primer cálculo o el número de compases
   int start;
   if(prev_calculated<=0)
     {
      start=slowEMA;
      ArrayInitialize(bullishDivergence,EMPTY_VALUE);   // los buffers de divergencia deben ser inicializados
      ArrayInitialize(bearishDivergence,EMPTY_VALUE);
     }
   else
     { 
      start=prev_calculated-1;
      bullishDivergence[rates_total-1]=EMPTY_VALUE;
      bearishDivergence[rates_total-1]=EMPTY_VALUE;
     }
//--- datos (macd buffers) cuenta a copiar 
   int toCopy=rates_total-prev_calculated+(prev_calculated<=0 ? 0 : 1);
//--- no todos los datos pueden ser calculados
   int calculated=BarsCalculated(macdHandle);
   if(calculated<rates_total)
     {
      Print("Not all data of macdHandle is calculated (",calculated,"bars ). Error",GetLastError());
      return(0);
     }
//--- obtener el buffer principal MACD
   if(IsStopped()) return(0); //Comprobación de la bandera de parada
   if(CopyBuffer(macdHandle,MAIN_LINE,0,toCopy,macdBuffer)<=0)
     {
      Print("Getting MACD Main is failed! Error : ",GetLastError());
      return(0);
     }
//--- obtener señal MACD buffer
   if(IsStopped()) return(0); //Comprobación de la bandera de parada
   if(CopyBuffer(macdHandle,SIGNAL_LINE,0,toCopy,signalBuffer)<=0)
     {
      Print("Getting MACD Signal is failed! Error : ",GetLastError());
      return(0);
     }
//--- bucle principal de cálculos
   for(int shift=start; shift<rates_total; shift++)
     {
      int currentExtremum,lastExtremum;
      bool isBullishDivergence,isBearishDivergence;
      string divergenceMsg;
      ENUM_LINE_STYLE divergenceStyle=0;
      
      //--- Atrapar Divergencia Alcista
      isBullishDivergence=false;
               
      if(macdBuffer[shift-1]<=macdBuffer[shift-2] && 
         macdBuffer[shift-1]<macdBuffer[shift-3] && 
         macdBuffer[shift-1]<macdBuffer[shift])
         //--- si el macd principal actual es un mínimo (inferior a 2 anterior y 1 siguiente)
        {
         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;
           }
         //--- Se encuentra una divergencia alcista
         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]);
           }
        }
      //--- Captura Divergencia Bajista
      isBearishDivergence=false;

      if(macdBuffer[shift-1]>=macdBuffer[shift-2] && 
         macdBuffer[shift-1]>macdBuffer[shift-3] && 
         macdBuffer[shift-1]>macdBuffer[shift])
         //--- si el macd principal actual es un máximo (mayor que 2 anteriores y 1 siguiente)
        {
         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;
           }
         //--- Se encuentra divergencia bajista
         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]);
           }
        }
     }
//--- valor de retorno de prev_calculado para la siguiente llamada
   return(rates_total);
  }
//+------------------------------------------------------------------+
//| Buscar última depresión|
//+------------------------------------------------------------------+
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);
  }
//+------------------------------------------------------------------+
//| Buscar último pico|
//+------------------------------------------------------------------+
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 utilizado por DrawTrendLine ||
//+------------------------------------------------------------------+

Vraja Sudhakar 2021.12.16 05:40 #49

Vladimir Karputov #:

cuando divergencia línea cero por debajo también formación de precios HL fondo ( precio si no se hace de nuevo LL) histograma cualquier otro 5 30 60 240 tf 3 tf firmado a fructífero

Indicators: MACD Divergence Indicadores en zigzag Indicadores de tendencia para

Tony Sampietro 2022.05.27 01:19 #50

Hola Alain,

Muchas gracias por este gran indicador.

Estoy tratando de utilizar los valores de la ventana de datos de este indicador dentro de un EA (por favor, vea el archivo adjunto).

Utilizo la misma lógica para los cuatro índices, pero sólo puedo obtener los valores correctos para los dos últimos (Principal y Señal).

Para los dos primeros veo siempre un número fijo

cuando, para el ejemplo adjunto, uno debe tener un valor correcto y el otro debe ser 0 / en blanco

¿sabéis por qué tengo este problema?

Gracias

Archivos adjuntos:

Screenshot.PNG 85 kb

Deseos para MT5 Ayuda a la codificación TSD-v11 MT4-JB-OsMA

Indicadores: Divergencia MACD - página 5