Desenvolvimento de ferramentas para análise de Price Action (Parte 29): EA "Boom and Crash Interceptor"

Sumário

• Introdução
• Conhecendo a estratégia
• Análise do código
• Testes com dados históricos e resultados
• Conclusão

Introdução

Nos modernos sistemas de defesa antiaérea, uma rede de sensores distribuídos em múltiplas camadas analisa cada eco de radar e cada rastro infravermelho com extrema precisão. Cada objeto detectado é avaliado de acordo com sua velocidade, trajetória e assinatura, e seus dados são comparados com um amplo banco de dados de ameaças. Somente quando vários filtros independentes chegam à mesma conclusão o sistema autoriza o lançamento de um interceptador, preservando recursos e garantindo que as ameaças reais sejam neutralizadas sem demora.

O EA Boom & Crash Interceptor aplica uma abordagem igualmente rigorosa à análise dos dados de mercado. Uma janela móvel de cálculo da velocidade determina se o impulso atual do preço supera os movimentos recentes do mercado; um multiplicador de detecção de picos baseado no ATR confirma se houve um aumento significativo da volatilidade; e filtros de tendência baseados em médias móveis confirmam a direção do movimento. Filtros adicionais de zonas de pivô e horários das sessões reduzem ainda mais a ocorrência de sinais que poderiam surgir em períodos de baixa liquidez.

Quando todas as camadas de análise confirmam um sinal, o EA desenha no gráfico uma seta "BOOM" ou "CRASH", com cores e deslocamentos configuráveis pelo usuário, além de registrar o evento em um arquivo de log CSV. Dessa forma, a atenção fica concentrada nas oportunidades com maior probabilidade de sucesso. A seguir, veremos como calibrar cada camada de detecção e utilizar essa ferramenta em MQL5 como um componente confiável de geração de sinais, integrado a um sistema de negociação mais abrangente.

Conhecendo a estratégia

Inspirado nos sistemas de defesa antimísseis, o EA Boom & Crash Interceptor trata os movimentos bruscos do mercado como ameaças que se aproximam. Em sentido amplo, o termo inglês "missile" designa qualquer projétil lançado para atingir um alvo, seja guiado ou não. As versões modernas incluem mísseis autopropulsados, equipados com ogivas e sistemas de orientação inercial, por radar, por satélite ou óptica. Essa categoria abrange desde mísseis balísticos intercontinentais (MBIs) até mísseis de cruzeiro e interceptadores antiaéreos. Historicamente, até mesmo uma lança arremessada ou uma flecha disparada se enquadram nessa definição, pois são lançadas deliberadamente na direção de um alvo.

No trading, um movimento brusco do preço pode ser igualmente perigoso: ocorre rapidamente, muitas vezes de forma inesperada, e pode causar prejuízos consideráveis a uma conta sem proteção adequada. É nesse ponto que a analogia com um sistema de interceptação de mísseis se torna especialmente útil. Um sistema desse tipo é um complexo defensivo projetado para detectar, rastrear e neutralizar uma ogiva antes que ela atinja seu alvo. Seu funcionamento se baseia em quatro etapas interligadas:

Detecção e rastreamento

• Sensores terrestres, navais ou espaciais detectam o lançamento de um projétil inimigo.
• O sistema de controle de tiro calcula sua trajetória, velocidade e provável ponto de impacto.

Lançamento e orientação

• Após a confirmação da ameaça, o interceptador é lançado de um silo, de uma plataforma móvel, de um navio ou de uma aeronave.
• As correções de trajetória são realizadas por meio de orientação inercial, transmissão de dados durante a fase intermediária do voo e autoguiamento terminal por radar ou infravermelho.

Métodos de interceptação e neutralização

• Interceptação cinética: o interceptador colide diretamente com a ogiva a uma velocidade relativa de aproximação superior a Mach 10, utilizando a energia cinética do impacto para destruí-la.
• Detonação por proximidade: uma explosão controlada nas proximidades do alvo provoca sua destruição ou desvia sua trajetória por meio de fragmentos ou de uma onda de choque direcionada.

Defesa em camadas

