English Русский Español Deutsch 日本語
preview
Automatização de estratégias de negociação em MQL5 (Parte 32): Desenvolvimento de um sistema de reconhecimento do padrão harmônico "5 Drives" com Price Action

Automatização de estratégias de negociação em MQL5 (Parte 32): Desenvolvimento de um sistema de reconhecimento do padrão harmônico "5 Drives" com Price Action

MetaTrader 5 — Negociação |
17 0
Allan Munene Mutiiria
Allan Munene Mutiiria

Introdução

No artigo anterior (Parte 31), desenvolvemos um sistema de reconhecimento do padrão gráfico "3 Drives" em MetaQuotes Language 5 (MQL5), capaz de identificar padrões harmônicos de alta e de baixa com base em proporções de Fibonacci. O sistema automatizava as operações com níveis configuráveis de stop-loss e take-profit e utilizava objetos gráficos, como triângulos e linhas de tendência, para representar visualmente os padrões. Na Parte 32, desenvolveremos um sistema de reconhecimento do padrão "5 Drives", que identifica formações harmônicas de alta e de baixa por meio de pontos de reversão e níveis específicos de retração e extensão de Fibonacci. O sistema permitirá executar operações com opções flexíveis de entrada, stop-loss e realização de lucros em múltiplos níveis, além de utilizar triângulos, linhas de tendência e rótulos para facilitar a visualização dos padrões. Abordaremos os seguintes tópicos:

  1. Análise da estrutura do padrão harmônico "5 Drives"
  2. Implementação em MQL5
  3. Backtesting com dados históricos
  4. Conclusão

Ao final, você terá uma estratégia de negociação estável, desenvolvida em MQL5 e baseada no padrão harmônico "5 Drives", pronta para ser configurada conforme suas necessidades. Vamos à implementação!


Análise da estrutura do padrão harmônico "5 Drives"

O padrão "5 Drives (5-0)" é uma estrutura de preços utilizada na análise harmônica, definida por seis pontos de reversão principais: A, B, C, D, E e F. Ele pode apresentar uma configuração de alta ou de baixa e é utilizado para identificar possíveis zonas de reversão por meio de uma sequência de movimentos e retrações que seguem proporções específicas de Fibonacci. Na configuração de alta do padrão "5 Drives", a estrutura apresenta a sequência "máxima-mínima-máxima-mínima-máxima-mínima", em que A corresponde a uma máxima de swing, B a uma mínima de swing, C a uma máxima de swing, D a uma mínima de swing, E a uma máxima de swing e F a uma mínima de swing, posicionada acima de B. Os segmentos AB e CD correspondem a valores entre 1,13 e 1,618 vezes a amplitude dos respectivos movimentos anteriores, enquanto BC e DE apresentam proporções entre 1,618 e 2,24 vezes. Além disso, CD é igual a AB, com uma retração de 0,5 (50%). Na configuração de baixa, a sequência de máximas e mínimas é invertida, e o ponto F fica abaixo de B. Veja a representação visual dessas formações:

Padrão harmônico "5 Drives" de baixa:

Padrão "5 Drives" de baixa

Padrão harmônico "5 Drives" de alta:

Padrão "5 Drives" de alta

Nossa abordagem consiste em identificar esses pontos de reversão dentro de um intervalo definido de barras, validar as ondas do padrão de acordo com os critérios de Fibonacci, representar visualmente a estrutura A-B-C-D-E-F por meio de objetos gráficos, como triângulos e linhas de tendência, e abrir operações no ponto F para aproveitar a reversão esperada do preço. As operações utilizam um stop-loss configurável (baseado em Fibonacci ou em uma distância fixa) e níveis de take-profit ajustáveis (um terço, dois terços ou o preço do ponto de reversão E). Vamos à implementação!


Implementação em MQL5

Para criar o programa em MQL5, abra o MetaEditor, acesse o "Navegador", selecione a pasta Indicators, clique em "Novo" e siga as instruções para criar o arquivo. Primeiro, precisamos declarar algumas variáveis globais que serão utilizadas ao longo do programa.

//+------------------------------------------------------------------+
//|                                          5 Drives Pattern EA.mq5 |
//|                        Copyright 2025, Forex Algo-Trader, Allan. |
//|                                 "https://t.me/Forex_Algo_Trader" |
//+------------------------------------------------------------------+
#property copyright "Forex Algo-Trader, Allan"
#property link "https://t.me/Forex_Algo_Trader"
#property version "1.00"
#property description "This EA trades based on 5 Drives Strategy"
#property strict

//--- Include the trading library for order functions
#include <Trade\Trade.mqh>   //--- Include Trade library
CTrade obj_Trade;            //--- Instantiate a obj_Trade object
//--- Enumeration for TP levels
enum ENUM_TAKE_PROFIT_LEVEL {
   TP1 = 1, // One-third of the move to E
   TP2 = 2, // Two-thirds of the move to E
   TP3 = 3  // Pivot E Price
};
//--- Enumeration for SL types
enum ENUM_STOP_LOSS_TYPE {
   SL_FIBO = 1, // Fibonacci Extension
   SL_FIXED = 2 // Fixed Points
};
//--- Input parameters for user configuration
input int PivotLeft = 5;                             // Number of bars to the left for pivot check
input int PivotRight = 5;                            // Number of bars to the right for pivot check
input double Tolerance = 0.10;                       // Allowed deviation (10% of move)
input double LotSize = 0.01;                         // Lot size for new orders
input bool AllowTrading = true;                      // Enable or disable trading
input ENUM_TAKE_PROFIT_LEVEL TakeProfitLevel = TP2;  // Take Profit Level
input ENUM_STOP_LOSS_TYPE StopLossType = SL_FIBO;    // Stop Loss Type
input double SL_FiboExtension = 1.618;               // Fibonacci Extension for SL
input double SL_FixedPoints = 50;                    // Fixed Points for SL (in points)

//---------------------------------------------------------------------------
//--- Structure for a pivot point
struct Pivot {
   datetime time; //--- Bar time of the pivot
   double price;  //--- Pivot price (High for swing high, low for swing low)
   bool isHigh;   //--- True if swing high; false if swing low
};
//--- Global dynamic array for storing pivots in chronological order
Pivot pivots[]; //--- Declare a dynamic array to hold identified pivot points
//--- Global variables to lock in a pattern (avoid trading on repaint)
int g_patternFormationBar = -1; //--- Bar index where the pattern was formed (-1 means none)
datetime g_lockedPatternA = 0; //--- The key A pivot time for the locked pattern
//--- Global array to track traded patterns (using A.time as identifier)
datetime tradedPatterns[];

