Indicadores: Divergência MACD

Stephen Paul 2020.05.05 08:39 #41

Alain Verleyen:

Você não entendeu o ponto. A postagem a que você se refere era sobre COMO obter o sinal de um EA. Obviamente, não é possível obtê-lo apenas com os valores dos dois últimos candles, você precisa do terceiro.

NÃO é possível obter um sinal antecipado porque, para detectar uma divergência, você precisa de um pico/valor mínimo e, para isso, precisa de um candle adicional que FECHE. Portanto, quando o candle 0 acaba de abrir, isso significa que o candle 1 está fechado e permite confirmar o pico/vale no candle 2. Se alguém quiser modificar o indicador para usar pico/vale não confirmado para ter um sinal antecipado, pode fazê-lo, mas não ajudarei nisso porque é uma má ideia, pois você receberá muitos sinais ruins.

O que poderia ser feito é DESENHAR o sinal no candle 1 ou mesmo no candle 0, mas isso não mudará nada, e eu decidi desenhar o sinal no candle que realmente mostra o pico/vale.

Alterei o código e você está certo. Você obtém movimentos falsos antes da divergência real. Obrigado por sua atenção.

bk7 2021.01.16 16:31 #42

Alain Verleyen:

Você não entendeu o ponto. A postagem a que você se refere era sobre COMO obter o sinal de um EA. Obviamente, não é possível obtê-lo apenas com os valores dos dois últimos candles, você precisa do terceiro.

NÃO é possível ter um sinal antecipado porque, para detectar uma divergência, você precisa de um pico/vale e, para isso, precisa de um candle adicional que FECHE. Portanto, quando o candle 0 acaba de abrir, isso significa que o candle 1 está fechado e permite confirmar o pico/vale no candle 2. Se alguém quiser modificar o indicador para usar pico/vale não confirmado para ter um sinal antecipado, pode fazê-lo, mas não ajudarei nisso porque é uma má ideia, pois você receberá muitos sinais ruins.

O que poderia ser feito é DESENHAR o sinal no candle 1 ou mesmo no candle 0, mas isso não mudará nada, e eu decidi desenhar o sinal no candle que realmente mostra o pico/vale.

Talvez você tenha perdido um ponto também.

No caso dos gráficos renko, a barra atual já está (em sua maior parte) fechada, portanto, você precisaria de um candle a menos. Ou estou perdendo alguma coisa?

Quaisquer perguntas de recém-chegados Aprendizado de máquina no Indicadores de elite :)

Hristo 2021.04.06 23:07 #43

Oi Alain, muito bom indicador, funciona bem mesmo sem ajustar as configurações. É bom que ele tenha os alertas, mas a única coisa que está faltando para mim é a capacidade de enviar notificações por push para o meu telefone. A mesma mensagem que aparece no alerta pop-up para que seja enviada ao meu telefone. Você pode adicionar essa função a ele? Seria muito gentil de sua parte.

Indicadores de múltiplos períodos Indicadores de elite :) Ajuda na codificação

Zeke Yaeger 2021.04.12 05:14 #44

Obrigado, Alain, esse é um excelente indicador

Vladimir Karputov 2021.09.12 13:50 #45

Fórum sobre negociação, sistemas de negociação automatizados e teste de estratégias de negociação

macd divegence

ENEZA PETER MKIRAMWENI, 2021.09.12 12:26

O que eu quero é que esse indicador exiba um alerta imediatamente após uma 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

//--- Gráfico 1 : Alta 
#property indicator_type1   DRAW_ARROW
#property indicator_color1  clrGreen
#property indicator_label1  "Bullish divergence"
//--- Gráfico 2 : Baixa
#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 : Sinal 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="-----------------------------------------------";      // ----------- Configurações de MACD ----------------------
input int    fastEMA                 = 12;
input int    slowEMA                 = 26;
input int    signalSMA               = 9;
input string s2="-----------------------------------------------";      // ----------- Configurações do 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[];
//--- alças
int    macdHandle=INVALID_HANDLE;
//--- variáveis globais
static datetime lastAlertTime;
//+------------------------------------------------------------------+
//| Função de inicialização do indicador personalizado
//+------------------------------------------------------------------+
int OnInit()
  {
//--- alça do 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);
     }
