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

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

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.

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.

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.

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:

Padrão de alta:

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:

Sinal de alta:

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:

Relatório do backtesting:

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
Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.
Esse artigo foi escrito por um usuário do site e reflete seu ponto de vista pessoal. A MetaQuotes Ltd. não se responsabiliza pela precisão das informações apresentadas nem pelas possíveis consequências decorrentes do uso das soluções, estratégias ou recomendações descritas.
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
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