Para estabelecer a base do sistema de reconhecimento do padrão "5 Drives", começaremos incluindo a biblioteca "<Trade\Trade.mqh>" e criando uma instância da classe CTrade, denominada "obj_Trade", para gerenciar operações de negociação, como a abertura de posições de compra e venda. Em seguida, definiremos as enumerações "ENUM_TAKE_PROFIT_LEVEL" (TP1 para um terço, TP2 para dois terços e TP3 para o preço do ponto de reversão E) e "ENUM_STOP_LOSS_TYPE" (SL_FIBO para a extensão de Fibonacci e SL_FIXED para uma distância fixa em pontos), permitindo configurar diferentes níveis de saída das operações. Também estabeleceremos os parâmetros de entrada: "PivotLeft" e "PivotRight", ambos com valor 5, para identificar pontos de reversão considerando cinco barras de cada lado; "Tolerance" = 0.10, para definir a tolerância em relação às proporções de Fibonacci; "LotSize" = 0.01; "AllowTrading" = true; "TakeProfitLevel" = TP2; "StopLossType" = SL_FIBO; "SL_FiboExtension" = 1.618; e "SL_FixedPoints" = 50. Esses parâmetros poderão precisar de otimização conforme o par de moedas negociado.

Em seguida, definiremos a estrutura "Pivot", com os campos "time", "price" e "isHigh", para armazenar os pontos de reversão dos preços. Declararemos "pivots" como um array dinâmico e inicializaremos as variáveis globais "g_patternFormationBar" com -1 e "g_lockedPatternA" com 0, sendo esta última utilizada para armazenar o horário do ponto de reversão A. Também declararemos "tradedPatterns" como um array destinado a rastrear os padrões já negociados, utilizando o horário do ponto A como referência. Esses elementos constituem a base para identificar os padrões "5 Drives" e executar as operações correspondentes. Para representar visualmente os padrões, podemos utilizar funções que desenham linhas, rótulos e triângulos no gráfico.

//+------------------------------------------------------------------+
//| Helper: Draw a filled triangle                                   |
//+------------------------------------------------------------------+
void DrawTriangle(string name, datetime t1, double p1, datetime t2, double p2, datetime t3, double p3, color cl, int width, bool fill, bool back) {
   //--- Attempt to create a triangle object with three coordinate points
   if(ObjectCreate(0, name, OBJ_TRIANGLE, 0, t1, p1, t2, p2, t3, p3)) {
      //--- Set the triangle's color
      ObjectSetInteger(0, name, OBJPROP_COLOR, cl);
      //--- Set the triangle's line style to solid
      ObjectSetInteger(0, name, OBJPROP_STYLE, STYLE_SOLID);
      //--- Set the line width of the triangle
      ObjectSetInteger(0, name, OBJPROP_WIDTH, width);
      //--- Determine if the triangle should be filled
      ObjectSetInteger(0, name, OBJPROP_FILL, fill);
      //--- Set whether the object is drawn in the background
      ObjectSetInteger(0, name, OBJPROP_BACK, back);
   }
}
//+------------------------------------------------------------------+
//| Helper: Draw a trend line                                        |
//+------------------------------------------------------------------+
void DrawTrendLine(string name, datetime t1, double p1, datetime t2, double p2, color cl, int width, int style) {
   //--- Create a trend line object connecting two points
   if(ObjectCreate(0, name, OBJ_TREND, 0, t1, p1, t2, p2)) {
      //--- Set the trend line's color
      ObjectSetInteger(0, name, OBJPROP_COLOR, cl);
      //--- Set the trend line's style (solid, dotted, etc.)
      ObjectSetInteger(0, name, OBJPROP_STYLE, style);
      //--- Set the width of the trend line
      ObjectSetInteger(0, name, OBJPROP_WIDTH, width);
   }
}
//+------------------------------------------------------------------+
//| Helper: Draw a dotted trend line                                 |
//+------------------------------------------------------------------+
void DrawDottedLine(string name, datetime t1, double p, datetime t2, color lineColor) {
   //--- Create a horizontal trend line at a fixed price level with dotted style
   if(ObjectCreate(0, name, OBJ_TREND, 0, t1, p, t2, p)) {
      //--- Set the dotted line's color
      ObjectSetInteger(0, name, OBJPROP_COLOR, lineColor);
      //--- Set the line style to dotted
      ObjectSetInteger(0, name, OBJPROP_STYLE, STYLE_DOT);
      //--- Set the line width to 1
      ObjectSetInteger(0, name, OBJPROP_WIDTH, 1);
   }
}
//+------------------------------------------------------------------+
//| Helper: Draw anchored text label (for pivots)                    |
//| If isHigh is true, anchor at the bottom (label appears above);   |
//| if false, anchor at the top (label appears below).               |
//+------------------------------------------------------------------+
void DrawTextEx(string name, string text, datetime t, double p, color cl, int fontsize, bool isHigh) {
   //--- Create a text label object at the specified time and price
   if(ObjectCreate(0, name, OBJ_TEXT, 0, t, p)) {
      //--- Set the text of the label
      ObjectSetString(0, name, OBJPROP_TEXT, text);
      //--- Set the color of the text
      ObjectSetInteger(0, name, OBJPROP_COLOR, cl);
      //--- Set the font size for the text
      ObjectSetInteger(0, name, OBJPROP_FONTSIZE, fontsize);
      //--- Set the font type and style
      ObjectSetString(0, name, OBJPROP_FONT, "Arial Bold");
      //--- Anchor the text depending on whether it's a swing high or low
      if(isHigh)
         ObjectSetInteger(0, name, OBJPROP_ANCHOR, ANCHOR_BOTTOM);
      else
         ObjectSetInteger(0, name, OBJPROP_ANCHOR, ANCHOR_TOP);
      //--- Center-align the text
      ObjectSetInteger(0, name, OBJPROP_ALIGN, ALIGN_CENTER);
   }
}