//--- mapeamento de buffers de indicadores
   SetIndexBuffer(0,bullishDivergence);
   SetIndexBuffer(1,bearishDivergence);
   SetIndexBuffer(2,macdBuffer);
   SetIndexBuffer(3,signalBuffer);
//--- código de seta veja http://www.mql5.com/en/docs/constants/objectconstants/wingdings
   PlotIndexSetInteger(0,PLOT_ARROW,233);
   PlotIndexSetInteger(1,PLOT_ARROW,234);
//--- propriedades do 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);
  }
//+------------------------------------------------------------------+
//| Limpeza do gráfico|
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   ObjectDeleteByName("MACD_DivergenceLine");
  }
//+------------------------------------------------------------------+
//| Função de iteração de indicador personalizado|
//+------------------------------------------------------------------+
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 atualizado somente no novo candle, exceto no redesenho total
   static datetime lastCandleTime=0;
   if(lastCandleTime==time[rates_total-1])
      return(rates_total);
   else
      lastCandleTime=time[rates_total-1];
//--- o primeiro cálculo ou o número de barras foi alterado
   int start;
   if(prev_calculated<=0)
     {
      start=slowEMA;
      ArrayInitialize(bullishDivergence,EMPTY_VALUE);   // os buffers de divergência devem ser inicializados
      ArrayInitialize(bearishDivergence,EMPTY_VALUE);
     }
   else
     {
      start=prev_calculated-2;
      bullishDivergence[rates_total-1]=EMPTY_VALUE;
      bearishDivergence[rates_total-1]=EMPTY_VALUE;
     }
//--- contagem de dados (buffers macd) para copiar 
   int toCopy=rates_total-prev_calculated+(prev_calculated<=0 ? 0 : 1);
//--- nem todos os dados podem ser calculados
   int calculated=BarsCalculated(macdHandle);
   if(calculated<rates_total)
     {
      Print("Not all data of macdHandle is calculated (",calculated,"bars ). Error",GetLastError());
      return(0);
     }
//--- obter o buffer MACD principal
   if(IsStopped()) return(0); /Verificação do sinalizador de parada
   if(CopyBuffer(macdHandle,MAIN_LINE,0,toCopy,macdBuffer)<=0)
     {
      Print("Getting MACD Main is failed! Error : ",GetLastError());
      return(0);
     }
//--- obter buffer de sinal MACD
   if(IsStopped()) return(0); /Verificação do sinalizador de parada
   if(CopyBuffer(macdHandle,SIGNAL_LINE,0,toCopy,signalBuffer)<=0)
     {
      Print("Getting MACD Signal is failed! Error : ",GetLastError());
      return(0);
     }
//--- loop 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;

      //--- Pegue a Divergência de Alta
      isBullishDivergence=false;

      if(macdBuffer[shift]<=macdBuffer[shift-1] && 
         macdBuffer[shift]<macdBuffer[shift-2] && 
         macdBuffer[shift]<macdBuffer[shift+1])
         //--- se a macd principal atual for um fundo (inferior a 2 anteriores e 1 seguinte)
        {
         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;
           }
         //--- Encontrada divergência de alta
         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]);
           }
        }
      //--- Pegue a Divergência de Baixa
      isBearishDivergence=false;

      if(macdBuffer[shift]>=macdBuffer[shift-1] && 
         macdBuffer[shift]>macdBuffer[shift-2] && 
         macdBuffer[shift]>macdBuffer[shift+1])
         //--- se o macd principal atual for um topo (maior que 2 anteriores e 1 seguinte)
        {
         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;
           }
         //--- Encontrada divergência de baixa
         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_calculated para a próxima chamada
   return(rates_total);
  }
