English Русский 中文 Español Deutsch 日本語
preview
Automatização de estratégias de negociação em MQL5 (Parte 30): Criação e visualização do padrão harmônico AB=CD com base em Price Action

Automatização de estratégias de negociação em MQL5 (Parte 30): Criação e visualização do padrão harmônico AB=CD com base em Price Action

MetaTrader 5 — Negociação |
31 2
Allan Munene Mutiiria
Allan Munene Mutiiria

Introdução

No artigo anterior (Parte 29), criamos um sistema de reconhecimento do padrão harmônico "Gartley" em MetaQuotes Language 5 (MQL5). Desenvolvemos uma solução capaz de identificar padrões de alta e de baixa com base em níveis precisos de Fibonacci, automatizar a abertura de operações utilizando níveis calculados de entrada, stop-loss e take-profit e representar os padrões no gráfico por meio de objetos como triângulos e linhas de tendência. Nesta Parte 30, implementaremos um sistema de reconhecimento do padrão AB=CD. Enquanto o sistema de Gartley identifica estruturas harmônicas mais complexas, compostas por vários movimentos e definidas por múltiplas proporções de Fibonacci, o sistema AB=CD concentra-se em reconhecer padrões formados por dois segmentos de preço equivalentes (AB e CD), identificados a partir de pontos de reversão e de coeficientes específicos de retração e extensão de Fibonacci. Isso permite identificar os padrões de forma mais simples e dinâmica. O sistema AB=CD automatiza a abertura de operações com pontos de entrada dinâmicos e alvos de take-profit em diferentes níveis. A visualização também é aprimorada com triângulos, linhas de tendência e rótulos que permitem identificar claramente a estrutura dos padrões. Neste artigo, abordaremos os seguintes tópicos:

  1. Entendendo a estrutura do padrão harmônico AB=CD
  2. Implementação em MQL5
  3. Backtesting
  4. Conclusão

Ao final, você terá uma estratégia de negociação baseada no padrão AB=CD, implementada em MQL5, robusta e pronta para ser configurada. Vamos à implementação!


Entendendo a estrutura do padrão harmônico AB=CD

O padrão AB=CD é uma formação harmônica utilizada para identificar zonas potenciais de reversão do preço a partir de quatro pontos principais: A, B, C e D. Ele pode apresentar uma configuração de alta ou de baixa e utiliza níveis de Fibonacci para identificar com precisão setups de negociação de alta probabilidade. No padrão AB=CD de alta, a estrutura segue uma sequência de máxima, mínima, máxima e mínima: A corresponde a um swing high, B a um swing low, C a outro swing high e D a um swing low situado abaixo de B. Os segmentos AB e CD têm a mesma amplitude de preço ou apresentam relações definidas por coeficientes de retração e extensão de Fibonacci. Já o padrão AB=CD de baixa segue a sequência inversa, de mínima, máxima, mínima e máxima, com o ponto D situado acima de B. Veja a representação visual dos dois padrões:

Padrão harmônico AB=CD de baixa:

BEARISH HARMONIC AB=CD PATTERN

Padrão harmônico AB=CD de alta:

BULLISH HARMONIC AB=CD PATTERN

Nossa abordagem consiste em identificar esses pontos de reversão em um intervalo definido de barras e validar o padrão, verificando se a retração do segmento BC corresponde a 0,382–0,886 de AB e se a extensão do segmento CD fica entre 1,13 e 2,618 vezes a amplitude de BC. Também representamos o padrão por meio de objetos gráficos, como triângulos e linhas de tendência, para facilitar sua identificação. Além disso, a estratégia prevê a abertura de operações no ponto D, com um stop-loss calculado e múltiplos níveis de take-profit definidos com base nas retrações de Fibonacci, buscando aproveitar os movimentos de reversão esperados. Vamos à implementação!


Implementação em MQL5

Para criar o programa em MQL5, abra o MetaEditor, acesse o Navegador, localize a pasta "Indicadores" (Indicators), selecione a opção "Novo" (New) e siga as instruções para criar o arquivo. Depois de concluir essa etapa, precisaremos declarar algumas variáveis globais no ambiente de desenvolvimento, que serão utilizadas em diferentes partes do programa.

//+------------------------------------------------------------------+
//|                                              ABCD 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 AB=CD 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