• Sistemas de curto alcance, como o Patriot PAC-3, interceptam ameaças na fase terminal de sua trajetória.
• Sistemas de interceptação na fase intermediária, como o SM-3 e o Ground-based Midcourse Defense, atuam no espaço.
• Os interceptadores destinados à fase de aceleração ainda estão em estágio experimental. Seu objetivo é atingir os mísseis logo após o lançamento.

Essas camadas permitem maximizar a proteção e minimizar os lançamentos indevidos, mantendo um equilíbrio baseado na rápida fusão de dados e em critérios rigorosos de confirmação.

O EA Boom & Crash Interceptor reproduz essa mesma arquitetura. O monitoramento contínuo do mercado desempenha o papel da rede de radares; os limiares de velocidade, os filtros de picos de ATR e o alinhamento com a média móvel funcionam como camadas independentes de confirmação; os filtros adicionais de zonas de pivô e horários das sessões simulam a identificação e a filtragem de falsos alvos. Somente quando todos os critérios são atendidos o EA "efetua o lançamento", desenhando uma seta BOOM ou CRASH no gráfico e registrando o evento no log. Dessa forma, ajuda o trader a preservar a atenção do trader e o capital de negociação para situações que realmente exigem uma reação, assim como uma bateria de defesa antimísseis reserva seus interceptadores para ogivas que representam ameaças reais.

Figura 1. Estratégia

Radar de velocidade

Mede a variação do preço ao longo de VelocityHistoryBars e a compara com um limiar definido por um percentil histórico. Apenas movimentos considerados "excepcionalmente grandes" passam por esse filtro.

// Record current vs. old price
double priceNow = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
double priceOld = velHistory[VelocityHistoryBars - 1];
double delta    = priceNow - priceOld;

// Build and sort past deltas
double d[];
ArrayResize(d, VelocityHistoryBars - 1);
for(int i = 1; i < VelocityHistoryBars; i++)
    d[i - 1] = velHistory[0] - velHistory[i];
ArraySort(d);

// Pick the (100–VelocityPctile)% threshold
int idx      = (int)MathRound((VelocityPctile / 100.0) * (ArraySize(d) - 1));
double velTh = d[ArraySize(d) - 1 - idx];

// Pass if current move exceeds threshold
bool okVel = (delta > velTh || delta < -velTh);

Detector de picos de ATR

Verifica se houve um aumento brusco da volatilidade, comparando o valor mais recente do ATR com o ATR da barra anterior multiplicado por ATRMultiplier.

// Fetch two most recent ATR values
double atrArr[2];
CopyBuffer(atrHandle, 0, 0, 2, atrArr);

// Pass if ATR_now > ATR_prev × ATRMultiplier
bool okATR = (atrArr[0] > atrArr[1] * ATRMultiplier);

Verificação de alinhamento com a tendência

Verifica se o movimento do preço acompanha a tendência: quando o preço sobe, a média móvel simples (SMA) também deve estar subindo; quando o preço cai, a SMA deve estar caindo.

// Fetch two most recent SMA values
double maArr[2];
CopyBuffer(maHandle, 0, 0, 2, maArr);

// If delta>0 require SMA_now>SMA_prev; if delta<0 require SMA_now<SMA_prev
bool okTrend = (delta > 0 
                ? maArr[0] > maArr[1] 
                : maArr[0] < maArr[1]);

Filtro de zonas de pivô (opcional)

Bloqueia sinais gerados muito perto do pivô da barra anterior, utilizando um buffer definido por ZoneBufferPoints.

// Compute prior bar’s pivot
double h1    = iHigh(_Symbol, MainTF, 1),
       l1    = iLow (_Symbol, MainTF, 1),
       c1    = iClose(_Symbol, MainTF, 1);
double pivot = (h1 + l1 + c1) / 3.0;

// Pass if priceNow is beyond pivot ± buffer
bool okZone = (delta > 0
               ? priceNow < pivot - ZoneBufferPoints * _Point
               : priceNow > pivot + ZoneBufferPoints * _Point);

Lógica final de "lançamento do míssil"