Agora, implementaremos as funções de visualização para representar claramente o padrão harmônico "5 Drives" e seus níveis de negociação. Começaremos pela função "DrawTriangle", que utiliza ObjectCreate para desenhar um triângulo preenchido (OBJ_TRIANGLE), definido por três pontos com coordenadas de tempo ("t1", "t2", "t3") e preço ("p1", "p2", "p3"). Por meio da função ObjectSetInteger, configuraremos OBJPROP_COLOR com a cor especificada, OBJPROP_STYLE com STYLE_SOLID, OBJPROP_WIDTH com a largura definida, OBJPROP_FILL para ativar ou desativar o preenchimento e OBJPROP_BACK para determinar se o objeto será exibido em primeiro plano ou em segundo plano.

Em seguida, implementaremos a função "DrawTrendLine", que cria uma linha de tendência (OBJ_TREND) entre dois pontos. Depois, desenvolveremos "DrawDottedLine", responsável por desenhar uma linha horizontal pontilhada (OBJ_TREND) no nível de preço especificado. Por fim, criaremos a função "DrawTextEx", que utiliza ObjectCreate para adicionar um rótulo de texto (OBJ_TEXT) nas coordenadas de tempo e preço ("t", "p"). Configuraremos OBJPROP_TEXT com o texto especificado, OBJPROP_COLOR com a cor desejada, OBJPROP_FONTSIZE com o tamanho da fonte e OBJPROP_FONT com "Arial Bold", utilizando ObjectSetString e ObjectSetInteger conforme o tipo de propriedade. Com OBJPROP_ANCHOR, posicionaremos o texto acima das máximas de swing ou abaixo das mínimas de swing, de acordo com "isHigh", e utilizaremos OBJPROP_ALIGN para definir seu alinhamento centralizado. Agora, passaremos ao tratamento do evento OnTick para identificar os pontos de reversão que serão utilizados posteriormente no reconhecimento dos padrões. Vejamos como essa lógica funciona.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick() {
   //--- Declare a static variable to store the time of the last processed bar
   static datetime lastBarTime = 0;
   //--- Get the time of the current confirmed bar
   datetime currentBarTime = iTime(_Symbol, _Period, 1);
   //--- If the current bar time is the same as the last processed, exit
   if(currentBarTime == lastBarTime)
      return;
   //--- Update the last processed bar time
   lastBarTime = currentBarTime;
  
   //--- Clear the pivot array for fresh analysis
   ArrayResize(pivots, 0);
   //--- Get the total number of bars available on the chart
   int barsCount = Bars(_Symbol, _Period);
   //--- Define the starting index for pivot detection (ensuring enough left bars)
   int start = PivotLeft;
   //--- Define the ending index for pivot detection (ensuring enough right bars)
   int end = barsCount - PivotRight;
  
   //--- Loop through bars from 'end-1' down to 'start' to find pivot points
   for(int i = end - 1; i >= start; i--) {
      //--- Assume current bar is both a potential swing high and swing low
      bool isPivotHigh = true;
      bool isPivotLow = true;
      //--- Get the high and low of the current bar
      double currentHigh = iHigh(_Symbol, _Period, i);
      double currentLow = iLow(_Symbol, _Period, i);
      //--- Loop through the window of bars around the current bar
      for(int j = i - PivotLeft; j <= i + PivotRight; j++) {
         //--- Skip if the index is out of bounds
         if(j < 0 || j >= barsCount)
            continue;
         //--- Skip comparing the bar with itself
         if(j == i)
            continue;
         //--- If any bar in the window has a higher high, it's not a swing high
         if(iHigh(_Symbol, _Period, j) > currentHigh)
            isPivotHigh = false;
         //--- If any bar in the window has a lower low, it's not a swing low
         if(iLow(_Symbol, _Period, j) < currentLow)
            isPivotLow = false;
      }
      //--- If the current bar qualifies as either a swing high or swing low
      if(isPivotHigh || isPivotLow) {
         //--- Create a new pivot structure
         Pivot p;
         //--- Set the pivot's time
         p.time = iTime(_Symbol, _Period, i);
         //--- Set the pivot's price depending on whether it is a high or low
         p.price = isPivotHigh ? currentHigh : currentLow;
         //--- Set the pivot type (true for swing high, false for swing low)
         p.isHigh = isPivotHigh;
         //--- Get the current size of the pivots array
         int size = ArraySize(pivots);
         //--- Increase the size of the pivots array by one
         ArrayResize(pivots, size + 1);
         //--- Add the new pivot to the array
         pivots[size] = p;
      }
   }
}

Começaremos implementando a lógica inicial de OnTick para detectar os pontos de reversão, etapa fundamental para o reconhecimento do padrão. Primeiro, declararemos a variável estática "lastBarTime", inicializada com 0, para registrar o horário da última barra processada e compará-lo com "currentBarTime", obtido por meio de iTime com deslocamento 1 para o símbolo e o período atuais. Se o horário não tiver mudado, encerraremos a execução para evitar processamento desnecessário. Quando uma nova barra for detectada, atualizaremos "lastBarTime". Em seguida, esvaziaremos o array "pivots" com ArrayResize para iniciar uma nova análise. Obteremos o número total de barras por meio de Bars, definiremos o intervalo de busca dos pontos de reversão, atribuindo "PivotLeft" a "start" e o número total de barras menos "PivotRight" a "end", e percorreremos as barras desse intervalo.

Para cada barra, começaremos supondo que ela possa representar tanto uma máxima de swing ("isPivotHigh" = true) quanto uma mínima de swing ("isPivotLow" = true), obtendo seus preços máximo e mínimo por meio de iHigh e iLow. Em seguida, verificaremos as barras vizinhas dentro dos limites definidos por "PivotLeft" e "PivotRight", utilizando iHigh e iLow para confirmar os pontos de reversão. A condição de máxima de swing será descartada se alguma barra vizinha apresentar uma máxima superior, enquanto a condição de mínima de swing será descartada se houver uma mínima inferior. Se a barra atender aos critérios de um ponto de reversão, criaremos uma instância da estrutura "Pivot", preencheremos o campo "time" com o horário obtido por iTime, definiremos "price" com o preço máximo ou mínimo conforme "isPivotHigh" e atribuiremos o valor correspondente ao flag "isHigh". Por fim, ampliaremos o array "pivots" com ArrayResize e armazenaremos a estrutura. Ao exibir os dados dos pontos de reversão, obteremos um array semelhante ao apresentado a seguir.