//--- 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 AB move)
input double LotSize = 0.01;      // Lot size for new orders
input bool AllowTrading = true;   // Enable or disable trading
//---------------------------------------------------------------------------

//--- 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

Para estabelecer a base do sistema de reconhecimento do padrão AB=CD, começaremos incluindo a biblioteca "<Trade\Trade.mqh>" e criando uma instância da classe CTrade chamada "obj_Trade", responsável por gerenciar operações de negociação, como a abertura de posições de compra e venda. Em seguida, definiremos cinco parâmetros de entrada que permitirão personalizar o funcionamento do sistema. Os parâmetros "PivotLeft" e "PivotRight" terão o valor de 5 barras cada, definindo a quantidade de barras analisadas à esquerda e à direita de cada possível ponto de reversão. O parâmetro "Tolerance" será definido como 0,10, permitindo uma margem de tolerância de 10% nas proporções de Fibonacci. Já "LotSize" será definido como 0,01 lote, estabelecendo o volume de cada operação, enquanto "AllowTrading" será definido como true para habilitar a negociação automática.

Na sequência, definiremos a estrutura "Pivot", composta pelos campos "time" (datetime), "price" (double) e "isHigh" (bool), para armazenar os pontos de reversão do preço. Também declararemos "pivots" como um array dinâmico destinado a armazenar esses pontos e inicializaremos duas variáveis globais: "g_patternFormationBar" com o valor -1, para acompanhar a barra em que o padrão se forma, e "g_lockedPatternA" com o valor 0, para armazenar o horário do ponto de reversão A utilizado na confirmação do padrão. Observe que utilizamos A em vez de X, pois o padrão AB=CD se concentra nos segmentos AB e CD. Com essa estrutura, estabelecemos a base necessária para identificar os padrões AB=CD e executar operações a partir deles. Para a visualização, 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 AB=CD e seus níveis de negociação no gráfico. Começaremos criando a função "DrawTriangle", que utiliza ObjectCreate para desenhar um triângulo preenchido (OBJ_TRIANGLE), definido por três pontos, cada um com suas coordenadas de tempo ("t1", "t2", "t3") e preço ("p1", "p2", "p3"). Em seguida, utilizaremos a função ObjectSetInteger para configurar as propriedades do objeto: "OBJPROP_COLOR" receberá a cor especificada, "OBJPROP_STYLE" será definido como STYLE_SOLID, "OBJPROP_WIDTH" receberá a largura desejada, "OBJPROP_FILL" controlará a ativação ou desativação do preenchimento e "OBJPROP_BACK" determinará se o triângulo será exibido no plano de fundo ou em primeiro plano.

Em seguida, implementaremos a função "DrawTrendLine", que cria uma linha de tendência (OBJ_TREND) entre dois pontos. Por fim, desenvolveremos a função "DrawTextEx", responsável por criar um rótulo de texto (OBJ_TEXT) nas coordenadas de tempo e preço ("t", "p") utilizando ObjectCreate. Configuraremos "OBJPROP_TEXT" com o texto especificado, "OBJPROP_COLOR" com a cor desejada, "OBJPROP_FONTSIZE" com o tamanho da fonte e "OBJPROP_FONT" com a fonte "Arial Bold", utilizando as funções ObjectSetString e ObjectSetInteger. Com base no valor de "isHigh", utilizaremos "OBJPROP_ANCHOR" para posicionar o texto acima dos swing highs ou abaixo dos swing lows, enquanto "OBJPROP_ALIGN" será utilizado para centralizar o texto. Com as funções de visualização implementadas, podemos passar ao manipulador de eventos OnTick e identificar os pontos de reversão que serão utilizados posteriormente no reconhecimento dos padrões. Vejamos a lógica adotada.

//+------------------------------------------------------------------+
//| 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 parte inicial da função OnTick. Primeiro, declararemos uma variável estática chamada "lastBarTime", inicializada com o valor 0, para registrar o horário da última barra processada. Esse valor será comparado com "currentBarTime", obtido por meio de iTime com deslocamento 1 para o símbolo e período gráfico atuais. Para evitar processamento desnecessário, encerraremos a execução caso o horário não tenha mudado. Quando uma nova barra for detectada, atualizaremos "lastBarTime". Em seguida, utilizaremos ArrayResize para limpar o array "pivots" e iniciar uma nova análise. Depois, obteremos o número total de barras com a função Bars e definiremos os limites da busca por pontos de reversão: "start" receberá o valor de "PivotLeft", enquanto "end" será calculado subtraindo "PivotRight" do número total de barras. Percorreremos então as barras em ordem decrescente, de "end - 1" até "start".