A seta Boom (para cima) ou Crash (para baixo) só aparece quando o sinal passa por todos os filtros.

// Determine direction
bool isBoom  = (delta  >  velTh);
bool isCrash = (delta  < -velTh);

// Fire only if velocity, ATR, trend, and zone all passed
bool fire    = ((isBoom || isCrash) && okVel && okATR && okTrend && okZone);

if(fire)
    GenerateSignal(isBoom, priceNow, delta, atrArr[0], MainTF);

Análise do código

A seguir, analisaremos, na ordem, as principais seções do EA "Boom & Crash Interceptor".

Cabeçalho e diretivas de compilação

O bloco inicial de comentários e as diretivas #property que vêm em seguida funcionam como o cartão de visitas do EA. Neles são definidos os dados de direitos autorais, o link de suporte, a versão atual e a opção de compilação estrita. Nesse modo, o MetaTrader 5 aplica verificações mais rigorosas de tipos e limites de valores, ajudando a identificar erros difíceis de detectar ainda nas primeiras etapas da compilação. Essas informações também permitem que o MetaQuotes Market acompanhe o histórico do produto e ofereça aos usuários finais atualizações mais suaves entre versões.

//+------------------------------------------------------------------+
//|                                     Boom and Crash Interceptor EA|
//|                                   Copyright 2025, MetaQuotes Ltd.|
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com/ru/users/lynnchris"
#property version   "1.0"
#property strict

Inclusão da biblioteca e objeto de negociação

Ao incluir <Trade\Trade.mqh> e criar um objeto global CTrade, o código passa a contar com um wrapper orientado a objetos para a API de negociação do MetaTrader. Embora a versão atual ainda se limite a emitir alertas e exibir elementos gráficos, esse objeto deixa a base de código preparada para incorporar a execução real de ordens quando necessário.

#include <Trade\Trade.mqh>
CTrade trade;            // object-oriented trading wrapper

Parâmetros de entrada: painel de controle do EA

Todos os parâmetros operacionais são declarados com a palavra-chave input, o que permite otimizá-los no Testador de Estratégias ou ajustá-los rapidamente na aba "Inputs" da janela do gráfico. Eles estão divididos em quatro grupos principais:

• Configurações de geração de sinais: timeframes, extensão do histórico usado na análise de velocidade, parâmetros do ATR e da média móvel.

• Filtros opcionais: lógica das zonas de pivô e horários das sessões.

• Configurações de exibição: posição do painel, cores, espessura das linhas e deslocamento das setas.

• Registro de dados: nome do arquivo CSV.

input ENUM_TIMEFRAMES MainTF            = PERIOD_CURRENT; // Signal TF
input int            VelocityHistoryBars = 96;
input double         VelocityPctile      = 120.0;          // >100 ⇒ extreme
input int            ATRPeriod           = 14;
input double         ATRMultiplier       = 1.5;
input bool           UseZoneFilter       = true;
input int            SessionStartHour    = 7;
input int            SessionEndHour      = 17;
input string         LogFilename         = "BoCrashLog.csv";

Um detalhe interessante é que o valor padrão de VelocityPctile é 120%. Como o algoritmo de percentis fica limitado ao extremo superior da distribuição, um valor acima de 100% exige, na prática, que o movimento atual do preço supere o maior movimento registrado na janela de análise. Isso torna o critério de geração de sinais deliberadamente mais seletivo.

Variáveis globais e convenções de nomenclatura

O array velHistory[] armazena os dados da janela móvel utilizados na análise de velocidade, enquanto um conjunto de constantes de string centraliza os nomes dos objetos da interface gráfica. Manter esses nomes em arrays (dashNames, hVelUp etc.) garante a criação e a remoção determinísticas dos objetos, evita a permanência de elementos órfãos no gráfico e facilita futuras refatorações.

double  velHistory[];
string  dashBG      = "DashBG";
string  dashNames[] = {"Delta","VelThr","ATR","ATRm","Trend",
                       "Pivot","Zone","Signal"};
string  hVelUp      = "VelUp";
string  hVelDown    = "VelDown";

OnInit(): obtenção dos recursos e criação da interface