Exemplo de dados dos pontos de reversão

Com esses dados, podemos identificar os pontos de reversão e, quando houver uma quantidade suficiente deles, analisar a sequência para reconhecer possíveis padrões. A lógica necessária é apresentada a seguir.

//--- Determine the total number of pivots found
int pivotCount = ArraySize(pivots);
//--- If fewer than six pivots are found, the pattern cannot be formed
if(pivotCount < 6) {
   //--- Reset pattern lock variables
   g_patternFormationBar = -1;
   g_lockedPatternA = 0;
   //--- Exit the OnTick function
   return;
}

//--- Extract the last six pivots as A, B, C, D, E, F
Pivot A = pivots[pivotCount - 6];
Pivot B = pivots[pivotCount - 5];
Pivot C = pivots[pivotCount - 4];
Pivot D = pivots[pivotCount - 3];
Pivot E = pivots[pivotCount - 2];
Pivot F = pivots[pivotCount - 1];

//--- Initialize a flag to indicate if a valid 5 Drives pattern is found
bool patternFound = false;
//--- Initialize pattern type
string patternType = "";
//--- Check for the high-low-high-low-high-low (Bullish reversal) structure
if(A.isHigh && (!B.isHigh) && C.isHigh && (!D.isHigh) && E.isHigh && (!F.isHigh)) {
   //--- Calculate XA length
   double XA_length = C.price - B.price;
   //--- Calculate AB length
   double AB_length = C.price - D.price;
   //--- Check AB extension of XA
   if(AB_length >= 1.13 * XA_length && AB_length <= 1.618 * XA_length) {
      //--- Calculate BC length
      double BC_length = E.price - D.price;
      //--- Check BC extension of AB
      if(BC_length >= 1.618 * AB_length && BC_length <= 2.24 * AB_length) {
         //--- Calculate CD length
         double CD_length = E.price - F.price;
         //--- Check 50% retracement of BC
         double ideal_retrace = 0.5 * BC_length;
         if(MathAbs(CD_length - ideal_retrace) <= Tolerance * BC_length) {
            //--- Check reciprocal AB=CD
            if(MathAbs(CD_length - AB_length) <= Tolerance * AB_length) {
               //--- Additional conditions: higher high at E, D above B
               if(E.price > C.price && F.price > B.price) {
                  patternFound = true;
                  patternType = "Bullish";
               }
            }
         }
      }
   }
}
//--- Check for the low-high-low-high-low-high (Bearish reversal) structure
if((!A.isHigh) && B.isHigh && (!C.isHigh) && D.isHigh && (!E.isHigh) && F.isHigh) {
   //--- Calculate XA length
   double XA_length = B.price - C.price;
   //--- Calculate AB length
   double AB_length = D.price - C.price;
   //--- Check AB extension of XA
   if(AB_length >= 1.13 * XA_length && AB_length <= 1.618 * XA_length) {
      //--- Calculate BC length
      double BC_length = D.price - E.price;
      //--- Check BC extension of AB
      if(BC_length >= 1.618 * AB_length && BC_length <= 2.24 * AB_length) {
         //--- Calculate CD length
         double CD_length = F.price - E.price;
         //--- Check 50% retracement of BC
         double ideal_retrace = 0.5 * BC_length;
         if(MathAbs(CD_length - ideal_retrace) <= Tolerance * BC_length) {
            //--- Check reciprocal AB=CD
            if(MathAbs(CD_length - AB_length) <= Tolerance * AB_length) {
               //--- Additional conditions: lower low at E, D below B
               if(E.price < C.price && F.price < B.price) {
                  patternFound = true;
                  patternType = "Bearish";
               }
            }
         }
      }
   }
}

Primeiro, obteremos o número total de pontos de reversão com "ArraySize(pivots)" e armazenaremos o resultado em "pivotCount". Se forem encontrados menos de seis pontos, redefiniremos "g_patternFormationBar" como -1 e "g_lockedPatternA" como 0 e encerraremos a chamada atual de OnTick, pois o reconhecimento do padrão "5 Drives" exige seis pontos de reversão: A, B, C, D, E e F.

Em seguida, extrairemos os seis pontos de reversão mais recentes do array "pivots" e os atribuiremos às variáveis "A" (ponto mais antigo), "B", "C", "D", "E" e "F" (ponto mais recente). Para o padrão de alta (máxima A, mínima B, máxima C, mínima D, máxima E e mínima F), calcularemos o comprimento XA ("C.price - B.price") e o comprimento AB ("C.price - D.price"), verificando se AB corresponde a um valor entre 1,13 e 1,618 vezes XA. Também calcularemos BC ("E.price - D.price"), que deve corresponder a um valor entre 1,618 e 2,24 vezes AB, e CD ("E.price - F.price"), verificando se representa uma retração de 0,5 (50%) de BC e se equivale a AB dentro da margem definida por "Tolerance". Além disso, confirmaremos que E é uma máxima superior a C e que F está acima de B. Se todos os critérios forem atendidos, definiremos "patternFound" como true e "patternType" como Bullish. Para o padrão de baixa (mínima A, máxima B, mínima C, máxima D, mínima E e máxima F), aplicaremos verificações equivalentes aos comprimentos XA ("B.price - C.price"), AB ("D.price - C.price"), BC ("D.price - E.price") e CD ("F.price - E.price"), garantindo que E esteja abaixo da mínima C e F abaixo de B. Nesse caso, definiremos "patternFound" como true e "patternType" como Bearish. Uma vez identificado o padrão, poderemos representá-lo no gráfico.

//--- If a valid 5 Drives pattern is detected
if(patternFound) {
   //--- Print a message indicating the pattern type and detection time
   Print(patternType, " 5 Drives pattern detected at ", TimeToString(F.time, TIME_DATE|TIME_MINUTES|TIME_SECONDS));
  
   //--- Create a unique prefix for all graphical objects related to this pattern
   string signalPrefix = "5D_" + IntegerToString(A.time);
  
   //--- Choose triangle color based on the pattern type
   color triangleColor = (patternType=="Bullish") ? clrBlue : clrRed;
  
   //--- Draw the first triangle connecting pivots B, C, D
   DrawTriangle(signalPrefix+"_Triangle1", B.time, B.price, C.time, C.price, D.time, D.price,
                triangleColor, 2, true, true);
   //--- Draw the second triangle connecting pivots D, E, F
   DrawTriangle(signalPrefix+"_Triangle2", D.time, D.price, E.time, E.price, F.time, F.price,
                triangleColor, 2, true, true);
}