Para cada barra, começaremos considerando que ela pode representar tanto um swing high ("isPivotHigh" igual a true) quanto um swing low ("isPivotLow" igual a true). Obteremos seus preços máximo e mínimo utilizando as funções iHigh e iLow. Em seguida, verificaremos as barras adjacentes, dentro dos intervalos definidos por "PivotLeft" e "PivotRight", para confirmar se o ponto analisado atende aos critérios de reversão. A identificação como swing high será descartada se alguma barra vizinha apresentar uma máxima superior, enquanto a identificação como swing low será descartada se houver uma mínima inferior. Se a barra atender aos critérios de um ponto de reversão, criaremos uma estrutura "Pivot", atribuindo ao campo "time" o horário obtido por iTime, ao campo "price" o preço máximo ou mínimo, conforme "isPivotHigh", e ao campo booleano "isHigh" o valor de "isPivotHigh", indicando se o pivô corresponde a uma máxima. Por fim, ampliaremos o array "pivots" utilizando ArrayResize e armazenaremos a estrutura. Ao exibir os dados dos pontos de reversão identificados, obteremos o seguinte array de dados.

PIVOTS DATA

Com esses dados, podemos identificar os pontos de reversão e, quando houver uma quantidade suficiente deles, analisar sua sequência para detectar possíveis padrões. Vejamos a lógica que implementaremos para isso.

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

//--- Extract the last four pivots as A, B, C, and D
Pivot A = pivots[pivotCount - 4];
Pivot B = pivots[pivotCount - 3];
Pivot C = pivots[pivotCount - 2];
Pivot D = pivots[pivotCount - 1];

//--- Initialize a flag to indicate if a valid AB=CD pattern is found
bool patternFound = false;
//--- Initialize pattern type
string patternType = "";
double used_retr = 0.0;
double used_ext = 0.0;
//--- Check for the high-low-high-low (Bullish reversal) structure
if(A.isHigh && (!B.isHigh) && C.isHigh && (!D.isHigh)) {
   //--- Calculate the difference between pivot A and B
   double diff = A.price - B.price;
   //--- Ensure the difference is positive
   if(diff > 0) {
      //--- Calculate the BC leg length
      double BC = C.price - B.price;
      double retrace = BC / diff;
      //--- Calculate the CD leg length
      double CD = C.price - D.price;
      double extension = CD / BC;
      //--- Define fib ratios
      double fib_retr[] = {0.382, 0.5, 0.618, 0.786, 0.886};
      double fib_ext[] = {2.618, 2.0, 1.618, 1.272, 1.13};
      bool valid = false;
      for(int k = 0; k < ArraySize(fib_retr); k++) {
         if(MathAbs(retrace - fib_retr[k]) <= Tolerance && MathAbs(extension - fib_ext[k]) <= Tolerance) {
            valid = true;
            used_retr = fib_retr[k];
            used_ext = fib_ext[k];
            break;
         }
      }
      if(valid && (D.price < B.price)) {
         patternFound = true;
         patternType = "Bullish";
      }
   }
}
//--- Check for the low-high-low-high (Bearish reversal) structure
if((!A.isHigh) && B.isHigh && (!C.isHigh) && D.isHigh) {
   //--- Calculate the difference between pivot B and A
   double diff = B.price - A.price;
   //--- Ensure the difference is positive
   if(diff > 0) {
      //--- Calculate the BC leg length
      double BC = B.price - C.price;
      double retrace = BC / diff;
      //--- Calculate the CD leg length
      double CD = D.price - C.price;
      double extension = CD / BC;
      //--- Define fib ratios
      double fib_retr[] = {0.382, 0.5, 0.618, 0.786, 0.886};
      double fib_ext[] = {2.618, 2.0, 1.618, 1.272, 1.13};
      bool valid = false;
      for(int k = 0; k < ArraySize(fib_retr); k++) {
         if(MathAbs(retrace - fib_retr[k]) <= Tolerance && MathAbs(extension - fib_ext[k]) <= Tolerance) {
            valid = true;
            used_retr = fib_retr[k];
            used_ext = fib_ext[k];
            break;
         }
      }
      if(valid && (D.price > B.price)) {
         patternFound = true;
         patternType = "Bearish";
      }
   }
}