Durante a inicialização, redimensionamos o array de velocidade, obtemos os handles dos indicadores ATR e média móvel e retornamos INIT_FAILED caso algum deles não esteja disponível. É preferível interromper a inicialização nesse ponto a enfrentar problemas de estabilidade durante a execução. Em seguida, o EA abre ou cria o arquivo de log CSV, grava o cabeçalho caso o arquivo seja novo e posiciona o ponteiro do arquivo no final para acrescentar os próximos registros. Por fim, a rotina cria um retângulo semitransparente para o painel, adiciona os rótulos de texto e desenha antecipadamente as linhas de referência horizontais e verticais. Assim, todos os elementos gráficos já estão presentes antes mesmo da chegada do primeiro tick do mercado.

int OnInit()
  {
   ArrayResize(velHistory,VelocityHistoryBars);

   atrHandle = iATR(_Symbol, ATRTF, ATRPeriod);
   maHandle  = iMA (_Symbol, TrendTF, TrendMAPeriod, 0, MODE_SMA, PRICE_CLOSE);
   if(atrHandle==INVALID_HANDLE || maHandle==INVALID_HANDLE)
      return INIT_FAILED;

   logHandle = FileOpen(LogFilename, FILE_READ|FILE_WRITE|FILE_CSV|FILE_ANSI);
   if(logHandle>=0 && FileSize(logHandle)==0)
         FileWrite(logHandle,"DateTime,Type,Velocity,ATR,Price");

   // dashboard background
   ObjectCreate(0,dashBG,OBJ_RECTANGLE_LABEL,0,0,0);
   ObjectSetInteger(0,dashBG,OBJPROP_XSIZE,200);
   ObjectSetInteger(0,dashBG,OBJPROP_YSIZE,140);

   // dashboard labels
   for(int i=0;i<ArraySize(dashNames);i++)
     {
      string name="Dash_"+dashNames[i];
      ObjectCreate(0,name,OBJ_LABEL,0,0,0);
      ObjectSetString(0,name,OBJPROP_TEXT,dashNames[i]+": ?");
     }

   // reference lines
   ObjectCreate(0,hVelUp ,OBJ_HLINE,0,0,0);
   ObjectCreate(0,hVelDown,OBJ_HLINE,0,0,0);
   return INIT_SUCCEEDED;
  }

OnDeinit(): encerramento adequado

Quando o EA é removido, a função libera os handles dos indicadores, fecha o handle do arquivo e exclui todos os objetos gráficos listados nos arrays de nomes. Essa correspondência entre a criação e a remoção dos recursos é fundamental para manter a lista de objetos do terminal sem elementos desnecessários e reduzir o consumo de recursos do sistema operacional.

void OnDeinit(const int reason)
  {
   if(atrHandle!=INVALID_HANDLE) IndicatorRelease(atrHandle);
   if(maHandle !=INVALID_HANDLE) IndicatorRelease(maHandle);
   if(logHandle>=0)              FileClose(logHandle);

   string objs[]={dashBG,hVelUp,hVelDown};
   for(int i=0;i<ArraySize(objs);i++) ObjectDelete(0,objs[i]);
   for(int i=0;i<ArraySize(dashNames);i++)
      ObjectDelete(0,"Dash_"+dashNames[i]);
  }

OnTick(): mecanismo de tomada de decisões em tempo real

Primeiro, a função verifica se uma nova barra foi concluída no timeframe MainTF. Caso contrário, encerra imediatamente a execução, evitando cálculos desnecessários. Quando detecta a transição para uma nova barra, o código aplica o filtro opcional de sessão, restringindo o funcionamento ao intervalo de horários definido pelo trader.