Agora, vamos exibir os padrões detectados no gráfico. Primeiro, quando um padrão válido for identificado ("patternFound" = true), utilizaremos a função Print para registrar sua detecção no log, incluindo o valor de "patternType" ("Bullish" ou "Bearish") e o horário do ponto de reversão F, formatado por TimeToString com data, minutos e segundos. Em seguida, criaremos um identificador exclusivo chamado "signalPrefix", concatenando "5D_" com o valor de "A.time", convertido em string pela função IntegerToString. Esse identificador permitirá atribuir nomes específicos aos objetos gráficos associados ao padrão.

Depois, definiremos "triangleColor" como azul para os padrões de alta e vermelho para os padrões de baixa, facilitando sua identificação visual. Por fim, chamaremos "DrawTriangle" duas vezes para representar o padrão: primeiro, desenharemos o triângulo BCD, conectando os pontos de reversão B, C e D; depois, desenharemos o triângulo DEF, conectando D, E e F. Utilizaremos "signalPrefix" com os sufixos "_Triangle1" e "_Triangle2", respectivamente, além das coordenadas de tempo e preço dos pontos correspondentes, da cor definida em "triangleColor" e de uma largura de linha igual a 2. Também ativaremos o preenchimento e a exibição em segundo plano, definindo os respectivos flags como true. O resultado será o seguinte.

Conjunto de triângulos

A imagem mostra que conseguimos representar corretamente o padrão detectado por meio dos triângulos. Agora, adicionaremos linhas de tendência para completar o contorno da formação, além de rótulos que facilitarão a identificação dos níveis.

//--- Draw boundary trend lines connecting the pivots for clarity
DrawTrendLine(signalPrefix+"_TL_AB", A.time, A.price, B.time, B.price, clrBlack, 2, STYLE_SOLID);
DrawTrendLine(signalPrefix+"_TL_BC", B.time, B.price, C.time, C.price, clrBlack, 2, STYLE_SOLID);
DrawTrendLine(signalPrefix+"_TL_CD", C.time, C.price, D.time, D.price, clrBlack, 2, STYLE_SOLID);
DrawTrendLine(signalPrefix+"_TL_DE", D.time, D.price, E.time, E.price, clrBlack, 2, STYLE_SOLID);
DrawTrendLine(signalPrefix+"_TL_EF", E.time, E.price, F.time, F.price, clrBlack, 2, STYLE_SOLID);

//--- Retrieve the symbol's point size to calculate offsets for text positioning
double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
//--- Calculate an offset (15 points) for positioning text above or below pivots
double offset = 15 * point;

//--- Determine the Y coordinate for each pivot label based on its type
double textY_A = (A.isHigh ? A.price + offset : A.price - offset);
double textY_B = (B.isHigh ? B.price + offset : B.price - offset);
double textY_C = (C.isHigh ? C.price + offset : C.price - offset);
double textY_D = (D.isHigh ? D.price + offset : D.price - offset);
double textY_E = (E.isHigh ? E.price + offset : E.price - offset);
double textY_F = (F.isHigh ? F.price + offset : F.price - offset);

//--- Draw text labels for each pivot with appropriate anchoring
DrawTextEx(signalPrefix+"_Text_A", "A", A.time, textY_A, clrBlack, 11, A.isHigh);
DrawTextEx(signalPrefix+"_Text_B", "B", B.time, textY_B, clrBlack, 11, B.isHigh);
DrawTextEx(signalPrefix+"_Text_C", "C", C.time, textY_C, clrBlack, 11, C.isHigh);
DrawTextEx(signalPrefix+"_Text_D", "D", D.time, textY_D, clrBlack, 11, D.isHigh);
DrawTextEx(signalPrefix+"_Text_E", "E", E.time, textY_E, clrBlack, 11, E.isHigh);
DrawTextEx(signalPrefix+"_Text_F", "F", F.time, textY_F, clrBlack, 11, F.isHigh);

//--- Calculate the central label's time as the midpoint between pivots A and D
datetime centralTime = (A.time + D.time) / 2;
//--- Set the central label's price at pivot F's price
double centralPrice = F.price;
//--- Create the central text label indicating the pattern type
if(ObjectCreate(0, signalPrefix+"_Text_Center", OBJ_TEXT, 0, centralTime, centralPrice)) {
   ObjectSetString(0, signalPrefix+"_Text_Center", OBJPROP_TEXT,
      (patternType=="Bullish") ? "Bullish 5 Drives" : "Bearish 5 Drives");
   ObjectSetInteger(0, signalPrefix+"_Text_Center", OBJPROP_COLOR, clrBlack);
   ObjectSetInteger(0, signalPrefix+"_Text_Center", OBJPROP_FONTSIZE, 11);
   ObjectSetString(0, signalPrefix+"_Text_Center", OBJPROP_FONT, "Arial Bold");
   ObjectSetInteger(0, signalPrefix+"_Text_Center", OBJPROP_ALIGN, ALIGN_CENTER);
}

Em seguida, aprimoraremos a visualização dos padrões identificados com objetos gráficos adicionais, permitindo representar sua estrutura com mais clareza. Primeiro, desenharemos cinco linhas de tendência contínuas utilizando "DrawTrendLine" e o identificador exclusivo "signalPrefix" para conectar os principais pontos de reversão: AB, BC, CD, DE e EF. Cada linha utilizará as coordenadas de tempo e preço dos respectivos pontos (por exemplo, "A.time" e "A.price"). Por meio de ObjectSetInteger, configuraremos OBJPROP_COLOR como "clrBlack", OBJPROP_WIDTH como 2 e OBJPROP_STYLE como "STYLE_SOLID", formando o contorno completo do padrão. Depois, obteremos o tamanho de um ponto do símbolo por meio de "SymbolInfoDouble(_Symbol, SYMBOL_POINT)" e calcularemos um deslocamento equivalente a 15 pontos para posicionar os rótulos. Definiremos as coordenadas verticais ("textY_A", "textY_B", "textY_C", "textY_D", "textY_E", "textY_F") adicionando ou subtraindo esse deslocamento conforme a classificação de cada ponto de reversão: máxima de swing ("isHigh" = true) ou mínima de swing. Dessa forma, os rótulos ficarão posicionados acima das máximas e abaixo das mínimas.