Primeiro, obteremos a quantidade total de pontos de reversão armazenados no array "pivots" utilizando "ArraySize(pivots)" e atribuiremos o resultado à variável "pivotCount". Se forem encontrados menos de quatro pontos, encerraremos a execução e redefiniremos "g_patternFormationBar" como -1 e "g_lockedPatternA" como 0, pois o padrão AB=CD exige quatro pontos: A, B, C e D. Caso contrário, recuperaremos os quatro últimos pontos de reversão do array "pivots" e os atribuiremos às variáveis "A", "B", "C" e "D", respectivamente, considerando A como o mais antigo dos quatro pontos selecionados e D como o mais recente. Esses pontos formarão a estrutura que será analisada para identificar o padrão.

Em seguida, verificaremos se os pontos identificados formam um padrão AB=CD de alta (máxima em A, mínima em B, máxima em C e mínima em D). Começaremos calculando a amplitude do segmento AB ("A.price - B.price") e verificando se o resultado é positivo. Depois, calcularemos a amplitude de BC ("C.price - B.price") e sua proporção de retração em relação a AB, seguida da amplitude de CD ("C.price - D.price") e sua proporção de extensão em relação a BC. Definiremos os coeficientes de retração de Fibonacci (0.382, 0.5, 0.618, 0.786, 0.886) e os coeficientes de extensão (2.618, 2.0, 1.618, 1.272, 1.13). Em seguida, verificaremos se as proporções calculadas correspondem a esses coeficientes dentro da margem definida por "Tolerance" e se a condição "D.price < B.price" é satisfeita. Se todas as condições forem atendidas, definiremos "patternFound" como true e "patternType" como "Bullish", armazenando os coeficientes de Fibonacci correspondentes em "used_retr" e "used_ext". Para identificar um padrão AB=CD de baixa (mínima em A, máxima em B, mínima em C e máxima em D), aplicaremos cálculos equivalentes às amplitudes de AB ("B.price - A.price"), BC ("B.price - C.price") e CD ("D.price - C.price"). Verificaremos a correspondência com os mesmos coeficientes de Fibonacci e a condição "D.price > B.price". Se o padrão for válido, definiremos "patternFound" como true e "patternType" como "Bearish". Após identificar um padrão válido, poderemos representá-lo no gráfico.

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

Para visualizar o padrão identificado, começaremos verificando se "patternFound" é true. Nesse caso, utilizaremos a função Print para registrar a detecção no log, incluindo o valor de "patternType" ("Bullish" ou "Bearish") e o horário do ponto de reversão D, formatado com TimeToString para exibir a data, os minutos e os segundos. Em seguida, criaremos um identificador exclusivo chamado "signalPrefix", concatenando "AB_" com o valor de "A.time", convertido em string por meio da função IntegerToString. Esse identificador permitirá atribuir nomes exclusivos aos objetos gráficos associados a cada padrão.

Depois, definiremos "triangleColor" como azul para os padrões de alta ou vermelho para os padrões de baixa, facilitando sua distinção visual. Chamaremos então a função "DrawTriangle" duas vezes: a primeira para desenhar o triângulo ABC, conectando os pontos de reversão A, B e C, e a segunda para desenhar o triângulo BCD, conectando B, C e D. Utilizaremos "signalPrefix" com os sufixos "_Triangle1" e "_Triangle2" para identificar os objetos, passando as coordenadas de tempo e preço dos respectivos pontos de reversão, a cor definida em "triangleColor" e a largura 2. Também definiremos os parâmetros de preenchimento e exibição no plano de fundo como true, criando triângulos preenchidos atrás dos demais elementos do gráfico. O resultado será o seguinte.

TRIANGLE SET

A imagem mostra que conseguimos representar corretamente o padrão identificado no gráfico. Agora, adicionaremos linhas de tendência para destacar todo o contorno do padrã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);

//--- 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);

//--- 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);

//--- Calculate the central label's time as the midpoint between pivots A and C
datetime centralTime = (A.time + C.time) / 2;
//--- Set the central label's price at pivot D's price
double centralPrice = D.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 AB=CD" : "Bearish AB=CD");
   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);
}