//+------------------------------------------------------------------+
//| Pesquisar a última calha|
//+------------------------------------------------------------------+
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);
  }
//+------------------------------------------------------------------+
//| Pesquisar o ú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 usado por DrawTrendLine
//+------------------------------------------------------------------+
enum ENUM_TRENDLINE_TYPE
  {
   TRENDLINE_MAIN,
   TRENDLINE_INDICATOR
  };
//+------------------------------------------------------------------+
//| Desenhar uma linha de tendência no gráfico principal ou no 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);
  }
//+------------------------------------------------------------------+
//| Exibir alerta quando for encontrada uma divergência|
//+------------------------------------------------------------------+
void DisplayAlert(string message,const datetime alertTime)
  {
   lastAlertTime=alertTime;
   Alert(message,Symbol()," , ",EnumToString(Period())," minutes chart");
  }
//+------------------------------------------------------------------+
//| Excluir todos os objetos desenhados pelo indicador
//+------------------------------------------------------------------+
void ObjectDeleteByName(string prefix)
  {
   int total=ObjectsTotal(0),
   length=StringLen(prefix);

//--- Exclusão de todos os objetos usados pelo 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 da linguagem mql5, Bibliotecas: Expert Indicadores: Oscilador Ergodic MACD

Alain Verleyen 2021.09.12 13:55 #46

Fórum sobre negociação, sistemas de negociação automatizados e teste de estratégias de negociação

Indicadores: Divergência MACD

Alain Verleyen, 2013.11.05 19:14

Tão amigável.

O sinal é dado no fechamento de um candle, 1 candle no passado (2 se você contar o candle aberto e não o 3). É normal e é assim que tem que funcionar. A divergência é baseada na pesquisa de extremos (superior/inferior). Se você tiver uma maneira de detectar um extremo no candle atual, sugiro que aprenda a programar e nos forneça, gratuitamente, essa grande inovação.

Obrigado por sua contribuição.

Como começar com o Especialistas: Expert Advisor AscTrend Discussão do artigo "Interfaces

lego9955 2021.12.14 01:18 #47

Olá, Alain. Indicador muito bom. Ele emite sinais corretos.

A propósito, na parte "//--- Bearish divergence is found", deveria ser "divergenceStyle" em vez de "STYLE_SOLID".

O indicador não foi totalmente redesenhado. Para meu propósito, decidi fazer uma pequena modificação para que a última barra do indicador possa ser redesenhada, bem como o sinal de divergência.

Ele mostrará o sinal de divergência na barra anterior, com certeza um sinal que pode ser redesenhado. Será útil em períodos de tempo rápidos usar o sinal apenas antes de fechar uma barra.

Fiz alterações:

- removi toda a parte "//--- o indicador é atualizado somente na nova vela, exceto no redesenho total"

- "start=prev_calculated-2;" foi alterado para "start=prev_calculated-1;"

- Na parte "//--- loop principal de cálculos" "for(int shift=start; shift<rates_total-2; shift++)" foi alterado para "for(int shift=start; shift<rates_total-1; shift++)"

O sinal de divergência agora aparece na barra anterior, mas congela no momento em que aparece e não segue a linha do indicador nessa barra.

Você pode me ajudar a resolver isso?

Índice de Qualidade de Qualquer pergunta de novato, Indicador diferencial Sultonov

lego9955 2021.12.15 21:10 #48

Alterei essa parte e resolvi o problema. Talvez pudesse ser feito de forma melhor e mais simples, mas funciona. As setas avançaram 1 barra. As linhas sem setas são sinais não confirmados.

//--- indicador atualizado somente no novo candle, exceto no redesenho total
 // datetime estático lastCandleTime=0;
 // se (lastCandleTime==time[rates_total-1])
 // return(rates_total);
 // senão
 // lastCandleTime=time[rates_total-1];
//--- o primeiro cálculo ou o número de barras foi alterado
   int start;
   if(prev_calculated<=0)
     {
      start=slowEMA;
      ArrayInitialize(bullishDivergence,EMPTY_VALUE);   // os buffers de divergência devem ser inicializados
      ArrayInitialize(bearishDivergence,EMPTY_VALUE);
     }
   else
     { 
      start=prev_calculated-1;
      bullishDivergence[rates_total-1]=EMPTY_VALUE;
      bearishDivergence[rates_total-1]=EMPTY_VALUE;
     }
//--- contagem de dados (buffers macd) para copiar 
   int toCopy=rates_total-prev_calculated+(prev_calculated<=0 ? 0 : 1);
//--- nem todos os dados podem ser calculados
   int calculated=BarsCalculated(macdHandle);
   if(calculated<rates_total)
     {
      Print("Not all data of macdHandle is calculated (",calculated,"bars ). Error",GetLastError());
      return(0);
     }
//--- obter o buffer MACD principal
   if(IsStopped()) return(0); /Verificação do sinalizador de parada
   if(CopyBuffer(macdHandle,MAIN_LINE,0,toCopy,macdBuffer)<=0)
     {
      Print("Getting MACD Main is failed! Error : ",GetLastError());
      return(0);
     }
//--- obter buffer de sinal MACD
   if(IsStopped()) return(0); /Verificação do sinalizador de parada
   if(CopyBuffer(macdHandle,SIGNAL_LINE,0,toCopy,signalBuffer)<=0)
     {
      Print("Getting MACD Signal is failed! Error : ",GetLastError());
      return(0);
     }
//--- loop 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;
      
      //--- Pegue a Divergência de Alta
      isBullishDivergence=false;
               
      if(macdBuffer[shift-1]<=macdBuffer[shift-2] && 
         macdBuffer[shift-1]<macdBuffer[shift-3] && 
         macdBuffer[shift-1]<macdBuffer[shift])
         //--- se a macd principal atual for um fundo (inferior a 2 anteriores e 1 seguinte)
        {
         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;
           }
         //--- Encontrada divergência de alta
         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]);
           }
        }
      //--- Pegue a Divergência de Baixa
      isBearishDivergence=false;

      if(macdBuffer[shift-1]>=macdBuffer[shift-2] && 
         macdBuffer[shift-1]>macdBuffer[shift-3] && 
         macdBuffer[shift-1]>macdBuffer[shift])
         //--- se o macd principal atual for um topo (maior que 2 anteriores e 1 seguinte)
        {
         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;
           }
         //--- Encontrada divergência de baixa
         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_calculated para a próxima chamada
   return(rates_total);
  }
