Desenvolvimento de um kit de ferramentas para análise de Price Action (Parte 39): Automatização da detecção de BOS e ChOCh em MQL5
Introdução
Bem-vindos à Parte 39 da série Desenvolvimento de um kit de ferramentas para análise de Price Action. Nesta etapa, vamos desenvolver um sistema prático em MQL5 que ajuda os traders que utilizam Price Action a interpretar melhor os gráficos, identificando mudanças na estrutura do mercado que poderiam passar despercebidas durante a simples observação dos candles. Nosso objetivo é transformar pontos de pivô fractais e regras de estrutura de mercado em sinais confiáveis, que não sofram repintura e possam ser utilizados tanto na negociação em tempo real quanto nos testes com dados históricos.
Utilizaremos pontos de pivô fractais como referências locais confiáveis para identificar dois sinais complementares: o ChOCh (mudança de caráter), que indica a perda da direção anterior do mercado, por exemplo, quando uma tendência de alta deixa de formar máximas mais altas ou uma tendência de baixa deixa de formar mínimas mais baixas; e o BOS (rompimento de estrutura), que confirma a mudança de direção quando o preço fecha de forma decisiva acima ou abaixo de uma máxima ou mínima de swing anterior. O ChOCh deve ser interpretado como um alerta antecipado, enquanto o BOS funciona como sinal de confirmação.

A combinação de fractais com ChOCh/BOS fornece pontos de referência mais claros, que não sofrem repintura, permite emitir alertas antecipados sobre possíveis reversões e facilita a análise da estrutura do mercado em diferentes períodos gráficos. Isso também ajuda a filtrar o ruído nos períodos gráficos menores. Como essas regras podem ser facilmente automatizadas e avaliadas por meio de testes com dados históricos, enquanto os eventos gerados podem ser registrados em logs, são especialmente adequadas para implementação em um EA.
Neste artigo, examinaremos a concepção do algoritmo e sua implementação completa em MQL5, incluindo a identificação de fractais em barras fechadas, o armazenamento de fractais com gerenciamento seguro da memória, a renderização segura de objetos gráficos persistentes e o tratamento de eventos para registrar e emitir alertas a cada BOS ou ChOCh confirmado, tanto em desktops quanto em dispositivos móveis, inclusive com notificações sonoras. Ao final, você terá um detector de nível profissional, pronto para compilar, testar e executar.
Começaremos pela lógica da estratégia e, em seguida, abordaremos sua implementação em MQL5, os alertas, as configurações de logs e notificações, os testes e seus resultados. Por fim, apresentaremos as conclusões. Confira abaixo o sumário do artigo.
- Introdução
- Lógica da estratégia
- Implementação em MQL5
- Configurações de alertas, logs e notificações
- Testes e resultados
- Conclusão
Lógica da estratégia
Nesta seção, examinaremos a lógica que fundamenta a estratégia utilizada no sistema que estamos desenvolvendo. A abordagem se baseia no indicador de fractais e nos sinais de estrutura de mercado derivados desses pontos. Em um dos artigos anteriores, já abordamos uma estratégia de tendência baseada no rompimento de fractais. Os fractais são bastante versáteis: além de servirem de referência para estratégias de rompimento, fornecem pontos de referência confiáveis para diversas aplicações na análise de Price Action. Aqui, vamos utilizá-los para detectar mudanças de caráter (Change of Character, ChOCh) e rompimentos de estrutura (Break of Structure, BOS).
Um ponto de pivô fractal é um ponto de reversão local formado quando a máxima (ou mínima) da barra central é superior (ou inferior) às máximas (ou mínimas) de um número simétrico de barras adjacentes. Na prática, considerando uma janela de tamanho g_length = 2*p + 1, a barra central é classificada como fractal de alta quando sua máxima é maior ou igual à máxima de todas as demais barras da janela, e como fractal de baixa quando sua mínima é menor ou igual à mínima de todas as demais barras. Os fractais fornecem pontos de referência estáveis, que não sofrem repintura, pois sua identificação exige uma janela completa de barras de confirmação.
O rompimento de estrutura (BOS) ocorre quando o preço rompe de forma decisiva a estrutura recente do mercado, fechando acima de uma máxima de swing anterior (BOS de alta) ou abaixo de uma mínima de swing anterior (BOS de baixa). Esse sinal indica que o momentum e a direção do mercado, no curto e médio prazo, passaram a favorecer o lado do rompimento. É esse tipo de confirmação que os traders costumam utilizar para entrar em operações a favor da nova direção do movimento.
A mudança de caráter (ChOCh) é um sinal mais precoce e menos conclusivo de uma possível alteração na direção do mercado. Um exemplo típico ocorre quando uma tendência de alta deixa de formar máximas mais altas ou uma tendência de baixa deixa de formar mínimas mais baixas. O ChOCh deve ser interpretado como um alerta: muitas vezes antecede um BOS, caso o movimento subsequente do preço se torne mais convincente. Isso permite que o trader se prepare, aproximando os stops do preço, reduzindo a exposição ao risco ou procurando oportunidades de entrada em uma possível reversão.
Para evitar a repintura dos sinais, é fundamental que todas as avaliações sejam feitas exclusivamente com barras fechadas. Na prática, isso significa comparar os preços de fechamento das barras concluídas (por exemplo, prevClose e curClose) com os níveis fractais armazenados. Nunca emitimos um sinal de BOS ou ChOCh com base em uma barra ainda em formação e, portanto, não confirmada. A análise de barras fechadas garante que os eventos possam ser reproduzidos e avaliados em testes com dados históricos.
O algoritmo foi desenvolvido para ser simples e determinístico: identifica pontos de referência fractais confiáveis em barras fechadas, monitora se o preço cruza esses níveis com base nos fechamentos das barras, marca e desenha cada rompimento uma única vez e gera exatamente uma entrada no log e um alerta para cada evento confirmado. Essa abordagem evita a repintura dos sinais e produz resultados reproduzíveis, adequados para testes com dados históricos.
- Visão geral do funcionamento