Para aprimorar a visualização dos padrões identificados, acrescentaremos objetos gráficos que permitirão distinguir claramente cada segmento da estrutura. Primeiro, utilizaremos "DrawTrendLine" para desenhar três linhas de tendência contínuas, conectando os pontos de reversão dos segmentos AB, BC e CD. Cada linha receberá um nome exclusivo baseado em "signalPrefix" e utilizará as coordenadas de tempo e preço dos respectivos pontos, como "A.time" e "A.price". Configuraremos "OBJPROP_COLOR" como "clrBlack", "OBJPROP_WIDTH" como 2 e "OBJPROP_STYLE" como "STYLE_SOLID", utilizando ObjectSetInteger para destacar o contorno do padrão. Em seguida, obteremos o tamanho de um ponto em unidades de preço 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" e "textY_D", somando ou subtraindo esse deslocamento do preço de cada pivô, conforme o valor de "isHigh". Dessa forma, os rótulos serão posicionados acima dos swing highs quando "isHigh" for true e abaixo dos swing lows quando for false.

Em seguida, utilizaremos "DrawTextEx" para criar rótulos de texto nos pontos de reversão A, B, C e D. Cada objeto receberá um nome formado por "signalPrefix" e um sufixo correspondente, como "_Text_A", e exibirá a letra do respectivo ponto. Os rótulos serão posicionados no horário de cada pivô, com a coordenada vertical ajustada para evitar sobreposição com o padrão. Utilizaremos "clrBlack" como cor, tamanho de fonte 11 e o valor de "isHigh" para definir a ancoragem do texto. Por fim, calcularemos a posição de um rótulo central, definindo "centralTime" como o ponto médio entre "A.time" e "C.time" e "centralPrice" como "D.price". Criaremos então um objeto de texto com ObjectCreate, atribuindo-lhe o nome "signalPrefix + '_Text_Center'". Configuraremos "OBJPROP_TEXT" como "Bullish AB=CD" ou "Bearish AB=CD", conforme o valor de "patternType". Utilizando ObjectSetString e ObjectSetInteger, definiremos "OBJPROP_COLOR" como "clrBlack", "OBJPROP_FONTSIZE" como 11, "OBJPROP_FONT" como "Arial Bold" e "OBJPROP_ALIGN" como "ALIGN_CENTER". Dessa forma, o gráfico apresentará claramente a estrutura do padrão e sua classificação como de alta ou de baixa. Ao executar o programa, obteremos a seguinte visualização.

PATTERN WITH LABELS AND EDGES

A imagem mostra que adicionamos as linhas de contorno e os rótulos ao padrão, tornando sua estrutura mais fácil de identificar. O próximo passo será definir os níveis de negociação associados ao padrão.

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

//--- Declare variables for entry price and take profit levels
double entryPriceLevel, TP1Level, TP2Level, TP3Level;
//--- Calculate pattern range (CD length)
double patternRange = (patternType=="Bullish") ? (C.price - D.price) : (D.price - C.price);
//--- 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 C's price
   TP3Level = C.price;
   //--- Set TP1 at 0.382 fib retrace from D to C
   TP1Level = D.price + 0.382 * patternRange;
   //--- Set TP2 at 0.618 fib retrace from D to C
   TP2Level = D.price + 0.618 * patternRange;
} else { //--- Bearish → SELL signal
   //--- Use the current BID price as the entry
   entryPriceLevel = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   //--- Set TP3 at pivot C's price
   TP3Level = C.price;
   //--- Set TP1 at 0.382 fib retrace from D to C
   TP1Level = D.price - 0.382 * patternRange;
   //--- Set TP2 at 0.618 fib retrace from D to C
   TP2Level = D.price - 0.618 * patternRange;
}