void OnTick()
  {
   // process only on completed bar
   int cur=iBars(_Symbol,MainTF)-1;
   if(cur==lastBar) return;
   lastBar=cur;

   // optional session filter
   MqlDateTime now; TimeToStruct(TimeCurrent(),now);
   if(UseSessionFilter && (now.hour<SessionStartHour || now.hour>SessionEndHour))
      return;

   // velocity calculation
   double priceNow = SymbolInfoDouble(_Symbol,SYMBOL_ASK);
   ArrayMove(velHistory,1,0,VelocityHistoryBars-1); // shift right
   velHistory[0]=priceNow;
   double delta  = priceNow-velHistory[VelocityHistoryBars-1];
   double velTh  = ComputeVelocityPercentile(velHistory,VelocityPctile);
   bool   okVel  = (delta>velTh || delta<-velTh);

   // ATR, MA, pivot-zone checks ...
   /* …remaining signal logic… */

   if(fire) GenerateSignal(isBoom,priceNow,delta,atrArr[0],MainTF);
  }

Em seguida, o preço Ask mais recente é inserido no início de velHistory, deslocando os valores anteriores uma posição no array. Calculamos então delta, a diferença entre o preço mais recente e o mais antigo da janela, e obtemos o limiar do percentil por meio de ComputeVelocityPercentile(). O critério de velocidade é atendido quando delta ultrapassa o limiar superior ou fica abaixo do limiar inferior.

Os filtros de ATR e média móvel podem ser avaliados em outros timeframes, inclusive menores, para detectar aumentos de volatilidade de curto prazo e confirmar a direção do movimento. Quando ativado, o filtro de zonas de pivô calcula o pivô clássico a partir dos valores H, L e C da barra anterior e permite apenas sinais em que o preço ainda esteja do lado "errado" desse nível, considerando um buffer configurável. Dessa forma, o filtro seleciona situações com potencial de reversão à média.

O painel é atualizado com os valores de diagnóstico atuais, e as cores mostram imediatamente se cada critério foi atendido. Ao mesmo tempo, as linhas horizontais de velocidade e pivô, bem como a linha vertical de referência temporal, são reposicionadas para manter os elementos visuais do gráfico sincronizados com a nova barra. Um sinal só é considerado válido quando as quatro condições, pico de velocidade, pico de ATR, alinhamento com a tendência e aprovação no filtro de zonas, retornam true.

Função auxiliar UpdateLabel()

Essa pequena função centraliza a atualização dos textos e das cores do painel. Ao concentrar a formatação em um único lugar, mantemos a consistência visual e facilitamos alterações de estilo em toda a interface.

void UpdateLabel(int idx,string txt,bool pass)
  {
   string name="Dash_"+dashNames[idx];
   ObjectSetString (0,name,OBJPROP_TEXT ,txt);
   ObjectSetInteger(0,name,OBJPROP_COLOR, pass ? clrLime : clrRed);
  }

Função auxiliar ComputeVelocityPercentile()

O algoritmo transforma a série de preços armazenada em uma lista de diferenças delta com sinal, ordena esses valores e seleciona o índice correspondente ao percentil definido pelo usuário. A escolha de um dos extremos do array ordenado permite que o método considere a direção do movimento (boom ou crash) sem precisar de lógica adicional. Valores de percentil superiores a 100% são limitados ao maior elemento, estabelecendo um limiar equivalente ao "extremo absoluto dentro da janela de análise".

double ComputeVelocityPercentile(double &hist[],double pct)
  {
   int n=ArraySize(hist);
   if(n<2) return 0;
   double d[]; ArrayResize(d,n-1);
   for(int i=1;i<n;i++) d[i-1]=hist[0]-hist[i];
   ArraySort(d);                        // ascending
   int idx=(int)MathRound((pct/100.0)*(ArraySize(d)-1));
   return d[ArraySize(d)-1-idx];        // mirror to get extreme with sign
  }

Função auxiliar SetHLine()

Ao modificar as propriedades dos objetos existentes em vez de recriar as linhas, esse método evita oscilações visuais e atrasos na atualização do gráfico, mantendo a interface fluida mesmo em computadores com menor capacidade de processamento.

void SetHLine(string name,double price,color clr)
  {
   ObjectSetDouble (0,name,OBJPROP_PRICE, price);
   ObjectSetInteger(0,name,OBJPROP_COLOR, clr);
   ObjectSetInteger(0,name,OBJPROP_WIDTH, 1);
  }

Função auxiliar GenerateSignal()