//+------------------------------------------------------------------+
//| Pesquisar a última calha|
//+------------------------------------------------------------------+
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);
  }
//+------------------------------------------------------------------+
//| Pesquisar o ú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 usado por DrawTrendLine
//+------------------------------------------------------------------+

Vraja Sudhakar 2021.12.16 05:40 #49

Vladimir Karputov #:

Quando a linha zero de divergência estiver abaixo, a formação de preço também será o fundo HL (se o preço não voltar a ser LL) histograma qualquer outro 5 30 60 240 tf 3 tf assinado para dar frutos

FOREX - Tendências, previsões Indicators: MACD Divergence Indicadores em ziguezague

Tony Sampietro 2022.05.27 01:19 #50

Olá, Alain,

Muito obrigado por esse excelente indicador!

Estou tentando usar os valores da janela de dados desse indicador em um EA (veja o anexo).

Uso a mesma lógica para todos os quatro índices, mas só consigo obter os valores corretos para os dois últimos (Principal e Sinal).

Nos dois primeiros, vejo sempre um número fixo

quando, no exemplo em anexo, um deveria ter um valor correto e o outro deveria ser 0/em branco

Você sabe por que estou tendo esse problema?

Obrigado, senhor

Arquivos anexados:

Screenshot.PNG 85 kb

O "XO"-Método......... [AVISO FECHADO!] Qualquer pergunta Scripts: Export Indicator's Values

Indicadores: Divergência MACD - página 5