Introdução à linguagem MQL5 (Parte 21): Detecção automática do padrão de Gartley
Introdução
Sejam bem-vindos novamente à Parte 21 da série "Introdução à linguagem MQL5"! Na Parte 20, apresentei os padrões harmônicos e expliquei os conceitos matemáticos por trás dos níveis de Fibonacci e suas extensões, além de mostrar como implementá-los em MQL5. Neste artigo, vamos avançar um pouco mais e nos concentrar na detecção automática do padrão harmônico de Gartley.
Você aprenderá a identificar programaticamente possíveis padrões de Gartley nos seus gráficos, utilizando níveis de Fibonacci, swings de preço e objetos gráficos. A lógica e as técnicas apresentadas aqui também podem ser aplicadas a outros padrões harmônicos, como Bat (morcego), Butterfly (borboleta), Crab (caranguejo) e Deep Crab (caranguejo profundo). No entanto, para simplificar o aprendizado, vamos nos concentrar no padrão de Gartley.
Este artigo se destaca pela linguagem acessível aos iniciantes e pela maneira como simplificamos conceitos complexos, dividindo-os em etapas fáceis de acompanhar. Em vez de sobrecarregar você com teoria, adotaremos uma abordagem prática baseada em projeto, na qual desenvolveremos um EA capaz de identificar automaticamente o padrão de Gartley.
Configuração do projeto
O objetivo deste projeto é desenvolver um EA capaz de identificar automaticamente padrões harmônicos de Gartley no gráfico. Com base em critérios predefinidos, o EA analisará os swings de preço, calculará os principais níveis de retração e extensão de Fibonacci e identificará possíveis formações de Gartley.
O padrão de Gartley é composto por quatro segmentos principais (XA, AB, BC e CD) e caracterizado por proporções específicas de Fibonacci: o ponto B deve corresponder a uma retração de aproximadamente 78,6% do segmento XA, o ponto C deve situar-se entre os níveis de retração de 38,2% e 88,6% do segmento AB, e o ponto D deve corresponder a uma retração de aproximadamente 78,6% do segmento XA. Nosso EA será flexível e fácil de usar, inclusive para iniciantes, permitindo que os traders ajustem as faixas de retração e extensão de Fibonacci de acordo com seu estilo de negociação.
Lógica de compra
Para detectar um padrão de Gartley de alta, o EA seguirá estas etapas:
- Identificar o ponto X como um fundo de swing.
- Identificar o ponto A como um topo de swing significativo após o ponto X.
- Localizar o ponto B, cuja retração em relação ao segmento XA deve estar dentro de uma faixa definida.
- Confirmar o ponto C, que deve situar-se dentro de uma faixa de retração específica em relação ao segmento AB.
- Calcular o possível ponto D, que deve estar dentro de uma faixa de retração específica em relação ao segmento XA.
- Verificar se todos os segmentos atendem às proporções de Fibonacci exigidas para confirmar a validade da estrutura de Gartley.
- Após a confirmação do ponto D, o EA gerará um sinal de compra, antecipando uma reversão de alta a partir desse nível.
- Além disso, o EA permitirá que os usuários configurem todos os níveis de retração e extensão de Fibonacci por meio dos parâmetros de entrada, oferecendo flexibilidade para diferentes condições de mercado.
Assim que o EA confirmar um padrão de Gartley de alta válido:
- Entrada: uma operação de compra é aberta no ponto D, imediatamente após a conclusão do padrão.
- Stop Loss (SL): é posicionado no fundo de swing correspondente ao ponto D.
- Take Profit (TP): é definido com uma relação risco-retorno de 1:3, ou seja, a distância até o Take Profit será três vezes maior que a distância até o Stop Loss.
Lógica de venda
Para detectar um padrão de Gartley de baixa, o EA seguirá estas etapas:
- Identificar o ponto X como um topo de swing.
- Identificar o ponto A como um fundo de swing significativo após o ponto X.
- Localizar o ponto B, cuja retração em relação ao segmento XA deve estar dentro de uma faixa definida.
- Confirmar o ponto C, que deve situar-se dentro de uma faixa de retração específica em relação ao segmento AB.
- Calcular o possível ponto D, que deve estar dentro de uma faixa específica em relação ao segmento XA.
- Verificar se todos os segmentos atendem às proporções de Fibonacci exigidas para confirmar a validade da estrutura de Gartley.
- Após a confirmação do ponto D, o EA gerará um sinal de venda, antecipando uma reversão de baixa a partir desse nível.
- Além disso, o EA permitirá que os usuários configurem todos os níveis de retração e extensão de Fibonacci por meio dos parâmetros de entrada, oferecendo flexibilidade para diferentes condições de mercado.
Assim que o EA confirmar um padrão de Gartley de baixa válido:
- Entrada: uma operação de venda é aberta no ponto D, imediatamente após a conclusão do padrão.
- Stop Loss (SL): é posicionado no topo de swing correspondente ao ponto D.
- Take Profit (TP): é definido com uma relação risco-retorno de 1:3, ou seja, a distância até o Take Profit será três vezes maior que a distância até o Stop Loss.
Identificação do padrão de Gartley de baixa
No artigo anterior, expliquei detalhadamente a diferença entre os padrões harmônicos de alta e de baixa. Como sempre digo, ao trabalhar com padrões gráficos, você precisa dos dados dos candles e deve saber identificar os topos e fundos de swing. No padrão de Gartley de baixa, o ponto inicial X deve corresponder a um topo de swing. A partir daí, a estrutura deve respeitar os níveis de retração e extensão de Fibonacci exigidos, formando os segmentos XA, AB, BC e CD. Ao identificar esses swings com precisão, o EA consegue reconhecer a estrutura XABCD e determinar se ela atende aos critérios de um padrão de Gartley de baixa.
Exemplo:
input ENUM_TIMEFRAMES timeframe = PERIOD_CURRENT; // TIMEFRAME double open[]; double close[]; double low[]; double high[]; datetime time[]; datetime time_bar; int bars_check = 500; int total_symbol_bars; //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- //--- return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { //--- } //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { total_symbol_bars = Bars(_Symbol, timeframe); time_bar = iTime(_Symbol, timeframe, 0); CopyOpen(_Symbol, timeframe, time_bar, bars_check, open); CopyClose(_Symbol, timeframe, time_bar, bars_check, close); CopyLow(_Symbol, timeframe, time_bar, bars_check, low); CopyHigh(_Symbol, timeframe, time_bar, bars_check, high); CopyTime(_Symbol, timeframe, time_bar, bars_check, time); } //+------------------------------------------------------------------+ //| FUNCTION FOR SWING LOW | //+------------------------------------------------------------------+ bool IsSwingLow(const double &low_price[], int index, int lookback) { for(int i = 1; i <= lookback; i++) { if(low_price[index] > low_price[index - i] || low_price[index] > low_price[index + i]) return false; } return true; } //+------------------------------------------------------------------+ //| FUNCTION FOR SWING HIGH | //+------------------------------------------------------------------+ bool IsSwingHigh(const double &high_price[], int index, int lookback) { for(int i = 1; i <= lookback; i++) { if(high_price[index] < high_price[index - i] || high_price[index] < high_price[index + i]) return false; // If the current high is not the highest, return false. } return true; }
Explicação:
A primeira etapa consiste em configurar o timeframe do EA de acordo com o gráfico em que ele está sendo executado. São declarados arrays para armazenar os dados históricos dos candles, incluindo os preços de abertura, fechamento, máxima e mínima, além dos respectivos horários. As demais variáveis acompanham a marca de tempo da barra mais recente, o número total de barras disponíveis e a quantidade de barras que serão analisadas. Em seguida, os dados de mercado serão armazenados nesses arrays para permitir uma análise detalhada das oscilações de preço.
O programa obtém o horário da barra mais recente e determina quantas barras estão disponíveis a cada atualização do mercado. Para garantir que a análise esteja sempre baseada nas condições atuais do mercado, o EA coleta os dados mais recentes de preços e horários. Essas informações fornecem uma base confiável para cálculos adicionais e para a identificação de tendências técnicas nos dados de preços.
Ao comparar cada barra com as barras vizinhas, funções personalizadas identificam topos e fundos de swing significativos. Uma função verifica se há um fundo claramente definido, enquanto outra verifica se há um topo. Ao acompanhar esses pontos à medida que novos candles são formados, o programa consegue detectar de maneira consistente configurações de Gartley de alta e de baixa.
Identificação do ponto X
A identificação do ponto X é a primeira etapa da detecção de um padrão de Gartley de baixa. Para que a configuração seja de baixa, o ponto X deve corresponder a um topo de swing no gráfico. Isso significa que ele deve representar um pico claramente definido, no qual o preço sobe antes de iniciar um movimento de queda.
Exemplo:
double X; datetime X_time; string X_letter; int z = 4; long chart_id = ChartID();
//+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { total_symbol_bars = Bars(_Symbol, timeframe); time_bar = iTime(_Symbol, timeframe, 0); CopyOpen(_Symbol, timeframe, time_bar, bars_check, open); CopyClose(_Symbol, timeframe, time_bar, bars_check, close); CopyLow(_Symbol, timeframe, time_bar, bars_check, low); CopyHigh(_Symbol, timeframe, time_bar, bars_check, high); CopyTime(_Symbol, timeframe, time_bar, bars_check, time); if(total_symbol_bars >= bars_check) { for(int i = z ; i < bars_check - z; i++) { if(IsSwingHigh(high, i, z)) { X = high[i]; X_time = time[i]; X_letter = StringFormat("X %d",i); ObjectCreate(chart_id,X_letter,OBJ_TEXT,0,X_time,X); ObjectSetString(chart_id,X_letter,OBJPROP_TEXT,"X"); } } } }
Explicação:
Para garantir que haja candles suficientes para a análise, o programa começa com uma verificação de segurança. Ele verifica se há pelo menos 500 barras no gráfico antes de prosseguir, pois essa é a quantidade necessária. Essa precaução evita erros e garante que o EA utilize apenas dados de mercado completos. Após essa verificação, o programa utiliza um laço e uma janela de análise retrospectiva (z) para percorrer os candles e comparar cada um com seus vizinhos. Por exemplo, para evitar erros de acesso fora dos limites do array e identificar os pontos de swing com precisão, a variável z recebe o valor 4, de modo que cada candle seja comparado com os quatro candles anteriores e os quatro posteriores.
Durante esse laço, o algoritmo procura um topo de swing e define o ponto X, a primeira referência do padrão de Gartley de baixa. Quando um topo de swing é identificado, seu preço, horário e índice são armazenados, e o gráfico é imediatamente marcado com um rótulo de texto "X". Além de destacar esse ponto de swing importante, o marcador visual estabelece uma referência clara para as etapas seguintes de identificação dos demais componentes do padrão de Gartley.
Identificação do ponto A
Depois que o ponto X é corretamente identificado como um topo de swing válido, a próxima etapa consiste em localizar o ponto A. No padrão harmônico de Gartley de baixa, o ponto A normalmente corresponde a um fundo de swing formado após o ponto X. Para identificá-lo, o EA avança a partir da barra em que o ponto X foi detectado. Assim como utilizamos IsSwingHigh para identificar o ponto X, o EA utiliza a função IsSwingLow para procurar um fundo de swing, verificando cada candle dentro do intervalo.
Exemplo:
double A; datetime A_time; string A_letter; string xa_line;
if(total_symbol_bars >= bars_check) { for(int i = z ; i < bars_check - z; i++) { if(IsSwingHigh(high, i, z)) { X = high[i]; X_time = time[i]; X_letter = StringFormat("X %d",i); ObjectCreate(chart_id,X_letter,OBJ_TEXT,0,X_time,X); ObjectSetString(chart_id,X_letter,OBJPROP_TEXT,"X"); for(int j = i; j < bars_check - z; j++) { if(IsSwingLow(low, j, z) && low[j] < X) { A = low[j]; A_time = time[j]; A_letter = StringFormat("A %d",j); ObjectCreate(chart_id,A_letter,OBJ_TEXT,0,A_time,A); ObjectSetString(chart_id,A_letter,OBJPROP_TEXT,"A"); xa_line = StringFormat("XA Line %d",i); ObjectCreate(chart_id,xa_line,OBJ_TREND,0,X_time,X,A_time,A); break; } } } } }
Resultado:

Explicação:
O EA inicia imediatamente a busca pelo ponto A, o próximo ponto importante do padrão, assim que confirma que o ponto X corresponde a um topo de swing válido. A partir da posição de X, ele percorre os candles seguintes para identificar um fundo que atenda aos critérios de um fundo de swing. Durante essa busca, o programa também verifica se o novo fundo está abaixo do topo identificado anteriormente, para confirmar que a estrutura corresponde a um padrão harmônico de baixa. Quando uma barra atende a esses requisitos, o programa marca esse nível no gráfico com uma etiqueta de texto e armazena o preço e o horário do ponto A.
O EA utiliza ObjectCreate para adicionar uma etiqueta de texto com a letra "A" no ponto selecionado, facilitando sua identificação no gráfico. Em seguida, utiliza um objeto OBJ_TREND para traçar uma linha de tendência entre os pontos X e A. Essa linha conecta o primeiro topo de swing ao fundo de swing seguinte, representando visualmente o segmento XA do padrão harmônico. Para garantir que o EA selecione o ponto A válido mais próximo de X e não continue procurando outros fundos, a busca é encerrada com a instrução break; assim que o primeiro fundo de swing válido é encontrado.
O laço externo (for(int i = z; i < bars_check - z; i++)) percorre cada candle do intervalo analisado enquanto o EA procura o ponto X (topo de swing). Para identificar possíveis pontos iniciais de um padrão harmônico, o EA precisa examinar todos os possíveis topos de swing presentes nos dados. Se inserirmos uma instrução break nesse laço, o EA deixará de considerar outros pontos X válidos que poderiam dar origem a padrões no gráfico, pois a execução do laço seria interrompida após a identificação do primeiro topo de swing.
Por outro lado, assim que encontra o ponto X, o EA começa imediatamente a procurar um ponto A correspondente (um fundo de swing posterior a X). Nesse caso, como o objetivo é identificar o segmento XA, basta encontrar o primeiro fundo de swing válido após X. A instrução break impede que o EA continue procurando outros fundos depois de identificar o primeiro ponto A válido, evitando possíveis ambiguidades ou sobreposições entre segmentos XA. A solução consiste em selecionar o ponto X mais próximo de A, garantindo que cada ponto A esteja associado ao ponto X válido mais próximo. Dessa forma, o segmento XA permanece consistente e evita-se a sobreposição de diferentes formações.
Exemplo:if(total_symbol_bars >= bars_check) { for(int i = z ; i < bars_check - z; i++) { if(IsSwingHigh(high, i, z)) { for(int j = i; j < bars_check - z; j++) { if(IsSwingLow(low, j, z) && low[j] < high[i]) { A = low[j]; A_time = time[j]; A_letter = StringFormat("A %d",j); for(int a = j; a >= i; a--) { if(IsSwingHigh(high, a, z) && high[a] > A) { X = high[a]; X_time = time[a]; X_letter = StringFormat("X %d",a); ObjectCreate(chart_id,X_letter,OBJ_TEXT,0,X_time,X); ObjectSetString(chart_id,X_letter,OBJPROP_TEXT,"X"); ObjectCreate(chart_id,A_letter,OBJ_TEXT,0,A_time,A); ObjectSetString(chart_id,A_letter,OBJPROP_TEXT,"A"); xa_line = StringFormat("XA Line %d",i); ObjectCreate(chart_id,xa_line,OBJ_TREND,0,X_time,X,A_time,A); break; } } break; } } } } } } } }
Resultado:

Explicação:
Quando utilizamos inicialmente a condição low[j] < high[i] para verificar um fundo de swing, high[i] funciona apenas como uma referência provisória. Nesse momento, ainda não está definido qual topo de swing será formalmente selecionado como ponto X. Mesmo assim, a estrutura já pode ser considerada um possível início do segmento XA, pois a comparação com high[i] apenas garante que o ponto A (fundo de swing) esteja abaixo de pelo menos um topo de swing anterior. Em outras palavras, high[i] serve como referência temporária para a verificação, permitindo descartar fundos que não atendem aos critérios para serem considerados o ponto A.
Como esse topo de swing pode não ser o mais alto nem o mais próximo do ponto A, não podemos simplesmente definir high[i] como ponto X após identificar um ponto A válido. Para aprimorar essa busca, introduzimos um laço reverso, for(int a = j; a >= i; a--), que percorre os candles de trás para frente, partindo da posição do ponto A em direção ao topo inicialmente identificado. Essa abordagem permite selecionar o candidato mais adequado para o ponto X, pois procura o topo de swing mais próximo de A cujo preço seja superior ao de A. Assim, garantimos que o segmento XA seja definido de maneira consistente e correta, sem depender de um topo anterior escolhido arbitrariamente.
Como queremos desenhar esses elementos somente após confirmar a validade do ponto X, movemos a criação dos objetos gráficos (marcação dos pontos X e A e desenho da linha XA) para dentro desse laço reverso. Se os objetos fossem criados fora dele, os pontos X e A poderiam ser marcados prematuramente no gráfico, possivelmente com um topo de swing incorreto. Ao realizar essa operação dentro do laço, garantimos que o segmento XA seja exibido somente após a confirmação do topo de swing válido mais próximo.
Identificação do segmento BC
Depois de concluir o segmento XA, a próxima etapa consiste em identificar o segmento BC. No padrão de Gartley de baixa, essa parte da estrutura é definida por dois pontos: B e C. O ponto B deve corresponder a um topo de swing formado após o ponto A, enquanto o ponto C deve representar um fundo de swing posterior a B. Ao identificar esses dois pontos, começamos a traçar a segunda parte do padrão harmônico.
Nesta etapa, ainda não aplicamos critérios de retração ou extensão de Fibonacci. O objetivo principal é identificar os pontos de swing formados naturalmente pelo movimento do preço.
Exemplo:double B; datetime B_time; string B_letter; double C; datetime C_time; string C_letter; string ab_line; string bc_line;
for(int k = j; k < bars_check - z; k++) { if(IsSwingHigh(high, k, z) && high[k] > A) { B = high[k]; B_time = time[k]; B_letter = StringFormat("B %d",k); for(int l = k; l < bars_check - z; l++) { if(IsSwingLow(low, l, z) && low[l] < B) { C = low[l]; C_time = time[l]; C_letter = StringFormat("C %d",l); ObjectCreate(chart_id,B_letter,OBJ_TEXT,0,B_time,B); ObjectSetString(chart_id,B_letter,OBJPROP_TEXT,"B"); ObjectCreate(chart_id,C_letter,OBJ_TEXT,0,C_time,C); ObjectSetString(chart_id,C_letter,OBJPROP_TEXT,"C"); ab_line = StringFormat("AB Line %d",i); ObjectCreate(chart_id,ab_line,OBJ_TREND,0,A_time,A,B_time,B); bc_line = StringFormat("BC Line %d", i); ObjectCreate(chart_id,bc_line,OBJ_TREND,0,B_time,B,C_time,C); ObjectCreate(chart_id,X_letter,OBJ_TEXT,0,X_time,X); ObjectSetString(chart_id,X_letter,OBJPROP_TEXT,"X"); ObjectCreate(chart_id,A_letter,OBJ_TEXT,0,A_time,A); ObjectSetString(chart_id,A_letter,OBJPROP_TEXT,"A"); xa_line = StringFormat("XA Line %d",i); ObjectCreate(chart_id,xa_line,OBJ_TREND,0,X_time,X,A_time,A); i = l+1; break; } } break; } }
Resultado:

Explicação:
A partir do ponto A, o primeiro laço, for(int k = j; k < bars_check - z; k++), procura o ponto B. Dentro desse laço, o programa utiliza a função IsSwingHigh para identificar um topo de swing. Também verifica se high[k] > A, ou seja, se o topo de swing está acima do preço do ponto A, garantindo que o ponto B atenda aos requisitos da estrutura. Quando essa condição é satisfeita, o programa registra o preço, o horário e a etiqueta de identificação do ponto B.
Em seguida, o segundo laço, for(int l = k; l < bars_check - z; l++), procura o ponto C, que deve corresponder a um fundo de swing formado após B. A condição low[l] < B garante que o ponto C esteja abaixo do topo de swing B, preservando a estrutura do padrão de Gartley de baixa. Assim que um ponto C válido é identificado, seu preço, horário e identificação são registrados. Depois de identificar e marcar os pontos B e C no gráfico, o programa redesenha as marcações dos pontos X e A para manter a representação visual do padrão clara.
O algoritmo utiliza a expressão i = l+1; para avançar no laço externo, evitando detectar repetidamente os mesmos pontos. No entanto, ao utilizar i = l+1 após identificar o ponto C, o algoritmo pode deixar de detectar muitos sinais válidos de Gartley, pois avança demais e ignora possíveis pontos de swing. Portanto, essa abordagem deve ser evitada. Em vez disso, é preferível permitir que os laços sejam executados normalmente ou aplicar técnicas de filtragem para refinar os sinais sem perder possíveis oportunidades.
Identificação do ponto D
Depois de identificar os pontos X, A, B e C, a próxima etapa consiste em localizar o ponto D para completar o padrão de Gartley. Esse ponto é especialmente importante, pois representa uma possível zona de entrada e marca o final do último segmento da estrutura. Para identificá-lo, procuramos um topo de swing formado após o ponto C. Esse movimento deve ocorrer na direção oposta à do segmento BC, completando o segmento CD.
Exemplo:
double D; datetime D_time; string D_letter; string cd_line;
for(int m = l; m < bars_check - z; m++) { if(IsSwingHigh(high, m, z) && high[m] > B) { D = high[m]; D_time = time[m]; D_letter = StringFormat("D %d",m); ObjectCreate(chart_id,D_letter,OBJ_TEXT,0,D_time,D); ObjectSetString(chart_id,D_letter,OBJPROP_TEXT,"D"); cd_line = StringFormat("CD Line %d",i); ObjectCreate(chart_id,cd_line,OBJ_TREND,0,C_time,C,D_time,D); ObjectCreate(chart_id,B_letter,OBJ_TEXT,0,B_time,B); ObjectSetString(chart_id,B_letter,OBJPROP_TEXT,"B"); ObjectCreate(chart_id,C_letter,OBJ_TEXT,0,C_time,C); ObjectSetString(chart_id,C_letter,OBJPROP_TEXT,"C"); ab_line = StringFormat("AB Line %d",i); ObjectCreate(chart_id,ab_line,OBJ_TREND,0,A_time,A,B_time,B); bc_line = StringFormat("BC Line %d", i); ObjectCreate(chart_id,bc_line,OBJ_TREND,0,B_time,B,C_time,C); ObjectCreate(chart_id,X_letter,OBJ_TEXT,0,X_time,X); ObjectSetString(chart_id,X_letter,OBJPROP_TEXT,"X"); ObjectCreate(chart_id,A_letter,OBJ_TEXT,0,A_time,A); ObjectSetString(chart_id,A_letter,OBJPROP_TEXT,"A"); xa_line = StringFormat("XA Line %d",i); ObjectCreate(chart_id,xa_line,OBJ_TREND,0,X_time,X,A_time,A); i = m+1; break; } }
Resultado:

Explicação:
O laço começa a percorrer o gráfico a partir do índice do ponto C (l), procurando possíveis topos de swing que possam corresponder ao ponto D. A condição IsSwingHigh(high, m, z) && high[m] > B garante que o ponto D selecionado seja um topo de swing acima do ponto B, e não simplesmente um máximo arbitrário. Essa verificação é fundamental para a estrutura descrita, pois exige que o ponto D ultrapasse o nível do ponto B no padrão de Gartley de baixa.
Ao identificar um topo de swing que satisfaça essa condição, o código cria a linha CD, conectando o ponto C ao topo encontrado, adiciona a etiqueta "D" ao gráfico e armazena o preço e o horário nas variáveis correspondentes ao ponto D. Ao mesmo tempo, o código redesenha as linhas associadas aos demais pontos importantes da estrutura.
Depois de identificar corretamente os pontos de swing, precisamos confirmar que cada um deles corresponde ao extremo de preço mais significativo dentro do respectivo segmento. Não basta marcar topos e fundos, pois pequenas oscilações podem comprometer a identificação da estrutura. Para evitar sinais falsos, é necessário aplicar critérios rigorosos que permitam validar cada ponto de swing.
Primeiro, o ponto C deve corresponder à mínima mais baixa no intervalo entre C e D. Isso garante que o segmento CD comece em um fundo de swing válido, e não em uma queda temporária. Da mesma forma, o ponto B deve apresentar a máxima mais alta no intervalo entre B e C, garantindo que o segmento BC represente uma retração a partir de um topo de swing significativo.
Também precisamos verificar se o ponto A corresponde à mínima mais baixa no intervalo entre A e B. Essa condição confirma que o segmento AB começa em um fundo válido, e não em uma oscilação arbitrária. Por fim, o ponto X deve apresentar a máxima mais alta no intervalo entre X e A. Essa verificação garante que o segmento XA tenha início no topo de swing mais alto dessa região.
Exemplo:
int x_a_bars; int x_highest_index; double x_a_hh; datetime x_a_hh_t; int a_b_bars; int a_lowest_index; double a_b_ll; datetime a_b_ll_t; int b_c_bars; int b_highest_index; double b_c_hh; datetime b_c_hh_t; int c_d_bars; int c_lowest_index; double c_d_ll; datetime c_d_ll_t;
for(int m = l; m < bars_check - z; m++) { if(IsSwingHigh(high, m, z) && high[m] > B) { D = high[m]; D_time = time[m]; D_letter = StringFormat("D %d",m); c_d_bars = Bars(_Symbol,PERIOD_CURRENT,C_time,D_time); c_lowest_index = ArrayMinimum(low,l,c_d_bars); c_d_ll = low[c_lowest_index]; c_d_ll_t = time[c_lowest_index]; b_c_bars = Bars(_Symbol, PERIOD_CURRENT, B_time, c_d_ll_t); b_highest_index = ArrayMaximum(high, k, b_c_bars); b_c_hh = high[b_highest_index]; b_c_hh_t = time[b_highest_index]; a_b_bars = Bars(_Symbol,PERIOD_CURRENT,A_time,b_c_hh_t); a_lowest_index = ArrayMinimum(low,j,a_b_bars); a_b_ll = low[a_lowest_index]; a_b_ll_t = time[a_lowest_index]; x_a_bars = Bars(_Symbol, PERIOD_CURRENT, X_time, a_b_ll_t); x_highest_index = ArrayMaximum(high, a, x_a_bars); x_a_hh = high[x_highest_index]; x_a_hh_t = time[x_highest_index]; ObjectCreate(chart_id,D_letter,OBJ_TEXT,0,D_time,D); ObjectSetString(chart_id,D_letter,OBJPROP_TEXT,"D"); cd_line = StringFormat("CD Line %d",i); ObjectCreate(chart_id,cd_line,OBJ_TREND,0,c_d_ll_t,c_d_ll,D_time,D); ObjectCreate(chart_id,B_letter,OBJ_TEXT,0,b_c_hh_t,b_c_hh); ObjectSetString(chart_id,B_letter,OBJPROP_TEXT,"B"); ObjectCreate(chart_id,C_letter,OBJ_TEXT,0,c_d_ll_t,c_d_ll); ObjectSetString(chart_id,C_letter,OBJPROP_TEXT,"C"); ab_line = StringFormat("AB Line %d",i); ObjectCreate(chart_id,ab_line,OBJ_TREND,0,a_b_ll_t,a_b_ll,b_c_hh_t,b_c_hh); bc_line = StringFormat("BC Line %d", i); ObjectCreate(chart_id,bc_line,OBJ_TREND,0,b_c_hh_t,b_c_hh,c_d_ll_t,c_d_ll); ObjectCreate(chart_id,X_letter,OBJ_TEXT,0,x_a_hh_t,x_a_hh); ObjectSetString(chart_id,X_letter,OBJPROP_TEXT,"X"); ObjectCreate(chart_id,A_letter,OBJ_TEXT,0,a_b_ll_t,a_b_ll); ObjectSetString(chart_id,A_letter,OBJPROP_TEXT,"A"); xa_line = StringFormat("XA Line %d",i); ObjectCreate(chart_id,xa_line,OBJ_TREND,0,x_a_hh_t,x_a_hh,a_b_ll_t,a_b_ll); i = m+1; break; } }
Explicação:
O principal objetivo deste trecho de código é validar os pontos de swing identificados e garantir que a estrutura de Gartley seja construída com base nos maiores máximos e menores mínimos de cada segmento. A verificação começa quando um novo topo de swing, acima do ponto B, é identificado após o ponto C. Embora esse topo seja inicialmente considerado o ponto D, o código verifica todos os pontos anteriores antes de confirmar a presença do padrão.
A verificação começa pelo intervalo entre C e D. O código procura a mínima mais baixa nesse intervalo para confirmar que o ponto C corresponde ao fundo efetivo entre esses dois pontos, e não apenas a uma queda temporária. Em seguida, analisa o intervalo entre B e C para identificar a máxima mais alta. Isso garante que o ponto B seja o topo mais alto desse intervalo, e não apenas um pequeno pico que poderia comprometer a identificação do padrão.
Depois, o código procura a mínima mais baixa no intervalo entre A e B, para confirmar que o ponto A corresponde ao fundo mais significativo desse segmento. Por fim, identifica a máxima mais alta no intervalo entre X e A, verificando se o ponto X representa o topo mais alto antes da queda em direção ao ponto A. Com essas verificações, o código garante que os pontos X, A, B e C correspondam a extremos de swing válidos para a construção do padrão harmônico.
Retração de Fibonacci
Depois de identificar e validar os pontos de swing, a próxima etapa consiste em verificar se a estrutura atende aos critérios do padrão de Gartley. Como nem toda sequência de swings forma um padrão harmônico válido, não basta marcar os pontos X, A, B, C e D no gráfico. Para reconhecer o padrão, precisamos aplicar critérios de retração e extensão de Fibonacci aos diferentes segmentos da estrutura.
As medições de Fibonacci funcionam como filtros para verificar se os movimentos de preço atendem às relações exigidas pelo padrão de Gartley. Por exemplo, o ponto B deve corresponder a uma retração dentro de uma faixa específica do segmento XA, o ponto C deve respeitar uma faixa de retração em relação ao segmento AB, e a extensão até o ponto D deve atender a determinadas proporções de Fibonacci em relação aos demais swings. Se essas condições forem satisfeitas, a estrutura poderá ser classificada como um padrão de Gartley válido.
Exemplo:
input double b_xa_max = 78.6; // MAX B RETRACEMENT LEVEL FOR XA input double b_xa_min = 61.8; // MIN B RETRACEMENT LEVEL FOR XA input double c_ab_max = 88.6; // MAX C RETRACEMENT LEVEL FOR AB input double c_ab_min = 38.2; // MIN C RETRACEMENT LEVEL FOR AB input double d_xa_max = 76.0; // MAX D RETRACEMENT LEVEL FOR XA input double d_xa_min = 80.0; // MIN D RETRACEMENT LEVEL FOR XA double lvl_max_b; double lvl_min_b; double lvl_max_c; double lvl_min_c; double lvl_max_d; double lvl_min_d;
if(IsSwingHigh(high, m, z) && high[m] > B) { D = high[m]; D_time = time[m]; D_letter = StringFormat("D %d",m); c_d_bars = Bars(_Symbol,PERIOD_CURRENT,C_time,D_time); c_lowest_index = ArrayMinimum(low,l,c_d_bars); c_d_ll = low[c_lowest_index]; c_d_ll_t = time[c_lowest_index]; b_c_bars = Bars(_Symbol, PERIOD_CURRENT, B_time, c_d_ll_t); b_highest_index = ArrayMaximum(high, k, b_c_bars); b_c_hh = high[b_highest_index]; b_c_hh_t = time[b_highest_index]; a_b_bars = Bars(_Symbol,PERIOD_CURRENT,A_time,b_c_hh_t); a_lowest_index = ArrayMinimum(low,j,a_b_bars); a_b_ll = low[a_lowest_index]; a_b_ll_t = time[a_lowest_index]; x_a_bars = Bars(_Symbol, PERIOD_CURRENT, X_time, a_b_ll_t); x_highest_index = ArrayMaximum(high, a, x_a_bars); x_a_hh = high[x_highest_index]; x_a_hh_t = time[x_highest_index]; lvl_min_b = a_b_ll + ((b_xa_min / 100) * (x_a_hh - a_b_ll)); lvl_max_b = a_b_ll + ((b_xa_max / 100) * (x_a_hh - a_b_ll)); lvl_min_c = b_c_hh - ((c_ab_min / 100) * (b_c_hh - a_b_ll)); lvl_max_c = b_c_hh - ((c_ab_max / 100) * (b_c_hh - a_b_ll)); lvl_min_d = a_b_ll + ((d_xa_min / 100) * (x_a_hh - a_b_ll)); lvl_max_d = a_b_ll + ((d_xa_max / 100) * (x_a_hh - a_b_ll)); if(b_c_hh >= lvl_min_b && b_c_hh <= lvl_max_b && c_d_ll <= lvl_min_c && c_d_ll >= lvl_max_c && D >= lvl_min_d && D <= lvl_max_d) { ObjectCreate(chart_id,D_letter,OBJ_TEXT,0,D_time,D); ObjectSetString(chart_id,D_letter,OBJPROP_TEXT,"D"); cd_line = StringFormat("CD Line %d",i); ObjectCreate(chart_id,cd_line,OBJ_TREND,0,c_d_ll_t,c_d_ll,D_time,D); ObjectCreate(chart_id,B_letter,OBJ_TEXT,0,b_c_hh_t,b_c_hh); ObjectSetString(chart_id,B_letter,OBJPROP_TEXT,"B"); ObjectCreate(chart_id,C_letter,OBJ_TEXT,0,c_d_ll_t,c_d_ll); ObjectSetString(chart_id,C_letter,OBJPROP_TEXT,"C"); ab_line = StringFormat("AB Line %d",i); ObjectCreate(chart_id,ab_line,OBJ_TREND,0,a_b_ll_t,a_b_ll,b_c_hh_t,b_c_hh); bc_line = StringFormat("BC Line %d", i); ObjectCreate(chart_id,bc_line,OBJ_TREND,0,b_c_hh_t,b_c_hh,c_d_ll_t,c_d_ll); ObjectCreate(chart_id,X_letter,OBJ_TEXT,0,x_a_hh_t,x_a_hh); ObjectSetString(chart_id,X_letter,OBJPROP_TEXT,"X"); ObjectCreate(chart_id,A_letter,OBJ_TEXT,0,a_b_ll_t,a_b_ll); ObjectSetString(chart_id,A_letter,OBJPROP_TEXT,"A"); xa_line = StringFormat("XA Line %d",i); ObjectCreate(chart_id,xa_line,OBJ_TREND,0,x_a_hh_t,x_a_hh,a_b_ll_t,a_b_ll); } // i = m+1; break; } }
Explicação:
Começamos pelos parâmetros de entrada. Para determinar se a estrutura formada pelos pontos X, A, B, C e D corresponde a um padrão de Gartley válido, o EA utilizará níveis de retração de Fibonacci configuráveis pelo usuário. Por exemplo, de acordo com os parâmetros definidos, o ponto B deverá situar-se dentro de uma faixa de retração específica do segmento XA, o ponto C deverá estar dentro da faixa de retração estabelecida para o segmento AB, e o ponto D deverá corresponder ao nível de retração de Fibonacci especificado em relação ao segmento XA.
Os níveis de preço em que cada ponto de swing deve se formar são representados por variáveis calculadas pelo programa. Com base nas proporções de Fibonacci definidas nos parâmetros de entrada, esses valores são calculados a partir dos preços máximos e mínimos dos segmentos XA e AB. Por exemplo, os níveis de retração do segmento XA determinam a faixa de preços válida para o ponto B. O mesmo método é utilizado para calcular as faixas correspondentes aos pontos C e D, tomando como referência os segmentos AB e XA, respectivamente.
A última condição verifica se cada ponto do padrão está dentro da faixa de Fibonacci exigida, confirmando que os pontos B, C e D atendem aos respectivos critérios de retração. Quando todas essas condições são satisfeitas, o programa cria objetos gráficos para representar visualmente o padrão de Gartley identificado, marcando os pontos X, A, B, C e D e traçando as linhas que os conectam.
Execução de operações
Após identificar com sucesso um padrão de Gartley válido, a próxima etapa é executar uma operação. Até aqui, o EA se concentrou na análise dos dados de preços, na identificação de topos e fundos de swing e na verificação das proporções de Fibonacci, para confirmar que a estrutura atende aos critérios do padrão de Gartley. No entanto, a identificação do padrão apenas revela uma possível oportunidade de negociação, sem gerar lucro por si só. A parte mais interessante começa quando o EA passa a executar operações no mercado com base nessas informações.
Na prática, isso significa que o EA precisa determinar onde entrar na operação e em quais níveis posicionar o Take Profit e o Stop Loss. Por exemplo, em um padrão de Gartley de baixa, o EA normalmente abre uma ordem de venda no ponto D. Para limitar as perdas caso o padrão seja invalidado, o Stop Loss é posicionado um pouco acima do topo de swing correspondente ao ponto D. O Take Profit pode ser definido com base em alvos de extensão de Fibonacci ou em uma relação risco-retorno, como 1:3. Ao automatizar essas decisões, o EA permite executar a estratégia de maneira consistente, sem indecisões ou vieses emocionais.
Exemplo:
#include <Trade/Trade.mqh> CTrade trade; input int MagicNumber = 61626; input double lot_size = 0.1; double ask_price; datetime time_price[]; double take_p; string XAB; string BCD; datetime lastTradeBarTime = 0; //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { //--- trade.SetExpertMagicNumber(MagicNumber); ArraySetAsSeries(time_price,true); //--- return(INIT_SUCCEEDED); } //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { //--- ObjectsDeleteAll(chart_id); }
CopyTime(_Symbol, timeframe, 0, 2, time_price); ask_price = SymbolInfoDouble(_Symbol,SYMBOL_ASK); datetime currentBarTime = iTime(_Symbol,timeframe,0); if(b_c_hh >= lvl_min_b && b_c_hh <= lvl_max_b && c_d_ll <= lvl_min_c && c_d_ll >= lvl_max_c && D >= lvl_min_d && D <= lvl_max_d) { ObjectCreate(chart_id,D_letter,OBJ_TEXT,0,D_time,D); ObjectSetString(chart_id,D_letter,OBJPROP_TEXT,"D"); cd_line = StringFormat("CD Line %d",i); ObjectCreate(chart_id,cd_line,OBJ_TREND,0,c_d_ll_t,c_d_ll,D_time,D); ObjectCreate(chart_id,B_letter,OBJ_TEXT,0,b_c_hh_t,b_c_hh); ObjectSetString(chart_id,B_letter,OBJPROP_TEXT,"B"); ObjectCreate(chart_id,C_letter,OBJ_TEXT,0,c_d_ll_t,c_d_ll); ObjectSetString(chart_id,C_letter,OBJPROP_TEXT,"C"); ab_line = StringFormat("AB Line %d",i); ObjectCreate(chart_id,ab_line,OBJ_TREND,0,a_b_ll_t,a_b_ll,b_c_hh_t,b_c_hh); bc_line = StringFormat("BC Line %d", i); ObjectCreate(chart_id,bc_line,OBJ_TREND,0,b_c_hh_t,b_c_hh,c_d_ll_t,c_d_ll); ObjectCreate(chart_id,X_letter,OBJ_TEXT,0,x_a_hh_t,x_a_hh); ObjectSetString(chart_id,X_letter,OBJPROP_TEXT,"X"); ObjectCreate(chart_id,A_letter,OBJ_TEXT,0,a_b_ll_t,a_b_ll); ObjectSetString(chart_id,A_letter,OBJPROP_TEXT,"A"); xa_line = StringFormat("XA Line %d",i); ObjectCreate(chart_id,xa_line,OBJ_TREND,0,x_a_hh_t,x_a_hh,a_b_ll_t,a_b_ll); XAB = StringFormat("XAB TRIANGLE %d", i); BCD = StringFormat("BCD TRIANGLE %d", i); ObjectCreate(chart_id,XAB,OBJ_TRIANGLE,0,x_a_hh_t,x_a_hh,a_b_ll_t,a_b_ll,b_c_hh_t,b_c_hh); ObjectSetInteger(chart_id,XAB,OBJPROP_FILL,true); ObjectSetInteger(chart_id,XAB,OBJPROP_COLOR,clrPink); ObjectSetInteger(chart_id,XAB,OBJPROP_BACK,true); ObjectCreate(chart_id,BCD,OBJ_TRIANGLE,0,b_c_hh_t,b_c_hh,c_d_ll_t,c_d_ll,D_time,D); ObjectSetInteger(chart_id,BCD,OBJPROP_FILL,true); ObjectSetInteger(chart_id,BCD,OBJPROP_COLOR,clrPink); ObjectSetInteger(chart_id,BCD,OBJPROP_BACK,true); if(time[m+z] == time_price[1] && currentBarTime != lastTradeBarTime) { take_p = ask_price - (MathAbs(D - ask_price) * 3); trade.Sell(lot_size,_Symbol,ask_price,D,take_p); lastTradeBarTime = currentBarTime; } }
Resultado:

Explicação:
Esta seção do programa controla tanto a representação visual do padrão de Gartley no gráfico quanto a lógica de negociação. Primeiro, a biblioteca padrão de negociação do MQL5 é incluída por meio da diretiva #include <Trade/Trade.mqh>. Em seguida, é criada uma instância da classe CTrade, denominada trade, para gerenciar as operações de negociação, incluindo a abertura e o fechamento de posições. Na linha rade.SetExpertMagicNumber(MagicNumber);, é utilizado o parâmetro de entrada MagicNumber, que permite identificar e distinguir as operações executadas por este EA.
O volume negociado é definido por outros parâmetros importantes, como lot_size. Também são declaradas variáveis auxiliares, como ask_price, time_price[] e take_p, para armazenar o preço de mercado, os dados de horário e os níveis calculados de Take Profit. Como medida de segurança, a variável lastTradeBarTime é utilizada para impedir que mais de uma operação seja aberta na mesma barra.
A instrução ArraySetAsSeries(time_price, true); configura o array para que o elemento mais recente seja acessado pelo índice 0, permitindo o processamento correto dos dados temporais. Em seguida, os horários de abertura das duas barras mais recentes são copiados para o array time_price por meio da função CopyTime(_Symbol, таймфрейм, 0, 2, time_price). A linha Ask_price = SymbolInfoDouble(_Symbol, SYMBOL_ASK); obtém o preço Ask atual, enquanto currentBarTime = iTime(_Symbol, таймфрейм, 0); armazena a marca de tempo do candle mais recente.
O programa utiliza esses critérios para determinar com precisão quando as condições de negociação são atendidas. Ao comparar os horários das barras, uma verificação condicional limita as tentativas de operação a uma por barra. Quando as condições são satisfeitas, o nível de Take Profit é calculado pela instrução take_p = ask_price - (MathAbs(D - ask_price) * 3);, enquanto a chamada de venda é apresentada como Sell(lot_size, D, take_p, ask_price, _Symbol);. Em seguida, a variável lastTradeBarTime é atualizada para impedir a abertura de novas operações na mesma barra.
Além de executar operações, o programa também exibe o padrão de Gartley diretamente no gráfico. Por exemplo, as instruções XAB = StringFormat("XAB TRIANGLE %d", i); e BCD = StringFormat("BCD TRIANGLE %d", i); utilizam StringFormat para gerar nomes exclusivos para os objetos gráficos. Em seguida, a função ObjectCreate é utilizada para desenhar dois triângulos com esses identificadores. O primeiro triângulo representa a parte XAB do padrão, enquanto o segundo representa a parte BCD. Suas coordenadas são definidas com base nas posições dos respectivos pontos de swing identificados anteriormente pelo programa.
As propriedades dos triângulos são configuradas por meio de ObjectSetInteger, que permite definir o preenchimento, aplicar a cor rosa e posicionar os objetos no plano de fundo do gráfico, destacando os padrões identificados. Ao combinar a execução automática de operações com uma representação gráfica clara, o programa não apenas reage aos padrões de Gartley detectados, mas também permite que o trader os examine visualmente.
Conclusão
Neste artigo, aprendemos a construir o padrão de Gartley e negociar com base nele utilizando a linguagem MQL5. Começamos identificando os pontos de swing (X, A, B, C e D), aplicamos os níveis de retração e extensão de Fibonacci para validar a estrutura e, em seguida, automatizamos a execução de operações após a confirmação de um padrão válido. Por fim, adicionamos objetos gráficos para representar visualmente o padrão de forma clara, facilitando seu acompanhamento à medida que se forma. Este projeto demonstra como transformar padrões harmônicos complexos em código e automatizar operações com base neles. A partir dessa estrutura, você poderá aprimorar as regras, adicionar novos critérios de confirmação ou adaptar a lógica apresentada a outros padrões harmônicos.
Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/19331
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.