Em seguida, utilizaremos "DrawTextEx" para criar rótulos de texto para os pontos de reversão A, B, C, D, E e F, usando "signalPrefix" com sufixos como "_Text_A", de modo que cada rótulo exiba a letra correspondente, posicionada no instante de tempo do respectivo ponto de reversão e ajustada na coordenada Y. Para essa marcação, utilizaremos a cor "clrBlack", tamanho de fonte 11 e o status "isHigh" do ponto de reversão. Por fim, calcularemos a posição central do rótulo, definindo "centralTime" como o ponto médio entre "A.time" e "D.time" e "centralPrice" como "F.price", criando então um objeto de texto com "ObjectCreate" e o nome "signalPrefix + '_Text_Center'". Configuraremos OBJPROP_TEXT com o valor "Bullish 5 Drives" ou "Bearish 5 Drives", de acordo com "patternType", e ajustaremos OBJPROP_COLOR para "clrBlack", OBJPROP_FONTSIZE para 11, OBJPROP_FONT para "Arial Bold" e OBJPROP_ALIGN para "ALIGN_CENTER" por meio das funções ObjectSetString e ObjectSetInteger. Após a execução do programa, obtemos a seguinte visualização.

Padrão com rótulos e contornos

A imagem mostra que adicionamos linhas de contorno e rótulos ao padrão, tornando sua visualização mais clara. O próximo passo é definir os níveis operacionais do padrão.

//--- Define start and end times for drawing horizontal dotted lines for trade levels
datetime lineStart = F.time;
datetime lineEnd = F.time + PeriodSeconds(_Period)*2;

//--- Declare variables for entry price and take profit levels
double entryPriceLevel, TP1Level, TP2Level, TP3Level, tradeDiff;
//--- Calculate trade levels based on whether the pattern is Bullish or Bearish
if(patternType=="Bullish") { //--- Bullish → BUY signal
   //--- Use the current ASK price as the entry
   entryPriceLevel = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   //--- Set TP3 at pivot E's price
   TP3Level = E.price;
   //--- Calculate the total distance to be covered by the trade
   tradeDiff = TP3Level - entryPriceLevel;
   //--- Set TP1 at one-third of the total move
   TP1Level = entryPriceLevel + tradeDiff/3;
   //--- Set TP2 at two-thirds of the total move
   TP2Level = entryPriceLevel + 2*tradeDiff/3;
} else { //--- Bearish → SELL signal
   //--- Use the current BID price as the entry
   entryPriceLevel = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   //--- Set TP3 at pivot E's price
   TP3Level = E.price;
   //--- Calculate the total distance to be covered by the trade
   tradeDiff = entryPriceLevel - TP3Level;
   //--- Set TP1 at one-third of the total move
   TP1Level = entryPriceLevel - tradeDiff/3;
   //--- Set TP2 at two-thirds of the total move
   TP2Level = entryPriceLevel - 2*tradeDiff/3;
}

//--- Draw dotted horizontal lines to represent the entry and TP levels
DrawDottedLine(signalPrefix+"_EntryLine", lineStart, entryPriceLevel, lineEnd, clrMagenta);
DrawDottedLine(signalPrefix+"_TP1Line", lineStart, TP1Level, lineEnd, clrForestGreen);
DrawDottedLine(signalPrefix+"_TP2Line", lineStart, TP2Level, lineEnd, clrGreen);
DrawDottedLine(signalPrefix+"_TP3Line", lineStart, TP3Level, lineEnd, clrDarkGreen);

//--- Define a label time coordinate positioned just to the right of the dotted lines
datetime labelTime = lineEnd + PeriodSeconds(_Period)/2;

//--- Construct the entry label text with the price
string entryLabel = (patternType=="Bullish") ? "BUY (" : "SELL (";
entryLabel += DoubleToString(entryPriceLevel, _Digits) + ")";
//--- Draw the entry label on the chart
DrawTextEx(signalPrefix+"_EntryLabel", entryLabel, labelTime, entryPriceLevel, clrMagenta, 11, true);

//--- Construct and draw the TP1 label
string tp1Label = "TP1 (" + DoubleToString(TP1Level, _Digits) + ")";
DrawTextEx(signalPrefix+"_TP1Label", tp1Label, labelTime, TP1Level, clrForestGreen, 11, true);

//--- Construct and draw the TP2 label
string tp2Label = "TP2 (" + DoubleToString(TP2Level, _Digits) + ")";
DrawTextEx(signalPrefix+"_TP2Label", tp2Label, labelTime, TP2Level, clrGreen, 11, true);

//--- Construct and draw the TP3 label
string tp3Label = "TP3 (" + DoubleToString(TP3Level, _Digits) + ")";
DrawTextEx(signalPrefix+"_TP3Label", tp3Label, labelTime, TP3Level, clrDarkGreen, 11, true);

Para definir e visualizar os níveis operacionais do padrão detectado, atribuiremos a "lineStart" o horário do ponto de reversão F ("F.time") e a "lineEnd" um ponto situado dois períodos à frente, utilizando "PeriodSeconds(_Period) * 2". Declararemos as variáveis "entryPriceLevel", "TP1Level", "TP2Level" e "TP3Level" para os cálculos da operação. Em seguida, para o padrão de alta ("patternType == 'Bullish'"), definiremos "entryPriceLevel" como o preço ask atual, obtido com "SymbolInfoDouble", e "TP3Level" como o preço do ponto de reversão E. Calcularemos "tradeDiff" como "TP3Level - entryPriceLevel", e "TP1Level" e "TP2Level" como um terço e dois terços de "tradeDiff", somados a "entryPriceLevel". Para o padrão de baixa, utilizaremos o preço bid, definiremos "TP3Level" como o preço de E, calcularemos "tradeDiff" como "entryPriceLevel - TP3Level" e obteremos "TP1Level" e "TP2Level" subtraindo um terço e dois terços dessa diferença a partir do preço de entrada.