//--- 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 calcular e representar os níveis de negociação no gráfico, definiremos "lineStart" como o horário do ponto de reversão D ("D.time") e "lineEnd" como um instante dois períodos gráficos à frente, utilizando PeriodSeconds(_Period) multiplicado por 2. Declararemos as variáveis "entryPriceLevel", "TP1Level", "TP2Level" e "TP3Level" para armazenar os preços de entrada e os alvos de take-profit. Em seguida, calcularemos "patternRange" como a amplitude do segmento CD, utilizando "C.price - D.price" para padrões de alta e "D.price - C.price" para padrões de baixa. Para um padrão de alta, definiremos "entryPriceLevel" como o preço Ask, obtido por meio de SymbolInfoDouble, e "TP3Level" como o preço do ponto C. Calcularemos "TP1Level" como "D.price + 0.382 * patternRange" e "TP2Level" como "D.price + 0.618 * patternRange". Para um padrão de baixa, utilizaremos o preço Bid como nível de entrada, manteremos "TP3Level" no preço do ponto C e calcularemos "TP1Level" como "D.price - 0.382 * patternRange" e "TP2Level" como "D.price - 0.618 * patternRange".

Em seguida, utilizaremos a função "DrawDottedLine" para desenhar quatro linhas horizontais pontilhadas, estendidas de "lineStart" até "lineEnd". A linha de entrada será posicionada em "entryPriceLevel" e exibida em púrpura. As três linhas de take-profit serão posicionadas em "TP1Level", "TP2Level" e "TP3Level", utilizando, respectivamente, verde-floresta escuro, verde e verde-escuro. Por fim, definiremos "labelTime" como "lineEnd" acrescido de metade da duração de um período gráfico. Criaremos rótulos contendo os preços formatados com DoubleToString, como "BUY (price)" ou "SELL (price)" para o nível de entrada e "TP1 (price)", "TP2 (price)" e "TP3 (price)" para os respectivos alvos. Utilizaremos "DrawTextEx" para posicionar esses rótulos em "labelTime", com as cores correspondentes a cada linha, tamanho de fonte 11 e ancoragem acima dos respectivos níveis de preço. Após compilar o programa, obteremos os seguintes resultados.

Padrão de baixa:

BEARISH PATTERN

Padrão de alta:

BULLISH PATTERN

As imagens mostram que os níveis de negociação foram representados corretamente no gráfico. Agora, resta implementar a abertura efetiva 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)) {
         double entryPriceTrade = 0, stopLoss = 0, takeProfit = 0;
         point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
         bool tradeResult = false;
         //--- Determine next extension for SL
         double next_ext = 0.0;
         if(MathAbs(used_ext - 1.13) < 0.05) next_ext = 1.272;
         else if(MathAbs(used_ext - 1.272) < 0.05) next_ext = 1.618;
         else if(MathAbs(used_ext - 1.618) < 0.05) next_ext = 2.0;
         else if(MathAbs(used_ext - 2.0) < 0.05) next_ext = 2.618;
         else if(MathAbs(used_ext - 2.618) < 0.05) next_ext = 3.618;
         else next_ext = used_ext * 1.618; // fallback
         //--- For a Bullish pattern, execute a BUY trade
         if(patternType=="Bullish") { //--- BUY signal
            entryPriceTrade = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
            double BC_leg = C.price - B.price;
            stopLoss = C.price - next_ext * BC_leg;
            if(stopLoss > D.price) stopLoss = D.price - 10 * point;
            takeProfit = TP2Level;
            tradeResult = obj_Trade.Buy(LotSize, _Symbol, entryPriceTrade, stopLoss, takeProfit, "AB=CD 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);
            double BC_leg = B.price - C.price;
            stopLoss = C.price + next_ext * BC_leg;
            if(stopLoss < D.price) stopLoss = D.price + 10 * point;
            takeProfit = TP2Level;
            tradeResult = obj_Trade.Sell(LotSize, _Symbol, entryPriceTrade, stopLoss, takeProfit, "AB=CD Signal");
            if(tradeResult)
               Print("Sell order opened successfully.");
            else
               Print("Sell order failed: ", obj_Trade.ResultRetcodeDescription());
         }
      }
      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 AB=CD pattern is detected, reset the pattern lock variables
   g_patternFormationBar = -1;
   g_lockedPatternA = 0;
}

Nesta etapa, concluiremos a lógica do manipulador de eventos OnTick, implementando a confirmação do padrão harmônico AB=CD identificado e o controle da abertura de 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 ainda não houver um padrão registrado ("g_patternFormationBar == -1"), atribuiremos "currentBarIndex" a "g_patternFormationBar" e armazenaremos o horário do ponto de reversão A ("A.time") em "g_lockedPatternA". Também registraremos no log que o padrão foi detectado e está aguardando confirmação. Depois, encerraremos a execução. Se o padrão ainda estiver na mesma barra em que foi identificado ("currentBarIndex == g_patternFormationBar"), também encerraremos a execução para evitar a abertura prematura de operações.