Quando todos os filtros confirmam o sinal, essa função desenha uma seta colorida Wingdings, posicionada com um deslocamento em relação à mínima da barra (boom) ou à máxima da barra (crash), registra os detalhes do evento no arquivo de log CSV (marca de tempo, tipo de sinal, delta, ATR e preço) e emite um alerta sonoro. Como o objeto CTrade já está disponível no escopo, será possível transformar esses sinais visuais em ordens reais simplesmente adicionando uma chamada a trade.Buy() ou trade.Sell() nesse ponto do código.

void GenerateSignal(bool isBoom,double price,double delta,
                    double atr,ENUM_TIMEFRAMES tf)
  {
   int    code = isBoom ? 233 : 234;
   double y    = isBoom ? iLow(_Symbol,tf,0)-ArrowOffsetPips*_Point
                        : iHigh(_Symbol,tf,0)+ArrowOffsetPips*_Point;
   color  clr  = isBoom ? BoomArrowColor : CrashArrowColor;
   string tag  = (isBoom?"BOOM":"CRASH")+"_"+
                 TimeToString(TimeCurrent(),TIME_SECONDS);

   datetime t0 = iTime(_Symbol,tf,0);
   ObjectCreate(0,tag,OBJ_ARROW,0,t0,y);
   ObjectSetInteger(0,tag,OBJPROP_ARROWCODE,code);
   ObjectSetInteger(0,tag,OBJPROP_COLOR,clr);

   if(logHandle>=0)
      FileWrite(logHandle,TimeToString(TimeCurrent(),TIME_DATE|TIME_SECONDS),
                isBoom?"BOOM":"CRASH",DoubleToString(delta,2),
                DoubleToString(atr,_Digits),DoubleToString(price,_Digits));

   Alert((isBoom?"BOOM":"CRASH")+" signal @"+
         DoubleToString(price,_Digits));
  }

Lógica da estratégia e possibilidades de expansão

// Inside GenerateSignal(), after drawing the arrow:
double lot   = 0.02;                        // example risk sizing
double sl    = isBoom ? price - atr*2 : price + atr*2;
double tp    = pivot;                       // mean-reversion target

if(AutoTrade)                               // user-controlled switch
  {
   if(isBoom) trade.Buy(lot,_Symbol,price,sl,tp,"Boom-auto");
   else       trade.Sell(lot,_Symbol,price,sl,tp,"Crash-auto");
  }

Em essência, o EA procura acelerações bruscas do preço concentradas em uma única barra, acompanhadas por um aumento recente da volatilidade, mas que ainda apresentem potencial de retorno ao pivô anterior. Esse comportamento é característico dos índices Boom/Crash, nos quais movimentos repentinos de grande amplitude costumam ser seguidos por recuos rápidos. Atualmente, o código gera apenas alertas informativos. Para incorporar a execução automática de ordens, será necessário adicionar o cálculo do tamanho da posição, um stop-loss (por exemplo, baseado na linha de velocidade oposta) e uma lógica de take-profit (por exemplo, no nível do pivô ou na metade do buffer). Por fim, o deslocamento sequencial dos elementos do array velHistory é adequado para a janela padrão de 96 barras, mas, caso seja necessário trabalhar com um histórico muito maior, essa abordagem poderá ser substituída por um buffer circular.

Testes com dados históricos e resultados

Antes de colocar nosso interceptador em operação real, vamos realizar uma série de testes em uma conta demo para ajustar seus parâmetros com maior precisão:

1. Compile e carregue o EA

Depois de compilar o EA com sucesso no MetaEditor, volte ao MetaTrader.

2. Abra o Testador de Estratégias

Na barra de ferramentas do MetaTrader, clique no ícone "Testador de Estratégias". Selecione o EA Boom & Crash Interceptor na lista de Expert Advisors.

3. Configure o teste

• Ativo e timeframe: selecione o mesmo instrumento e o mesmo MainTF que pretende utilizar nas operações reais.
• Período: escolha um intervalo histórico que inclua diferentes condições de mercado (períodos de baixa volatilidade, movimentos de tendência e alta volatilidade).
• Parâmetros de entrada: ajuste VelocityHistoryBars, VelocityPctile, ATRMultiplier, TrendMAPeriod, ZoneBufferPoints e outros parâmetros para observar como cada um influencia a frequência e a precisão dos sinais.
• Modo de execução: utilize o modo "Every Tick" para obter resultados com a maior precisão possível.