- Aguardar o fechamento de uma nova barra (utilizando a marca de tempo da barra fechada como gatilho).
- Identificar um fractal no centro de uma janela simétrica de tamanho g_length = 2*p + 1.
- Se um fractal for encontrado, armazenar seus dados (tempo e preço) e definir o sinalizador marked como false.
- A cada nova barra fechada, comparar prevClose e curClose com o preço de cada fractal armazenado para detectar cruzamentos.
- Quando ocorrer um cruzamento (rompimento confirmado pelo fechamento da barra), marcar o fractal correspondente, desenhar uma linha horizontal ou de tendência e um rótulo associado a ele e, em seguida, gerar uma única entrada no log e um único alerta.
- Remover periodicamente os fractais antigos para impedir o crescimento ilimitado dos arrays.
Pseudocódigo principal (resumido):
if new_closed_bar(): ScanForFractals() // detect & append new fractal anchors PruneFractals(maxKeepBars) // remove very old anchors for each fractal in stored_fractals: if not fractal.marked and crossed(prevClose, curClose, fractal.price): DrawBreak(fractal) LabelAndLog(fractal) fractal.marked = true
Implementação em MQL5
Cabeçalho e metadados
No início do arquivo, comentários breves apresentam os principais metadados: nome do arquivo, autor, informações de direitos autorais e links de referência. Esses dados são úteis tanto para o controle de versões quanto para consultas futuras, especialmente quando o arquivo é compartilhado com outras pessoas ou retomado posteriormente. As diretivas #property definem as configurações de compilação. Em particular, #property strict ativa verificações mais rigorosas de tipos e do uso das APIs, ajudando a identificar erros difíceis de perceber ainda nas etapas iniciais do desenvolvimento. A diretiva #include <stdlib.mqh> incorpora uma biblioteca auxiliar padrão que simplifica tarefas comuns e mantém o código principal mais limpo e fácil de manter. Caso essa biblioteca não esteja disponível no ambiente do leitor, será necessário instalá-la ou remover a diretiva correspondente para evitar erros de compilação.
//+------------------------------------------------------------------+ //| Fractal Reaction System.mq5| //| Copyright 2025, Christian Benjamin.| //| https://www.mql5.com/ru/users/lynnchris| //+------------------------------------------------------------------+ #property copyright "Copyright 2025, Christian Benjamin." #property link "https://www.mql5.com/ru/users/lynnchris" #property version "1.0" #property strict #include <stdlib.mqh>
Parâmetros de entrada do usuário
O bloco de parâmetros de entrada reúne as configurações que controlam o comportamento do EA sem a necessidade de recompilação. AutoDetectLength seleciona automaticamente um tamanho adequado para a janela de detecção de fractais com base no período gráfico, enquanto LengthInput permite definir esse tamanho manualmente. Vale lembrar que a identificação de fractais exige uma janela com um número ímpar de barras (por exemplo, 3, 5 ou 7), garantindo a existência de uma única barra central com barras vizinhas distribuídas simetricamente. As opções de exibição, como ShowBull e ShowBear, e as configurações de cores (BullColor e BearColor) melhoram a clareza visual e agilizam a interpretação dos sinais em diferentes gráficos.
Os parâmetros HorizontalRightBars e HorizontalLeftExtend determinam até onde as linhas se estendem visualmente para a direita ou para a esquerda, facilitando a avaliação da atualidade dos níveis identificados. DebugMode ativa o registro de informações de diagnóstico em logs durante o desenvolvimento e os testes, enquanto MaxFractalHistoryBars limita a quantidade de fractais históricos armazenados, evitando que o consumo de memória cresça indefinidamente durante a execução prolongada do EA.
// User-configurable inputs input bool AutoDetectLength = false; input int LengthInput = 5; input bool ShowBull = true; input color BullColor = clrLime; input bool ShowBear = true; input color BearColor = clrRed; input int HorizontalRightBars = 0; input int HorizontalLeftExtend = 3; input bool DebugMode = false; input int MaxFractalHistoryBars = 2000;
Variáveis globais e estruturas de dados
As variáveis globais mantêm o estado do sistema durante a execução e armazenam os dados de forma persistente enquanto o EA estiver em funcionamento. g_chart_id armazena o identificador do gráfico, garantindo que todos os objetos gráficos sejam explicitamente associados ao gráfico correto. g_length representa o tamanho da janela de detecção de fractais, enquanto p_half indica o número de barras em cada lado da barra central. Esses valores são calculados uma única vez durante a inicialização e reutilizados posteriormente. ea_digits, ea_point e ea_point_pips permitem adaptar os cálculos de preços às características de diferentes corretoras e símbolos, garantindo deslocamentos uniformes e o posicionamento correto dos rótulos. O sistema armazena os fractais de alta e de baixa em arrays paralelos (_time[], _price[], _marked[]): a marca de tempo e o preço identificam cada fractal, enquanto o sinalizador marked impede que ele seja processado mais de uma vez. Por fim, os_state* representa a direção atual do mercado segundo a lógica do sistema: 0 indica um estado neutro, 1 uma direção de alta e -1 uma direção de baixa.
// Internal globals long g_chart_id; int g_length; int p_half; int ea_digits; double ea_point, ea_point_pips; datetime bull_time[]; double bull_price[]; bool bull_marked[]; datetime bear_time[]; double bear_price[]; bool bear_marked[]; int os_state = 0; // 0: none, 1: bullish, -1: bearish
Inicialização (OnInit)
OnInit() inicializa o sistema e valida os parâmetros de entrada. A função obtém o identificador do gráfico, determina o tamanho da janela de detecção de fractais (automaticamente ou com base no valor definido pelo usuário), garante que não seja inferior ao mínimo permitido e que seja um número ímpar. Em seguida, calcula p_half e consulta a precisão do símbolo para determinar o tamanho do ponto e do pip, necessários ao posicionamento preciso dos elementos gráficos. Os arrays de fractais são reinicializados e ficam vazios. Quando DebugMode está ativado, a função registra uma mensagem de inicialização com os principais valores da configuração, permitindo verificar se os parâmetros estão corretos antes do início da execução.
int OnInit() { g_chart_id = ChartID(); // Determine fractal length if(AutoDetectLength) { if(_Period <= PERIOD_H1) g_length = 5; else if(_Period <= PERIOD_H4) g_length = 7; else if(_Period <= PERIOD_D1) g_length = 9; else g_length = 11; } else { g_length = LengthInput; } // Ensure odd length >=3 if(g_length < 3) g_length = 5; if((g_length % 2) == 0) g_length++; p_half = g_length / 2; // Get symbol info ea_digits = (int)SymbolInfoInteger(_Symbol, SYMBOL_DIGITS); ea_point = Point(); ea_point_pips = ea_point; if(ea_digits == 3 || ea_digits == 5) ea_point_pips = Point() * 10.0; // Clear fractal arrays ArrayResize(bull_time,0); ArrayResize(bull_price,0); ArrayResize(bull_marked,0); ArrayResize(bear_time,0); ArrayResize(bear_price,0); ArrayResize(bear_marked,0); if(DebugMode) PrintFormat("EA INIT: AutoDetect=%s LengthInput=%d g_length=%d p_half=%d chart=%d", AutoDetectLength ? "true" : "false", LengthInput, g_length, p_half, g_chart_id); return(INIT_SUCCEEDED); }
Limpeza (OnDeinit)
OnDeinit() realiza a limpeza dos objetos gráficos quando o EA é removido do gráfico. A função chama CleanupObjectsByPrefix, utilizando um prefixo comum para localizar e excluir todos os objetos criados pelo EA, como linhas de tendência e rótulos. Isso evita o acúmulo de objetos residuais no gráfico e impede que interfiram em análises posteriores ou no funcionamento de outras ferramentas. Esse cuidado é especialmente importante em soluções de nível profissional e demonstrações.
void OnDeinit(const int reason) { CleanupObjectsByPrefix("CHB_"); }
Ciclo principal (OnTick)
OnTick() implementa a lógica de "uma execução por barra fechada", garantindo um comportamento determinístico. A função verifica a marca de tempo da última barra fechada e interrompe o processamento caso não tenha surgido uma nova barra fechada desde a verificação anterior. Quando uma nova barra fechada é detectada, OnTick() chama três funções principais: ScanForFractals(), responsável por identificar novos fractais confirmados; PruneFractals(), que remove os registros mais antigos do que o limite de histórico definido; e ProcessFractalCrosses(), que verifica se o preço cruzou algum dos níveis fractais armazenados. Essa sequência otimiza o desempenho e garante que todas as etapas de detecção e processamento utilizem exclusivamente barras fechadas, condição essencial para obter resultados reproduzíveis em testes com dados históricos e manter a confiabilidade da execução em tempo real.
void OnTick() { static datetime last_checked = 0; datetime t = iTime(_Symbol, _Period, 1); if(t == last_checked) return; last_checked = t; ScanForFractals(); PruneFractals(MaxFractalHistoryBars); ProcessFractalCrosses(); }
Detecção de fractais (ScanForFractals)
ScanForFractals() começa verificando se há dados históricos suficientes e, em seguida, analisa a barra central, localizada no deslocamento p_half, que corresponde ao centro da janela de detecção de fractais. A função chama IsFractalHighAtShift() e IsFractalLowAtShift para determinar se essa barra constitui um fractal de alta ou de baixa. Essas funções auxiliares realizam comparações rigorosas entre os valores da barra central e os das barras vizinhas. Quando um fractal válido é identificado, a função verifica sua marca de tempo para evitar duplicações. Se ele ainda não estiver registrado, adiciona sua marca de tempo e seu preço aos arrays correspondentes e define seu estado como não processado, permitindo que ele seja considerado posteriormente na detecção de cruzamentos.
void ScanForFractals() { int bars = iBars(_Symbol, _Period); if(bars <= g_length) return; int centerShift = p_half; if(centerShift >= bars) return; // High fractal detection if(IsFractalHighAtShift(centerShift)) { datetime t_fr = (datetime)iTime(_Symbol, _Period, centerShift); double p_fr = iHigh(_Symbol, _Period, centerShift); // Store if new bool exists = false; for(int i=0;i<ArraySize(bull_time);i++) if(bull_time[i]==t_fr) exists = true; if(!exists) { int n = ArraySize(bull_time); ArrayResize(bull_time, n+1); ArrayResize(bull_price, n+1); ArrayResize(bull_marked, n+1); bull_time[n] = t_fr; bull_price[n] = p_fr; bull_marked[n] = false; if(DebugMode) PrintFormat("FRAC_BULL DETECTED: t=%s price=%G", TimeToString(t_fr, TIME_DATE|TIME_SECONDS), p_fr); } } // Low fractal detection if(IsFractalLowAtShift(centerShift)) { datetime t_fr = (datetime)iTime(_Symbol, _Period, centerShift); double p_fr = iLow(_Symbol, _Period, centerShift); // Store if new bool exists = false; for(int i=0;i<ArraySize(bear_time);i++) if(bear_time[i]==t_fr) exists = true; if(!exists) { int n = ArraySize(bear_time); ArrayResize(bear_time, n+1); ArrayResize(bear_price, n+1); ArrayResize(bear_marked, n+1); bear_time[n] = t_fr; bear_price[n] = p_fr; bear_marked[n] = false; if(DebugMode) PrintFormat("FRAC_BEAR DETECTED: t=%s price=%G", TimeToString(t_fr, TIME_DATE|TIME_SECONDS), p_fr); } } }
Funções auxiliares de verificação de fractais
As funções IsFractalHighAtShift() e IsFractalLowAtShift() verificam se uma barra atende aos critérios de formação de um fractal, percorrendo uma janela simétrica em torno da barra central. Elas retornam false se alguma barra vizinha violar a condição de predominância da barra central ou se a janela completa não estiver disponível. Essas verificações rigorosas evitam sinais prematuros ou falsos e protegem contra erros de indexação no início do histórico ou após uma mudança de período gráfico. Para conjuntos de dados maiores, vale considerar a cópia de séries históricas em blocos por meio de CopyHigh/CopyLow, reduzindo o número de chamadas repetidas à API a cada barra e melhorando o desempenho.
bool IsFractalHighAtShift(int shift) { int bars = iBars(_Symbol,_Period); int p = p_half; if(shift < 0 || shift >= bars) return false; double center = iHigh(_Symbol,_Period,shift); for(int k=-p; k<=p; k++) { if(k == 0) continue; int s = shift + k; if(s < 0 || s >= bars) return false; // incomplete window if(iHigh(_Symbol,_Period,s) > center) return false; } return true; }
Função auxiliar: verificação de fractal de baixa
bool IsFractalLowAtShift(int shift) { int bars = iBars(_Symbol,_Period); int p = p_half; if(shift < 0 || shift >= bars) return false; double center = iLow(_Symbol,_Period,shift); for(int k=-p; k<=p; k++) { if(k == 0) continue; int s = shift + k; if(s < 0 || s >= bars) return false; if(iLow(_Symbol,_Period,s) < center) return false; } return true; }
Processamento de cruzamentos (ProcessFractalCrosses)
ProcessFractalCrosses() transforma os níveis fractais armazenados em sinais operacionais, verificando se o último fechamento confirmado cruzou algum desses níveis. A função adota uma abordagem conservadora, baseada exclusivamente em barras fechadas: compara prevClose (fechamento da barra anterior) com curClose (fechamento da última barra concluída) e utiliza CrossedOver() ou CrossedUnder() para determinar se houve um cruzamento. Quando detecta um cruzamento em um fractal ainda não processado, o EA atribui uma marcação exclusiva ao objeto, classifica o evento como rompimento de estrutura (BOS) ou mudança de caráter (ChOCh) com base no valor de os_state, desenha a linha de rompimento e o rótulo correspondente quando necessário, atualiza os_state, marca o fractal como processado e emite os alertas. Esse processamento único de cada fractal garante um comportamento determinístico, especialmente adequado para testes com dados históricos.
void ProcessFractalCrosses() { double prevClose = iClose(_Symbol, _Period, 2); double curClose = iClose(_Symbol, _Period, 1); datetime curTime = (datetime)iTime(_Symbol, _Period, 1); // Process bullish fractals for(int i=0; i<ArraySize(bull_time); i++) { if(bull_marked[i]) continue; double level = bull_price[i]; if(CrossedOver(prevClose, curClose, level)) { datetime fr_time = bull_time[i]; string tag = "CHB_BULL_" + IntegerToString((int)fr_time); bool isChoCH = (os_state == -1); string niceName = isChoCH ? "Bull ChoCH" : "Bull BOS"; if(ShowBull) { DrawBreak(tag, fr_time, level, curTime, true); CreateAnchoredLabel(tag + "_lbl", niceName, fr_time, level + 3*ea_point, BullColor); } os_state = 1; bull_marked[i] = true; string msg = StringFormat("%s detected: %s %s at %s price=%s", niceName, _Symbol, TimeframeToString(_Period), TimeToString(curTime, TIME_DATE|TIME_MINUTES), DoubleToString(level, ea_digits)); EmitLogAlert(msg); } } // Process bearish fractals for(int i=0; i<ArraySize(bear_time); i++) { if(bear_marked[i]) continue; double level = bear_price[i]; if(CrossedUnder(prevClose, curClose, level)) { datetime fr_time = bear_time[i]; string tag = "CHB_BEAR_" + IntegerToString((int)fr_time); bool isChoCH = (os_state == 1); string niceName = isChoCH ? "Bear ChoCH" : "Bear BOS"; if(ShowBear) { DrawBreak(tag, fr_time, level, curTime, false); CreateAnchoredLabel(tag + "_lbl", niceName, fr_time, level - 3*ea_point, BearColor); } os_state = -1; bear_marked[i] = true; string msg = StringFormat("%s detected: %s %s at %s price=%s", niceName, _Symbol, TimeframeToString(_Period), TimeToString(curTime, TIME_DATE|TIME_MINUTES), DoubleToString(level, ea_digits)); EmitLogAlert(msg); } } }
Notificações (EmitLogAlert)
EmitLogAlert() centraliza toda a lógica de notificações. A função sempre registra uma mensagem no log da aba "Experts", permitindo auditar os eventos e consultá-los posteriormente. Conforme as configurações, também pode exibir um alerta pop-up, enviar uma notificação push para o aplicativo móvel MetaTrader configurado e reproduzir um arquivo de áudio. Esse mecanismo multicanal permite que os traders recebam os alertas em tempo hábil por diferentes meios, independentemente das circunstâncias. Para utilizar notificações push, certifique-se de que o MetaQuotes ID esteja configurado no terminal.
void EmitLogAlert(const string msg) { Print(msg); if(EnableAlerts) Alert(msg); if(EnableNotifications) SendNotification(msg); if(EnableSound && StringLen(AlertSoundFile) > 0) PlaySound(AlertSoundFile); }
Funções de desenho
DrawBreak(), CreateTrendLine() e CreateAnchoredLabel() gerenciam os objetos gráficos exibidos no gráfico. DrawBreak() utiliza iBarShift() para calcular os índices das barras correspondentes ao momento de formação do fractal e ao rompimento. Em seguida, estende a extremidade mais antiga da linha conforme o valor de HorizontalLeftExtend e, quando necessário, desloca a extremidade mais recente em direção à barra atual, de acordo com HorizontalRightBars. CreateTrendLine() cria uma linha de tendência ancorada em dois pontos no tempo e aplica as configurações visuais correspondentes. CreateAnchoredLabel() posiciona um rótulo explicativo nas coordenadas de tempo e preço especificadas, com um deslocamento de alguns pontos para melhorar a legibilidade. Cada função de criação utiliza SafeDelete() para remover eventuais objetos existentes com o mesmo nome antes de criar novos elementos, evitando o acúmulo de objetos no gráfico e mantendo a consistência da apresentação visual.
void DrawBreak(const string tag, datetime fract_time, double fract_price, datetime break_time, bool bullish) { int barFr = iBarShift(_Symbol, _Period, fract_time, false); int barBreak = iBarShift(_Symbol, _Period, break_time, false); int bars = iBars(_Symbol, _Period); if(barFr == -1 || barBreak == -1) return; int older_shift = MathMax(barFr, barBreak); int newer_shift = MathMin(barFr, barBreak); // Extend left older_shift = MathMin(older_shift + HorizontalLeftExtend, bars - 1); // Extend right towards current bar if(HorizontalRightBars > 0) newer_shift = MathMax(newer_shift - HorizontalRightBars, 0); // Swap if necessary if(older_shift < newer_shift) { int tmp = older_shift; older_shift = newer_shift; newer_shift = tmp; } datetime tLeft = (datetime)iTime(_Symbol, _Period, older_shift); datetime tRight = (datetime)iTime(_Symbol, _Period, newer_shift); string lineName = tag + "_line"; CreateTrendLine(lineName, tLeft, fract_price, tRight, (bullish ? BullColor : BearColor), false); } void CreateAnchoredLabel(const string name, const string txt, datetime when, double price, color col) { SafeDelete(name); if(ObjectCreate(g_chart_id, name, OBJ_TEXT, 0, when, price)) { ObjectSetString(g_chart_id, name, OBJPROP_TEXT, txt); ObjectSetInteger(g_chart_id, name, OBJPROP_COLOR, (int)col); ObjectSetInteger(g_chart_id, name, OBJPROP_FONTSIZE, 10); ObjectSetInteger(g_chart_id, name, OBJPROP_BACK, false); ObjectMove(g_chart_id, name, 0, when, price); } } void CreateTrendLine(const string name, datetime tLeft, double price, datetime tRight, color col, bool dashed=false) { SafeDelete(name); if(ObjectCreate(g_chart_id, name, OBJ_TREND, 0, tLeft, price, tRight, price)) { ObjectSetInteger(g_chart_id, name, OBJPROP_COLOR, (int)col); ObjectSetInteger(g_chart_id, name, OBJPROP_WIDTH, 2); ObjectSetInteger(g_chart_id, name, OBJPROP_STYLE, dashed ? STYLE_DASH : STYLE_SOLID); ObjectSetInteger(g_chart_id, name, OBJPROP_BACK, false); ObjectSetInteger(g_chart_id, name, OBJPROP_SELECTABLE, false); } } void SafeDelete(const string name) { if(ObjectFind(g_chart_id, name) >= 0) ObjectDelete(g_chart_id, name); }
Funções auxiliares
CrossedOver() e CrossedUnder() encapsulam em funções separadas as condições de cruzamento confirmadas pelo fechamento da barra (prevClose <= level && curClose > level e a condição inversa).
bool CrossedOver(double prevClose, double curClose, double level) { return (prevClose <= level && curClose > level); } bool CrossedUnder(double prevClose, double curClose, double level) { return (prevClose >= level && curClose < level); }
TimeframeToString() converte as constantes dos períodos gráficos em strings legíveis, tornando as mensagens de log mais fáceis de interpretar.
string TimeframeToString(int period) { switch(period) { case PERIOD_M1: return "M1"; case PERIOD_M5: return "M5"; case PERIOD_M15: return "M15"; case PERIOD_M30: return "M30"; case PERIOD_H1: return "H1"; case PERIOD_H4: return "H4"; case PERIOD_D1: return "D1"; case PERIOD_W1: return "W1"; case PERIOD_MN1: return "MN1"; default: return IntegerToString(period); } }
CleanupObjectsByPrefix() remove todos os objetos que compartilham um mesmo prefixo. A função percorre a lista de objetos em ordem inversa para evitar erros decorrentes do deslocamento dos índices durante a exclusão.
void CleanupObjectsByPrefix(const string prefix) { long total = ObjectsTotal(g_chart_id); for(int i=total-1; i>=0; i--) { string name = ObjectName(g_chart_id, i); if(StringLen(name) >= StringLen(prefix) && StringSubstr(name, 0, StringLen(prefix)) == prefix) ObjectDelete(g_chart_id, name); } }
Remoção de fractais antigos (PruneFractals)
PruneFractals() mantém o desempenho e o consumo de memória estáveis, removendo os fractais armazenados que ultrapassam o limite de histórico definido por MaxFractalHistoryBars. A função compacta os arrays no próprio espaço de armazenamento, utilizando um índice de escrita, e depois ajusta seus tamanhos, evitando alocações desnecessárias. Vale lembrar que, durante a remoção, iBarShift() é chamada para cada fractal armazenado. Portanto, um limite de armazenamento excessivamente alto pode aumentar o tempo de processamento. Definir um valor padrão adequado, como 2000 barras, ajuda a equilibrar a profundidade do histórico e a eficiência da execução.
void PruneFractals(int keepBars) { if(keepBars <=0) return; // Prune bullish fractals int nB = ArraySize(bull_time); if(nB > 0) { int write = 0; for(int i=0; i<nB; i++) { int sh = iBarShift(_Symbol, _Period, bull_time[i], false); if(sh != -1 && sh <= keepBars) { bull_time[write] = bull_time[i]; bull_price[write] = bull_price[i]; bull_marked[write] = bull_marked[i]; write++; } } if(write != nB) { ArrayResize(bull_time, write); ArrayResize(bull_price, write); ArrayResize(bull_marked, write); } } // Prune bearish fractals int nS = ArraySize(bear_time); if(nS > 0) { int write = 0; for(int i=0; i<nS; i++) { int sh = iBarShift(_Symbol, _Period, bear_time[i], false); if(sh != -1 && sh <= keepBars) { bear_time[write] = bear_time[i]; bear_price[write] = bear_price[i]; bear_marked[write] = bear_marked[i]; write++; } } if(write != nS) { ArrayResize(bear_time, write); ArrayResize(bear_price, write); ArrayResize(bear_marked, write); } } }
Este EA é um sistema modular de nível profissional que identifica fractais confirmados em barras fechadas, armazena seus dados de forma eficiente, detecta cruzamentos confirmados para gerar sinais BOS/ChOCh, adiciona marcações claras ao gráfico e emite alertas por diferentes canais. Cada módulo foi desenvolvido priorizando clareza, reprodutibilidade e facilidade de manutenção. Tanto em ambientes profissionais quanto educacionais, recomenda-se testar o sistema em um ambiente de demonstração e ativar DebugMode durante as etapas de validação.
Configurações de alertas, logs e notificações
O EA oferece três canais de alerta configuráveis para que você não perca nenhum evento: alertas pop-up no desktop, notificações push para dispositivos móveis e alertas sonoros. Você pode utilizá-los simultaneamente para ampliar as possibilidades de recebimento ou ativá-los individualmente, caso prefira uma operação com menos interrupções.
Configurações:
- EnableAlerts - exibe janelas pop-up no desktop por meio de Alert(). Os alertas são acionados imediatamente e permanecem visíveis enquanto o terminal estiver em execução. É útil para o monitoramento ativo.
- EnableNotifications - envia notificações push para dispositivos móveis por meio de SendNotification(). Para utilizar esse recurso, é necessário configurar seu MetaQuotes ID em Ferramentas → Opções → Notificações e ativar as notificações no aplicativo móvel MetaTrader.
- EnableSound - reproduz um arquivo de áudio local do terminal por meio de PlaySound(filename). O arquivo deve estar localizado na pasta Sounds do terminal, e o som do terminal precisa estar ativado.
Formato recomendado das mensagens de alerta (claro e adequado à análise automatizada dos campos):
Bull BOS detected: EURUSD H1 at 2025.08.01 14:00 price=1.12345 fr_time=2025.08.01 12:00
Inclua o símbolo, o período gráfico, o tipo de evento, o horário de confirmação, o preço e, quando necessário, a marca de tempo do fractal para facilitar a conferência dos dados.
Para ativar as notificações, informe seu MetaQuotes ID nas configurações do terminal e verifique se as notificações estão habilitadas no dispositivo móvel.

Para os alertas sonoros, copie os arquivos WAV ou MP3 para a pasta Sounds do terminal e verifique, em Ferramentas → Opções → Eventos, se a função PlaySound está funcionando corretamente. Para evitar o envio excessivo de alertas, utilize os arrays *_marked[] para impedir notificações duplicadas referentes ao mesmo fractal e, se necessário, estabeleça um intervalo mínimo entre alertas, por exemplo, de 30 a 120 segundos por símbolo, durante períodos de alta volatilidade do mercado. Além disso, para fins de auditoria e diagnóstico durante os testes, é possível registrar os eventos em um arquivo CSV, utilizando FILE_COMMON ou o diretório MQL5/Files do terminal. Nesse caso, feche o arquivo imediatamente após cada gravação para evitar problemas de bloqueio.
Testes e resultados
Nesta seção, apresentarei o desempenho do sistema tanto nos testes com dados históricos quanto em tempo real. Com base nas minhas observações, os resultados atenderam aos objetivos definidos durante o desenvolvimento, e o sistema apresentou o comportamento esperado. Mostrarei a configuração e as métricas dos testes com dados históricos, a curva de capital e exemplos de operações que ilustram o funcionamento do detector na prática. Também analisarei brevemente os resultados obtidos em tempo real, utilizando capturas de tela e comparando-os com os resultados dos testes históricos. Por fim, destacarei as principais limitações e sugerirei os próximos passos para uma validação mais aprofundada.
Realizei testes com dados históricos dos instrumentos EURUSD e Step Index, ambos no período gráfico H1. Os resultados são apresentados a seguir. A animação GIF abaixo mostra claramente os eventos ChOCh e BOS, com marcações precisas que permitem acompanhar facilmente a sequência "alerta antecipado - confirmação".
- Step Index H1 - ponto de pivô fractal (âncora) com anotação, ChOCh (não formação de uma máxima mais alta) e Bull BOS (confirmado no fechamento da barra).

- EURUSD H1 - ponto de pivô fractal (âncora) com anotação, ChOCh (não formação de uma máxima mais alta) e Bull BOS (confirmado no fechamento da barra).

Também realizei testes em tempo real para validar o comportamento do sistema, e a ferramenta funcionou exatamente como esperado. As capturas de tela abaixo mostram como o EA detecta, marca e registra em logs os eventos ChOCh e BOS em tempo real. Os alertas no desktop e os objetos gráficos são exibidos assim que ocorre o fechamento da barra que confirma o evento. Os sinais observados em tempo real coincidiram, quanto à direção, com os obtidos nos testes históricos. Os logs de execução mostraram apenas os efeitos habituais das condições reais de mercado, como spread e slippage.
Teste em tempo real - Volatility 75 (1s) Index M1: alertas antecipados de ChOCh em tempo real e confirmações de Bull BOS.
Esta captura de tela de um teste em tempo real mostra como o sistema utiliza pontos de pivô fractais para identificar antecipadamente sinais de alerta ChOCh e, posteriormente, confirmar mudanças na estrutura do mercado por meio de marcadores BOS que não sofrem repintura. O resultado demonstra visualmente que o detector apresenta o comportamento esperado em tempo real.
Teste em tempo real - Step Index M1: alertas antecipados de ChOCh em tempo real e confirmações de Bull BOS
O EA começa identificando uma fase de baixa por meio de um sinal Bear ChOCh e de sucessivos níveis Bear BOS. Em seguida, emite um sinal Bull ChOCh quando o movimento de baixa perde força e confirma a reversão de alta com vários sinais Bull BOS. Essa sequência demonstra, em tempo real, como o alerta antecipado (ChOCh) é seguido pela confirmação sem repintura (BOS).
A seguir, apresentamos os logs registrados na aba "Experts" do MetaTrader 5.
2025.09.03 10 : 20 :58.856 Fractal Reaction System (Volatility 75 (1s) Index,M1) Alert: Bear BOS detected: Volatility 75 (1s) Index M1 at 2025.09.03 13:44 price=3446.40 2025.09.03 10 : 20 :58.856 Fractal Reaction System (Volatility 75 (1s) Index,M1) Bear BOS detected: Volatility 75 (1s) Index M1 at 2025.09.03 13:44 price=3446.73 2025.09.03 10 : 20 :58.856 Fractal Reaction System (Volatility 75 (1s) Index,M1) Alert: Bear BOS detected: Volatility 75 (1s) Index M1 at 2025.09.03 13:44 price=3446.73 2025.09.03 10 : 20 :58.894 Fractal Reaction System (Step Index,M1) Bear BOS detected: Step Index M1 at 2025.09.03 13:44 price=8233.6 2025.09.03 10 : 20 :58.894 Fractal Reaction System (Step Index,M1) Alert: Bear BOS detected: Step Index M1 at 2025.09.03 13:44 price=8233.6 2025.09.03 10 : 20 :58.896 Fractal Reaction System (Volatility 75 (1s) Index,M1) Alert: Bear BOS detected: Volatility 75 (1s) Index M1 at 2025.09.03 13:44 price=3447.86
Tanto nos testes com dados históricos (EURUSD e Step Index, H1) quanto nos testes em tempo real, o detector de fractais funcionou exatamente como previsto: os pontos de pivô fractais forneceram âncoras estáveis, que não sofrem repintura; os alertas ChOCh indicaram antecipadamente a perda da direção anterior; e as confirmações BOS identificaram de forma confiável as mudanças na estrutura do mercado. Os testes históricos produziram uma sequência de eventos de negociação correspondente às animações GIF com anotações, seguindo o padrão "alerta antecipado - confirmação". As capturas de tela dos testes em tempo real mostram o mesmo padrão, com diferenças atribuíveis apenas aos efeitos esperados das condições reais de mercado, como spread e slippage.
Conclusão
O Fractal Reaction System transforma pontos de pivô fractais simples em sinais confiáveis de estrutura de mercado que não sofrem repintura: o ChOCh (mudança de caráter) funciona como alerta antecipado, enquanto o BOS (rompimento de estrutura) fornece a confirmação. O EA apresentado utiliza um gerenciamento seguro da memória, avalia os sinais exclusivamente com base em barras fechadas para garantir a reprodutibilidade, desenha objetos gráficos persistentes que representam a estrutura do mercado e registra cada evento confirmado em logs, além de emitir os alertas correspondentes. O sistema apresentou um comportamento consistente tanto nos testes com dados históricos quanto em tempo real. Seus principais pontos fortes são a transparência, por meio de eventos verificáveis; a reprodutibilidade, proporcionada pela análise de barras fechadas; e a praticidade, com notificações no desktop, em dispositivos móveis e por áudio, além da facilidade de conferir os eventos nos logs.
Esta ferramenta é um detector de sinais, não um sistema completo de gerenciamento de operações. Os resultados efetivos das negociações dependem de fatores como spread, slippage e qualidade da execução das ordens. Além disso, os alertas ChOCh têm caráter predominantemente informativo e não devem ser interpretados como instruções diretas de negociação. Antes de arriscar seu capital, teste o EA nos instrumentos que pretende negociar e com as configurações da sua corretora. Examine também o arquivo .set de backtesting fornecido e os logs de eventos. Considere ainda a possibilidade de incorporar regras de dimensionamento de posições, filtros de períodos gráficos superiores ou um mecanismo de tempo de espera (timeout), conforme seu perfil de risco.
Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/19365
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.
Olá,
arquivo 'C:\Users\Administrator\AppData\Roaming\MetaQuotes\Terminal\24F345EB9F291441AFE537834F9D8A19\MQL5\Include\stdlib_mq5.mqh' não encontrado Fractal_Reaction_System.mq5
Onde posso obter o arquivo?
Chris
Olá,
Arquivo 'C:\Users\Administrator\AppData\Roaming\MetaQuotes\Terminal\24F345EB9F291441AFE537834F9D8A19\MQL5\Include\stdlib_mq5.mqh' não foi encontrado Fractal_Reaction_System.mq5
Onde posso obter o arquivo?
Chris
Parece um padrão de IA. Talvez seja usado para limpar o código. Os agentes de IA às vezes inserem sintaxe incompatível de C/C++ neste ponto. O código compila se você excluir a linha.
Para ficar claro, a diretiva `include` real no código é:
#include <stdlib.mqh>Observe que não há espaço com sublinhado.