Quando uma nova barra se formar ("currentBarIndex > g_patternFormationBar") e o horário do pivô 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 a negociação automática está habilitada por meio de "AllowTrading" e se já existe uma posição aberta para o símbolo, utilizando PositionSelect. Calcularemos então o próximo coeficiente de extensão de Fibonacci ("next_ext") com base em "used_ext", para definir o stop-loss. Por exemplo, poderemos passar de 1,13 para 1,272 e avançar até 3,618 ou, como alternativa, utilizar o valor de "used_ext" multiplicado por 1,618. Para um padrão de alta, definiremos "entryPriceTrade" como o preço Ask e calcularemos "BC_leg" como "C.price - B.price". O stop-loss será calculado subtraindo de "C.price" o produto de "next_ext" por "BC_leg". Se o nível calculado estiver acima do ponto D, ajustaremos "stopLoss" para 10 pontos abaixo de "D.price". Definiremos "takeProfit" como "TP2Level" e utilizaremos "obj_Trade.Buy" para abrir uma posição de compra com o volume especificado em "LotSize" e o comentário "AB=CD Signal". Em seguida, registraremos no log se a operação foi executada com sucesso ou se houve falha. Para um padrão de baixa, utilizaremos o preço Bid e calcularemos "BC_leg" como "B.price - C.price". Nesse caso, o stop-loss será calculado somando a "C.price" o produto de "next_ext" por "BC_leg". Se o nível calculado estiver abaixo do ponto D, ajustaremos "stopLoss" para 10 pontos acima de "D.price". Em seguida, utilizaremos "obj_Trade.Sell" para abrir uma posição de venda. Se a negociação estiver desabilitada ou já existir uma posição aberta, registraremos no log que nenhuma nova operação será executada. Caso o padrão identificado mude, atualizaremos os dados armazenados e aguardaremos uma nova confirmação. Se nenhum padrão for encontrado, redefiniremos as variáveis globais. Após compilar o programa, obteremos os seguintes resultados.

Sinal de baixa:

BEARISH SIGNAL

Sinal de alta:

BULLISH SIGNAL

As imagens mostram que conseguimos representar graficamente o padrão harmônico e executar as operações correspondentes após sua confirmação. Dessa forma, alcançamos o objetivo de identificar o padrão AB=CD, visualizar sua estrutura no gráfico e automatizar as operações com base nos sinais gerados. Resta realizar o backtesting do programa, que será apresentado na próxima seção.


Backtesting

Após realizar um backtesting detalhado, obtivemos os seguintes resultados.

Gráfico do backtesting:

Gráfico

Relatório do backtesting:

REPORT


Conclusão

Neste artigo, desenvolvemos um sistema de reconhecimento do padrão AB=CD em MQL5. A solução utiliza a análise do movimento dos preços para identificar padrões harmônicos AB=CD de alta e de baixa com base em níveis precisos de retração e extensão de Fibonacci. Também automatiza a abertura de operações com níveis calculados de entrada, stop-loss e alvos de take-profit em diferentes níveis. Além disso, representa os padrões no gráfico por meio de objetos como triângulos e linhas de tendência.

Aviso de isenção de responsabilidade: O conteúdo deste artigo destina-se exclusivamente a fins educacionais. A negociação nos mercados financeiros envolve riscos significativos, e a volatilidade do mercado pode resultar em perdas. A realização de backtesting rigoroso e a adoção de práticas adequadas de gestão de risco são fundamentais antes de utilizar este programa em condições reais de mercado.

Com os conceitos e métodos de implementação apresentados, você poderá adaptar o sistema de reconhecimento do padrão AB=CD 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/19442

Arquivos anexados |
Últimos Comentários | Ir para discussão (2)
Louis Wetzel
Louis Wetzel | 9 abr. 2026 em 18:13

A marca registrada (TM) será considerada nula por meio de qualquer padrão de quatro pontos criado naturalmente pelos movimentos de preço, uma vez que as designações em inglês atribuídas como descritores não podem ser consideradas como atendendo ao padrão da marca registrada (TM) de conduzir negócios com propriedade intelectual exclusiva e deter direitos exclusivos sobre essas descrições. Acho que você está inventando coisas e desperdiçou de 350,00 a 850,00 dólares no escritório da TM, e isso será contestado.