4. Execute o teste e avalie os resultados

Clique em "Iniciar". Após a conclusão do teste, analise a curva de capital, a lista de sinais e os casos em que a interceptação falhou ou ocorreu com atraso. Observe os pontos em que houve uma concentração excessiva de sinais e identifique os movimentos bruscos que passaram despercebidos.

5. Ajuste os parâmetros e repita o teste

Altere apenas um ou dois parâmetros por vez. Por exemplo, torne o limiar do percentil de velocidade mais restritivo ou aumente o buffer do pivô e execute novamente o teste. Repita esse procedimento até que os resultados obtidos na conta demo apresentem sinais Boom/Crash claros e consistentes, com um nível de drawdown aceitável.

Depois de confirmar a eficácia do EA em várias execuções de teste na conta demo, você poderá colocá-lo em operação real, mantendo o risco sob controle.

A seguir, apresento os resultados dos testes do EA Boom & Crash Interceptor com dados históricos, que considero especialmente esclarecedores.

Figura 2. Testes com dados históricos do Boom 900

No teste com o Boom 900, nosso EA registrou no log todos os sinais Boom e Crash, conforme esperado. A linha de pivô aparece em azul, enquanto o limiar de velocidade é exibido em laranja, facilitando a identificação visual desses níveis. Você também verá setas verdes apontando para cima, que marcam cada sinal BOOM, e setas vermelhas apontando para baixo, que identificam cada sinal CRASH. Abaixo, apresento também uma imagem estática para ilustrar com mais clareza o que foi mostrado no GIF.

Figura 3. Resultados dos testes com dados históricos

Conclusão

Desenvolvemos o EA Boom & Crash Interceptor e realizamos testes detalhados com dados históricos, obtendo resultados que falam por si. O EA identifica com precisão movimentos extremos dos preços ao monitorar a velocidade, os picos de ATR, o alinhamento com a tendência e os rompimentos das zonas de pivô. Com base nesses critérios, exibe apenas os sinais mais claros, representados por setas Boom (verdes) e Crash (vermelhas). Em nosso teste com o Boom 900 na conta demo, todos os sinais foram registrados, as linhas de pivô e velocidade apareceram em azul e laranja, respectivamente, e a imagem estática reproduziu exatamente o que foi mostrado no GIF.

Ainda assim, alguns sinais podem se beneficiar de filtros adicionais. Considere esse EA um radar tático, e não um sistema autônomo de execução de ordens. Antes de abrir uma operação, complemente seus sinais com suas próprias análises dos horários de negociação, padrões gráficos e fatores fundamentais. Se quiser reduzir ainda mais a ocorrência de sinais falsos, utilize timeframes maiores (H1, H4 ou Daily) para suavizar o ruído do mercado.

Com testes disciplinados, filtros bem ajustados e uma implementação gradual em conta real, o EA Boom & Crash Interceptor se torna uma ferramenta eficaz para interceptar movimentos bruscos dos preços, permitindo antecipar oportunidades em vez de reagir precipitadamente a cada oscilação do mercado.

Chart Projector	Analytical Comment	Analytics Master	Analytics Forecaster	Volatility Navigator	Mean Reversion Signal Reaper
Signal Pulse	Metrics Board	External Flow	VWAP	Heikin Ashi	FibVWAP
RSI DIVERGENCE	Parabolic Stop and Reverse (PSAR)	Script Quarters Drawer	Intrusion Detector	TrendLoom Tool	Quarters Board
ZigZag Analyzer	Correlation Pathfinder	Market Structure Flip Detector Tool	Correlation Dashboard	Currency Strength Meter	PAQ Analysis Tool
Dual EMA Fractal Breaker	Pin bar, Engulfing and RSI divergence	Liquidity Sweep	Opening Range Breakout Tool	Boom and Crash Interceptor