Em seguida, com a função "DrawDottedLine", desenharemos quatro linhas horizontais pontilhadas: a linha de entrada no nível "entryPriceLevel", em cor púrpura, e as linhas de take-profit nos níveis "TP1Level" (verde floresta escuro), "TP2Level" (verde) e "TP3Level" (verde escuro), estendendo-se de "lineStart" até "lineEnd". Por fim, definiremos "labelTime" como "lineEnd" acrescido de metade de um período e criaremos rótulos de texto com os preços formatados por meio da função "DoubleToString" (por exemplo, "BUY (price)" ou "SELL (price)" para a entrada, "TP1 (price)" e assim por diante). Utilizaremos "DrawTextEx" para desenhar esses rótulos em "labelTime", com as cores correspondentes, tamanho de fonte 11 e ancoragem acima dos níveis de preço. Após a compilação, obteremos o seguinte resultado.

Padrão de baixa:

Padrão de baixa

Padrão de alta:

Padrão de alta

As imagens mostram que os níveis operacionais foram representados corretamente no gráfico. Agora, falta implementar a abertura das posições.

//--- Retrieve the index of the current bar
int currentBarIndex = Bars(_Symbol, _Period) - 1;
//--- If no pattern has been previously locked, lock the current pattern formation
if(g_patternFormationBar == -1) {
   g_patternFormationBar = currentBarIndex;
   g_lockedPatternA = A.time;
   //--- Print a message that the pattern is detected and waiting for confirmation
   Print("Pattern detected on bar ", currentBarIndex, ". Waiting for confirmation on next bar.");
   return;
}
//--- If still on the same formation bar, the pattern is considered to be repainting
if(currentBarIndex == g_patternFormationBar) {
   Print("Pattern is repainting; still on locked formation bar ", currentBarIndex, ". No trade yet.");
   return;
}
//--- If we are on a new bar compared to the locked formation
if(currentBarIndex > g_patternFormationBar) {
   //--- Check if the locked pattern still corresponds to the same A pivot
   if(g_lockedPatternA == A.time) {
      Print("Confirmed pattern (locked on bar ", g_patternFormationBar, "). Opening trade on bar ", currentBarIndex, ".");
      //--- Update the pattern formation bar to the current bar
      g_patternFormationBar = currentBarIndex;
      //--- Only proceed with trading if allowed and if there is no existing position
      if(AllowTrading && !PositionSelect(_Symbol)) {
         //--- Check if this pattern has already been traded
         bool alreadyTraded = false;
         for(int k = 0; k < ArraySize(tradedPatterns); k++) {
            if(tradedPatterns[k] == A.time) {
               alreadyTraded = true;
               break;
            }
         }
         if(alreadyTraded) {
            Print("This pattern has already been traded. No new trade executed.");
            return;
         }
         double entryPriceTrade = 0, stopLoss = 0, takeProfit = 0;
         point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
         bool tradeResult = false;
         //--- Select TP level based on user input
         switch(TakeProfitLevel) {
            case TP1:
               takeProfit = TP1Level;
               break;
            case TP2:
               takeProfit = TP2Level;
               break;
            case TP3:
               takeProfit = TP3Level;
               break;
            default:
               takeProfit = TP2Level; // Fallback to TP2
         }
         //--- Calculate SL based on user-selected method
         if(patternType=="Bullish") { //--- BUY signal
            entryPriceTrade = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
            if(StopLossType == SL_FIBO) {
               double third_drive = E.price - F.price;
               stopLoss = F.price - (SL_FiboExtension - 1.0) * third_drive;
            } else { // SL_FIXED
               stopLoss = entryPriceTrade - SL_FixedPoints * point;
            }
            // Ensure SL is below entry for BUY
            if(stopLoss >= entryPriceTrade) {
               stopLoss = entryPriceTrade - 10 * point;
            }
            tradeResult = obj_Trade.Buy(LotSize, _Symbol, entryPriceTrade, stopLoss, takeProfit, "5 Drives Signal");
            if(tradeResult)
               Print("Buy order opened successfully.");
            else
               Print("Buy order failed: ", obj_Trade.ResultRetcodeDescription());
         }
         //--- For a Bearish pattern, execute a SELL trade
         else if(patternType=="Bearish") { //--- SELL signal
            entryPriceTrade = SymbolInfoDouble(_Symbol, SYMBOL_BID);
            if(StopLossType == SL_FIBO) {
               double third_drive = F.price - E.price;
               stopLoss = F.price + (SL_FiboExtension - 1.0) * third_drive;
            } else { // SL_FIXED
               stopLoss = entryPriceTrade + SL_FixedPoints * point;
            }
            // Ensure SL is above entry for SELL
            if(stopLoss <= entryPriceTrade) {
               stopLoss = entryPriceTrade + 10 * point;
            }
            tradeResult = obj_Trade.Sell(LotSize, _Symbol, entryPriceTrade, stopLoss, takeProfit, "5 Drives Signal");
            if(tradeResult)
               Print("Sell order opened successfully.");
            else
               Print("Sell order failed: ", obj_Trade.ResultRetcodeDescription());
         }
         //--- If trade was successful, mark the pattern as traded
         if(tradeResult) {
            int size = ArraySize(tradedPatterns);
            ArrayResize(tradedPatterns, size + 1);
            tradedPatterns[size] = A.time;
         }
      }
      else {
         //--- If a position is already open, do not execute a new trade
         Print("A position is already open for ", _Symbol, ". No new trade executed.");
      }
   }
   else {
      //--- If the pattern has changed, update the lock with the new formation bar and A pivot
      g_patternFormationBar = currentBarIndex;
      g_lockedPatternA = A.time;
      Print("Pattern has changed; updating lock on bar ", currentBarIndex, ". Waiting for confirmation.");
      return;
   }

}
else {
   //--- If no valid 5 Drives pattern is detected, reset the pattern lock variables
   g_patternFormationBar = -1;
   g_lockedPatternA = 0;
}

Na etapa final, implementaremos a confirmação do padrão e a abertura das operações. Primeiro, obteremos o índice da barra atual por meio da expressão "Bars(_Symbol, _Period) - 1" e armazenaremos o resultado em "currentBarIndex". Em seguida, se nenhum padrão estiver registrado ("g_patternFormationBar == -1"), atribuiremos "currentBarIndex" a "g_patternFormationBar", armazenaremos o horário do ponto de reversão A em "g_lockedPatternA", utilizando "A.time", e registraremos a detecção com Print, indicando que o sistema está aguardando a confirmação. Depois, encerraremos a execução da função.