Essa é a minha opinião.

Louis B. Wetzel

Allan Munene Mutiiria
Allan Munene Mutiiria | 9 abr. 2026 em 18:57
Louis Wetzel #:

A marca registrada será considerada nula por meio de qualquer padrão de quatro pontos criado naturalmente pelos movimentos de preço, e as designações em inglês atribuídas como descritores não podem ser consideradas como atendendo ao padrão da marca registrada para conduzir negócios com propriedade intelectual exclusiva e deter direitos exclusivos sobre essas descrições. Considero isso uma grande besteira, e você desperdiçou de 350,00 a 850,00 $$ no escritório da TM e será contestado.

Essa é a minha opinião.

Louis B. Wetzel

Olá. Obrigado pelo feedback. As ideias apresentadas têm como objetivo automatizar a estratégia de negociação mencionada acima. Houve algo que não ficou claro ou que causou confusão e precise de esclarecimento? Obrigado.
Desenvolvimento de um indicador personalizado de sentimento do mercado Desenvolvimento de um indicador personalizado de sentimento do mercado
Neste artigo, desenvolveremos um indicador personalizado de sentimento do mercado que classifica o sentimento como altista, baixista, risk-on, risk-off ou neutro. Por meio da análise de múltiplos timeframes, o indicador oferece aos traders uma visão mais clara do viés direcional geral do mercado e dos sinais de confirmação de curto prazo.
Como aumentar a eficiência das operações com Smart Money Concepts (SMC): OB, BOS e FVG Como aumentar a eficiência das operações com Smart Money Concepts (SMC): OB, BOS e FVG
Aumente a eficiência das suas operações com Smart Money Concepts (SMC), combinando blocos de ordens (Order Blocks, OB), rompimentos de estrutura (Break of Structure, BOS) e gaps de valor justo (Fair Value Gaps, FVG) em um único EA. Opte pela execução automática ou utilize cada conceito de SMC individualmente para negociar com mais flexibilidade e precisão.
Desenvolvimento de EAs auto-otimizáveis em MQL5 (Parte 14): Transformações de dados como parâmetros de ajuste de um controlador com realimentação Desenvolvimento de EAs auto-otimizáveis em MQL5 (Parte 14): Transformações de dados como parâmetros de ajuste de um controlador com realimentação
O pré-processamento é um poderoso parâmetro de ajuste, mas frequentemente negligenciado. Costuma ficar à sombra de componentes que recebem muito mais atenção, como os otimizadores e as sofisticadas arquiteturas de modelos. Mesmo uma pequena melhoria de desempenho nessa etapa pode produzir efeitos cumulativos desproporcionalmente significativos sobre a rentabilidade e os riscos. Com frequência, essa área ainda pouco explorada é reduzida a uma tarefa rotineira, tratada apenas como um meio para atingir um objetivo, quando, na realidade, é justamente nessa etapa que um sinal pode ser diretamente amplificado ou, com a mesma facilidade, eliminado.
Do iniciante ao especialista: Criando um EA animado para negociação baseada em notícias em MQL5 (X) - Visualização de múltiplos símbolos em um único gráfico para negociação baseada em notícias Do iniciante ao especialista: Criando um EA animado para negociação baseada em notícias em MQL5 (X) - Visualização de múltiplos símbolos em um único gráfico para negociação baseada em notícias
Hoje, vamos desenvolver um sistema de visualização de múltiplos gráficos utilizando objetos gráficos. O objetivo é aprimorar a negociação baseada em notícias por meio de algoritmos em MQL5 que ajudam a reduzir o tempo de reação dos traders durante períodos de alta volatilidade, como a divulgação de notícias de grande impacto. Para isso, ofereceremos aos traders uma solução integrada que permite monitorar vários dos principais instrumentos em uma única ferramenta de negociação baseada em notícias. Nosso projeto continua evoluindo com o News Headline EA ("Manchetes de notícias"), que agora conta com um conjunto cada vez maior de funcionalidades que agregam valor tanto para traders que utilizam sistemas totalmente automatizados quanto para aqueles que preferem operar manualmente com o auxílio de algoritmos. Acesse o link e participe desta discussão para ampliar seus conhecimentos, obter informações e conhecer ideias práticas.