Se o padrão ainda estiver na barra em que foi detectado ("currentBarIndex == g_patternFormationBar"), consideraremos que sua formação ainda pode sofrer alterações e sairemos da função para evitar operações prematuras. Quando uma nova barra for formada ("currentBarIndex > g_patternFormationBar") e o horário do ponto de reversão A corresponder ao valor armazenado em "g_lockedPatternA", confirmaremos o padrão, registraremos a confirmação no log e atualizaremos "g_patternFormationBar". Em seguida, verificaremos se as operações estão habilitadas por meio de "AllowTrading" e se não há uma posição aberta para o símbolo consultado, utilizando a função PositionSelect. Também verificaremos o array "tradedPatterns" para garantir que o padrão ainda não tenha sido negociado. Selecionaremos o nível de take-profit ("TP1Level", "TP2Level" ou "TP3Level") de acordo com "TakeProfitLevel" e calcularemos o stop-loss utilizando "SL_FIBO", com base na fórmula "F.price ± (SL_FiboExtension - 1.0) × third_drive", ou "SL_FIXED", com base na fórmula "entryPriceTrade ± SL_FixedPoints × point". Depois de validar o nível de stop-loss, abriremos uma posição de compra ou venda por meio de "obj_Trade.Buy" ou "obj_Trade.Sell", utilizando "LotSize" e a identificação "5 Drives Signal". Registraremos o sucesso ou a falha da operação no log e, se a operação for bem-sucedida, adicionaremos o padrão ao array "tradedPatterns" para identificá-lo como já negociado. Se as operações estiverem desabilitadas, já existir uma posição aberta ou o padrão já tiver sido negociado, registraremos no log que nenhuma nova operação foi executada. Caso o padrão sofra alterações, atualizaremos os dados armazenados e aguardaremos uma nova confirmação. Se nenhum padrão for identificado, redefiniremos as variáveis globais. Após a compilação, obteremos o seguinte resultado.

Sinal de baixa:

Sinal de baixa

Sinal de alta:

Sinal de alta

A imagem mostra que o padrão harmônico é representado corretamente no gráfico e pode ser utilizado para executar operações após sua confirmação. Dessa forma, atingimos o objetivo de identificar o padrão, representá-lo graficamente e automatizar as operações com base nele. Resta realizar o backtesting do programa com dados históricos.


Backtesting com dados históricos

Após realizar um backtesting detalhado com dados históricos, obtivemos os seguintes resultados.

Gráfico de backtesting:

Gráfico

Relatório de backtesting:

Relatório


Conclusão

Concluímos o desenvolvimento de um sistema de reconhecimento do padrão "5 Drives" em MQL5. O sistema utiliza os movimentos dos preços para identificar padrões harmônicos "5 Drives" de alta e de baixa, com níveis precisos de retração e extensão de Fibonacci. Além disso, automatiza as operações com níveis calculados de entrada e stop-loss, além de níveis de take-profit em múltiplos patamares, representando visualmente os padrões por meio de objetos gráficos, como triângulos e linhas de tendência.

Atenção: todo o conteúdo deste artigo destina-se exclusivamente a fins educacionais e não deve ser utilizado para outras finalidades. A negociação nos mercados financeiros envolve riscos significativos, e a volatilidade pode resultar em perdas financeiras. Antes de utilizar este programa em operações reais, é fundamental realizar testes rigorosos com dados históricos e adotar práticas adequadas de gestão de risco.

Com base nos conceitos e métodos de implementação apresentados, você poderá adaptar o sistema de reconhecimento do padrão "5 Drives" ao seu estilo de negociação e aprimorar suas estratégias algorítmicas. Boas negociações!

Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/19463

Arquivos anexados |
Desenvolvimento de ferramentas para análise de Price Action (Parte 40): Perfil de DNA do mercado Desenvolvimento de ferramentas para análise de Price Action (Parte 40): Perfil de DNA do mercado
Este artigo analisa o perfil único de cada par de moedas com base no histórico de seus movimentos de preço. Inspirados no conceito de DNA, que contém o código genético exclusivo de cada ser vivo, aplicamos uma abordagem semelhante aos mercados, considerando a dinâmica dos preços como o "DNA" de cada par de moedas. Ao analisar características estruturais como volatilidade, swings, retrações, picos de preço e particularidades das sessões de negociação, a ferramenta identifica um perfil que distingue cada par dos demais. Essa abordagem permite compreender melhor o comportamento do mercado e ajuda os traders a alinhar sistematicamente suas estratégias aos padrões de comportamento de cada instrumento.
Como negociar Fair Value Gaps: regras de formação, cenários de mitigação e negociação automatizada com breakers e mudanças na estrutura do mercado Como negociar Fair Value Gaps: regras de formação, cenários de mitigação e negociação automatizada com breakers e mudanças na estrutura do mercado
Neste artigo, explico o conceito de lacunas de valor justo (Fair Value Gaps, FVGs), a lógica por trás de sua formação e surgimento, além de abordar a negociação automatizada com o uso de breakers e mudanças de estrutura de mercado (Market Structure Shifts, MSS).
Está chegando o novo MetaTrader 5 e MQL5 Está chegando o novo MetaTrader 5 e MQL5
Esta é apenas uma breve resenha do MetaTrader 5. Eu não posso descrever todos os novos recursos do sistema por um período tão curto de tempo - os testes começaram em 09.09.2009. Esta é uma data simbólica, e tenho certeza que será um número de sorte. Alguns dias passaram-se desde que eu obtive a versão beta do terminal MetaTrader 5 e MQL5. Eu ainda não consegui testar todos os seus recursos, mas já estou impressionado.
Decomposição em modos dinâmicos aplicada a séries temporais univariadas na linguagem MQL5 Decomposição em modos dinâmicos aplicada a séries temporais univariadas na linguagem MQL5
A decomposição em modos dinâmicos (Dynamic Mode Decomposition, DMD) é um método geralmente aplicado a conjuntos de dados multidimensionais. Neste artigo, demonstramos como aplicar o DMD a séries temporais univariadas, explorando sua capacidade de caracterizar essas séries e gerar previsões. Também examinaremos a implementação da decomposição em modos dinâmicos integrada ao MQL5, com atenção especial ao novo método matricial DynamicModeDecomposition().