English Русский 中文 Español Deutsch 日本語
preview
Como aumentar a eficiência das operações com Smart Money Concepts (SMC): OB, BOS e FVG

Como aumentar a eficiência das operações com Smart Money Concepts (SMC): OB, BOS e FVG

MetaTrader 5 — Exemplos |
37 12
Hlomohang John Borotho
Hlomohang John Borotho

Introdução

Às vezes, os traders enfrentam dificuldades para manter a consistência de suas estratégias, alternando frequentemente entre indicadores, cenários de negociação e métodos sem uma estrutura sólida que oriente suas decisões. Essa falta de direcionamento pode gerar confusão, oportunidades perdidas e frustração crescente, especialmente quando as ferramentas tradicionais perdem eficácia diante das mudanças nas condições do mercado. Neste artigo, vamos explorar as vantagens de um EA que reúne diversas estratégias baseadas em Smart Money Concepts (SMC) em uma única solução.

Os Smart Money Concepts (SMC) oferecem uma abordagem estruturada para analisar o comportamento do mercado por meio de três elementos fundamentais: blocos de ordens (Order Blocks, OB), rompimentos de estrutura (Break of Structure, BOS) e gaps de valor justo (Fair Value Gaps, FVG). Os termos em inglês são apresentados na primeira ocorrência por serem amplamente utilizados pela comunidade SMC. Nas explicações seguintes, utilizaremos seus equivalentes em português. Ao integrar esses elementos em um único EA, os traders podem simplificar suas operações, automatizar a tomada de decisões e concentrar-se nos sinais mais fortes da ação do preço. Seja utilizando o modo automático para executar a estratégia continuamente, seja selecionando conceitos específicos, essa abordagem reduz a necessidade de decisões baseadas em suposições e proporciona operações mais eficientes, consistentes e adaptáveis às mudanças nas condições do mercado.



Lógica de funcionamento do EA

Bloco de ordens (Order Block):

Um bloco de ordens (OB) corresponde à última vela de alta ou de baixa antes de um movimento significativo do mercado e costuma indicar uma região em que participantes institucionais posicionaram suas ordens. Quando o preço retorna a essas zonas, elas tendem a funcionar como áreas de forte suporte ou resistência, criando cenários de negociação com maior probabilidade de sucesso. Neste EA, a identificação dos blocos de ordens também é confirmada por níveis de Fibonacci, permitindo alinhar as operações aos principais níveis de retração ou extensão. Conforme discutido no artigo anterior, combinar os blocos de ordens com a confirmação de Fibonacci ajuda a filtrar cenários menos promissores e oferece uma base mais confiável para a entrada e a gestão das operações.

Gap de valor justo (Fair Value Gap):

Um gap de valor justo (Fair Value Gap, FVG) surge quando ocorre um desequilíbrio no movimento dos preços, geralmente provocado por um forte impulso, no qual uma ou mais velas deixam um espaço entre as sombras das velas anteriores e posteriores. Esse gap representa uma ineficiência do mercado, em que nem todas as ordens encontraram contrapartida, e o preço frequentemente retorna à região para "preencher" esse espaço antes de continuar seu movimento na direção esperada. Ao identificar os FVGs e utilizá-los como referência para suas operações, os traders podem antecipar possíveis retrações até essas zonas e encontrar pontos de entrada mais precisos, com risco e potencial de lucro claramente definidos.

Rompimento de estrutura (Break of Structure):

O rompimento de estrutura (BOS) ocorre quando o preço rompe uma máxima ou mínima local anterior, sinalizando uma mudança na estrutura do mercado ou confirmando o impulso predominante, dependendo do contexto da estratégia. No artigo anterior, nosso foco estava nas operações de venda após o rompimento de uma máxima local, aproveitando o impulso de baixa. Nesta abordagem, porém, a lógica do BOS foi ajustada para acompanhar a tendência predominante do mercado: quando ocorre o rompimento de uma máxima local, passamos a buscar oportunidades de compra, confirmando a força compradora; já o rompimento de uma mínima local sinaliza possíveis oportunidades de venda. Essa mudança garante que as operações acompanhem o fluxo predominante do mercado, em vez de contrariá-lo.

Arquitetura do sistema:



Primeiros passos

//+------------------------------------------------------------------+
//|                                                 SMC_ALL_IN_1.mq5 |
//|                        GIT under Copyright 2025, MetaQuotes Ltd. |
//|                     https://www.mql5.com/en/users/johnhlomohang/ |
//+------------------------------------------------------------------+
#property copyright "GIT under Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com/en/users/johnhlomohang/"
#property version   "1.01"
#property description "Unified SMC: FVG + ордер-блоки + BOS. Detect + Draw + Trade."

#include <Trade/Trade.mqh>
#include <Trade/PositionInfo.mqh>

CTrade         trade;
CPositionInfo  pos;

enum ENUM_STRATEGY
{
   STRAT_OB,         // Использовать только ордер-блоки
   STRAT_FVG,        // Использовать только FVG
   STRAT_BOS,        // Использовать только пробой структуры
   STRAT_AUTO        // Авто (все концепции SMC)
};
enum SWING_TYPE{
   SWING_OB,
   SWING_BOS,
};

O código inclui os arquivos da biblioteca padrão de negociação do MetaTrader que disponibilizam as classes CTrade e CPositionInfo, que permitem ao EA abrir e gerenciar operações, além de consultar informações sobre as posições abertas. Ao inicializar essas classes logo no início, o EA passa a contar com os recursos fundamentais para executar ordens e monitorar posições.

A seção seguinte define as opções de estratégia e a classificação dos extremos locais por meio de enumerações. A enumeração ENUM_STRATEGY permite que os traders escolham qual método o EA deve utilizar: apenas blocos de ordens, apenas FVG, apenas BOS ou o modo totalmente automático (STRAT_AUTO), que utiliza dinamicamente os três conceitos. Da mesma forma, a enumeração SWING_TYPE distingue os pontos de máximas e mínimas locais utilizados na identificação dos blocos de ordens daqueles empregados na análise dos rompimentos de estrutura. Essa estrutura torna o código modular e adaptável, permitindo que os traders experimentem diferentes abordagens de SMC ou deixem que o EA selecione automaticamente a lógica de negociação de acordo com as condições do mercado.

//----------------------------- Входные параметры ------------------------------//
input ENUM_STRATEGY TradeStrategy   = STRAT_AUTO;
input double        In_Lot          = 0.02;
input double        StopLoss        = 3500;   // пункты
input double        TakeProfit      = 7500;   // пункты
input long          MagicNumber     = 76543;

input int           SwingPeriod     = 5;      // бары с каждой стороны для подтверждения локального экстремума
input int           SwingProbeBar   = 5;      // индекс бара, который проверяем на локальный экстремум (>=SwingPeriod)
input double        Fib_Trade_lvls  = 61.8;   // коррекция OB должна достичь этого %
input bool          DrawBOSLines    = true;

input int           FVG_MinPoints   = 3;      // минимальный разрыв в пунктах
input int           FVG_ScanBars    = 20;     // сколько баров сканировать для поиска FVG
input bool          FVG_TradeAtEQ   = true;   // торговать на 50% разрыва (EQ)
input bool          OneTradePerBar  = true;

//---------------------------- Цвета -------------------------------//
#define BullOB   clrLime
#define BearOB   clrRed
#define BullFVG  clrPaleGreen
#define BearFVG  clrMistyRose
#define BOSBull  clrDodgerBlue
#define BOSBear  clrTomato

Esta seção do código define os parâmetros de entrada que os traders podem ajustar conforme seu estilo de negociação e suas preferências de gestão de risco. O parâmetro TradeStrategy permite escolher se o EA deve operar exclusivamente com blocos de ordens, FVG ou BOS, ou combinar automaticamente as três abordagens. Os parâmetros de gestão de risco e capital são configurados por meio de In_Lot, StopLoss, TakeProfit e MagicNumber, permitindo definir o tamanho adequado do lote, os níveis de stop-loss para limitar perdas, as metas de lucro e um identificador que permite distinguir as operações do EA. Além disso, os parâmetros de identificação de extremos locais, como SwingPeriod e SwingProbeBar, determinam a quantidade de barras consideradas na identificação das máximas e mínimas locais, enquanto Fib_Trade_lvls garante que as operações baseadas em blocos de ordens estejam alinhadas à confirmação pelos níveis de retração de Fibonacci. A opção DrawBOSLines oferece maior flexibilidade na apresentação do gráfico, permitindo que os traders visualizem diretamente os níveis de rompimento de estrutura.

Em seguida, são definidos os parâmetros dos gaps de valor justo (FVG), que permitem controlar com maior precisão como esses gaps são identificados e utilizados nas operações. O parâmetro FVG_MinPoints garante que apenas desequilíbrios significativos sejam considerados, enquanto FVG_ScanBars determina quantas barras do histórico o EA analisará em busca de gaps confirmados. A opção FVG_TradeAtEQ permite realizar operações no nível de equilíbrio (50% do gap), frequentemente considerado um ponto de entrada equilibrado na teoria SMC. Por fim, as configurações de cores, como BullOB, BearOB, BullFVG, BearFVG, BOSBull e BOSBear, facilitam a identificação visual dos objetos no gráfico, permitindo que os traders diferenciem rapidamente os cenários de alta e de baixa.

//---------------------------- Глобальные переменные ------------------------------//
double   Bid, Ask;
datetime g_lastBarTime = 0;

// состояние OB
class COrderBlock : public CObject
{
public:
   int      direction;   // +1 бычий, -1 медвежий
   datetime time;        // время свечи OB
   double   high;        // high свечи OB
   double   low;         // low свечи OB

   string Key() const { return TimeToString(time, TIME_DATE|TIME_MINUTES); }

   void draw(datetime tmS, datetime tmE, color clr){
      string objOB = " OB REC" + TimeToString(time);
      ObjectCreate( 0, objOB, OBJ_RECTANGLE, 0, time, low, tmS, high);
      ObjectSetInteger( 0, objOB, OBJPROP_FILL, true);
      ObjectSetInteger( 0, objOB, OBJPROP_COLOR, clr);
      
      string objtrade = " OB trade" + TimeToString(time);
      ObjectCreate( 0, objtrade, OBJ_RECTANGLE, 0, tmS, high, tmE, low); // прямоугольник торговой зоны
      ObjectSetInteger( 0, objtrade, OBJPROP_FILL, true);
      ObjectSetInteger( 0, objtrade, OBJPROP_COLOR, clr);
   }
};
COrderBlock* OB = NULL;

// состояние Fibonacci для OB
// Отслеживаем, был ли OB уже отработан
datetime lastTradedOBTime = 0;
bool tradedOB = false;
double fib_low, fib_high;
datetime fib_t1, fib_t2;
bool isBullishOB = false; 
bool isBearishOB = false;
datetime T1;
datetime T2;
color OBClr;
#define FIB_OB_BULL "FIB_OB_BULL"
#define FIB_OB_BEAR "FIB_OB_BEAR"
#define FIBO_OBJ "Fibo Retracement"

// состояние BOS 
datetime lastBOSTradeTime = 0;
bool Bull_BOS_traded, Bear_BOS_traded;
int lastBOSTradeDirection = 0; // 1 для покупки, -1 для продажи
double   swng_High = -1.0, swng_Low = -1.0;
datetime bos_tH = 0, bos_tL = 0;

Esta seção do código define as principais variáveis globais e estruturas utilizadas para acompanhar as condições do mercado, as oportunidades de negociação e os objetos do gráfico. Inicialmente, são declaradas variáveis globais como Bid, Ask e g_lastBarTime, essenciais para acompanhar os preços em tempo real e garantir que o EA execute sua lógica apenas uma vez a cada nova barra. Em seguida, é definida a classe COrderBlock, que encapsula as propriedades de um bloco de ordens, incluindo sua direção (alta ou baixa), o momento e os níveis de preço (high/low). A classe também contém o método draw(), responsável por criar automaticamente retângulos coloridos no gráfico, facilitando a identificação dos blocos de ordens ativos e de suas respectivas zonas de negociação. Ao concentrar essas funcionalidades em uma única classe, o código mantém uma estrutura clara e favorece a reutilização.

Além da definição básica dos blocos de ordens, são declaradas variáveis adicionais para sua confirmação por meio dos níveis de Fibonacci. Por exemplo, fib_low e fib_high armazenam os limites de preço, enquanto os marcadores temporais fib_t1 e fib_t2 registram os limites de tempo utilizados na construção das retrações de Fibonacci. Já os sinalizadores isBullishOB, isBearishOB e tradedOB permitem controlar a confirmação dos blocos de ordens e evitar que um mesmo bloco seja utilizado em mais de uma operação. Essas variáveis permitem que o EA considere dinamicamente os níveis de Fibonacci, de modo que apenas retrações confirmadas, como o nível de 61,8% definido nos parâmetros de entrada, sejam consideradas para a abertura de operações. Para facilitar a identificação visual, as constantes FIB_OB_BULL, FIB_OB_BEAR e FIBO_OBJ definem os nomes dos objetos do gráfico, permitindo distinguir facilmente as retrações de Fibonacci traçadas.

Por fim, é implementado o gerenciamento do estado dos rompimentos de estrutura (Break of Structure, BOS). As variáveis lastBOSTradeTime, Bull_BOS_traded e Bear_BOS_traded impedem a execução de operações duplicadas quando surge um sinal de BOS. A variável lastBOSTradeDirection registra se a última operação baseada em BOS foi de alta (+1) ou de baixa (-1), enquanto swng_High e swng_Low armazenam os níveis mais recentes de máximas e mínimas locais utilizados na identificação da estrutura do mercado. Os marcadores temporais bos_tH e bos_tL registram os momentos exatos de confirmação desses extremos locais, permitindo respeitar as regras de análise da estrutura do mercado. O gerenciamento global desses estados ajuda o EA a manter a consistência entre as diferentes estratégias (blocos de ordens, BOS e FVG) e a evitar a sobreposição de operações, estabelecendo uma base estruturada para automatizar as negociações com Smart Money Concepts.

//--------------------------- Вспомогательные функции -------------------------------//
double  getHigh(int i)   { return iHigh(_Symbol, _Period, i);  }
double  getLow(int i)    { return iLow(_Symbol, _Period, i);   }
double  getOpen(int i)   { return iOpen(_Symbol, _Period, i);  }
double  getClose(int i)  { return iClose(_Symbol, _Period, i); }
datetime getTimeBar(int i){ return iTime(_Symbol, _Period, i); }

bool IsNewBar()
{
   datetime lastbar_time = (datetime)SeriesInfoInteger(_Symbol, _Period, SERIES_LASTBAR_DATE);
   if(g_lastBarTime == 0) { g_lastBarTime = lastbar_time; return false; }
   if(g_lastBarTime != lastbar_time) { g_lastBarTime = lastbar_time; return true; }
   return false;
}

void ExecuteTrade(ENUM_ORDER_TYPE type)
{
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   double price = (type==ORDER_TYPE_BUY) ? SymbolInfoDouble(_Symbol, SYMBOL_ASK)
                                         : SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double sl = (type==ORDER_TYPE_BUY) ? price - StopLoss*point
                                      : price + StopLoss*point;
   double tp = (type==ORDER_TYPE_BUY) ? price + TakeProfit*point
                                      : price - TakeProfit*point;
   sl = NormalizeDouble(sl, _Digits);
   tp = NormalizeDouble(tp, _Digits);

   trade.SetExpertMagicNumber(MagicNumber);
   trade.PositionOpen(_Symbol, type, In_Lot, price, sl, tp, "SMC");
}

As funções auxiliares oferecem uma maneira clara e reutilizável de acessar os dados do gráfico. Em vez de chamar diretamente as funções nativas iHigh, iLow e iClose em diferentes partes do código, as funções auxiliares getHigh(), getLow() e getClose() simplificam o acesso aos dados das barras e melhoram a legibilidade. A função IsNewBar() desempenha um papel fundamental, garantindo que o EA execute sua lógica apenas uma vez por vela, sem repetir o processamento dentro da mesma barra. Para isso, armazena em g_lastBarTime a marca de tempo da última barra identificada e o compara com a marca de tempo da barra atual. Essa abordagem garante que os sinais sejam avaliados e as operações consideradas somente na abertura de uma nova barra, o que é especialmente importante para estratégias que dependem da confirmação pelo fechamento das velas.

A função ExecuteTrade() concentra toda a lógica de execução das operações. Ela calcula automaticamente o preço de entrada adequado e os níveis de stop-loss e take-profit de acordo com o tipo de ordem (buy ou sell), normalizando os valores conforme a precisão de cotação do instrumento. Ao reunir essa lógica em uma única função, o EA evita a duplicação de código e reduz a possibilidade de erros na abertura de operações. A função também define um MagicNumber específico para o EA, permitindo identificar e acompanhar suas operações, e atribui o comentário "SMC" a cada operação para facilitar a identificação das posições abertas pelo sistema.

//----------------------- Унифицированное обнаружение локальных экстремумов -------------------//
// Определяет, является ли barIndex локальным максимумом и/или минимумом, используя len баров с каждой стороны.
// Если найден локальный максимум -> обновляет fib_high/fib_tH (и swng_High/bos_tH для BOS).
// Если найден локальный минимум -> обновляет fib_low/fib_tL (и swng_Low/bos_tL для BOS).
// Функция обновляет соответствующие переменные, если обнаружен хотя бы один локальный экстремум.
void DetectSwingForBar(int barIndex, SWING_TYPE type)
{
   const int len = 5;
   bool isSwingH = true, isSwingL = true;   

   for(int i = 1; i <= len; i++){
      int right_bars = barIndex - i;
      int left_bars  = barIndex + i;
      
      if(right_bars < 0) {
         isSwingH = false;
         isSwingL = false;
         break;
      }
      
      if((getHigh(barIndex) <= getHigh(right_bars)) || (left_bars < Bars(_Symbol, _Period) && getHigh(barIndex) < getHigh(left_bars)))
         isSwingH = false;
      
      if((getLow(barIndex) >= getLow(right_bars)) || (left_bars < Bars(_Symbol, _Period) && getLow(barIndex) > getLow(left_bars)))
         isSwingL = false;
   }

   // Назначаем значения в зависимости от типа локального экстремума
   if(isSwingH){
      if(type == SWING_OB) {
         fib_high = getHigh(barIndex);
         fib_t1 = getTimeBar(barIndex);
      } else {
         swng_High = getHigh(barIndex);
         bos_tH = getTimeBar(barIndex);
      }
   }
   if(isSwingL){
      if(type == SWING_OB) {
         fib_low = getLow(barIndex);
         fib_t2 = getTimeBar(barIndex);
      } else {
         swng_Low = getLow(barIndex);
         bos_tL = getTimeBar(barIndex);
      }
   }
}

A função unificada de detecção de extremos locais identifica possíveis máximas e mínimas locais no gráfico, analisando uma barra específica e comparando-a com um número definido de barras vizinhas. Utilizando uma janela simétrica (len barras de cada lado), a função verifica se a barra analisada representa um extremo local: para uma máxima local, seu valor high deve ser superior aos das barras à esquerda e à direita; para uma mínima local, seu valor low deve ser inferior aos das barras de ambos os lados. Se alguma barra vizinha invalidar essas comparações, o candidato a extremo local é descartado. Esse método ajuda a evitar sinais falsos provocados por pequenas oscilações e prioriza pontos de referência relevantes para a estrutura do mercado.

Após a confirmação de um extremo local, a função atualiza as variáveis correspondentes de acordo com o tipo de análise. Na identificação de blocos de ordens (SWING_OB), as máximas e mínimas locais são utilizadas como pontos de referência para as retrações de Fibonacci e armazenadas em fib_high e fib_low, juntamente com suas marcas de tempo, que posteriormente servirão para validar as retrações. Na lógica de rompimento de estrutura (BOS), esses mesmos níveis são armazenados nas variáveis swng_High ou swng_Low, acompanhados das respectivas marcas de tempo (bos_tH ou bos_tL). Ao tratar a identificação de extremos locais para OB e BOS em uma única função, o EA elimina lógica redundante e padroniza essa identificação, tanto para a confirmação da estrutura do mercado quanto para os cenários de retração de Fibonacci.

void DetectAndDrawOrderBlocks()
{
   static datetime lastDetect = 0;
   datetime lastBar = (datetime)SeriesInfoInteger(_Symbol, _Period, SERIES_LASTBAR_DATE);
   
   // Сбрасываем обнаружение OB на новом баре
   if(lastDetect != lastBar)
   {
      if(OB != NULL) 
      { 
         delete OB; 
         OB = NULL; 
      }
      lastDetect = lastBar;
   }
   
   // Обнаруживаем новый OB только если текущего еще нет
   if(OB == NULL)
   {
      for(int i = 1; i < 100; i++)
      {
         // Кандидат на бычий OB
         if(getOpen(i) < getClose(i) && 
            getOpen(i+2) < getClose(i+2) &&
            getOpen(i+3) > getClose(i+3) && 
            getOpen(i+3) < getClose(i+2))
         {
            OB = new COrderBlock();
            OB.direction = 1;
            OB.time = getTimeBar(i+3);
            OB.high = getHigh(i+3);
            OB.low = getLow(i+3);
            OBClr = BullOB;
            T1 = OB.time;
            Print("Бычий ордер-блок обнаружен в: ", TimeToString(OB.time));
            break;
         }
         
         // Кандидат на медвежий OB
         if(getOpen(i) > getClose(i) && 
            getOpen(i+2) > getClose(i+2) &&
            getOpen(i+3) < getClose(i+3) && 
            getOpen(i+3) > getClose(i+2)) // Исправленное условие
         {
            OB = new COrderBlock();
            OB.direction = -1;
            OB.time = getTimeBar(i+3);
            OB.high = getHigh(i+3);
            OB.low = getLow(i+3);
            OBClr = BearOB;
            T1 = OB.time;
            Print("Медвежий ордер-блок обнаружен в: ", TimeToString(OB.time));
            break;
         }
      }
   }

   if(OB == NULL) return;
   
   // Проверяем, был ли этот OB уже отработан
   if(lastTradedOBTime == OB.time) return;

   // Если цена откатывается внутрь зоны OB
   Bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   Ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);

   bool inBullZone = (OB.direction > 0 && Ask <= OB.high && Ask >= OB.low);
   bool inBearZone = (OB.direction < 0 && Bid >= OB.low && Bid <= OB.high);

   if(!inBullZone && !inBearZone) return;

   // Используем функцию DetectSwing для поиска локальных экстремумов
   // Нужно вызвать ее несколько раз, чтобы найти последние локальные экстремумы
   double mostRecentSwingHigh = 0;
   double mostRecentSwingLow = EMPTY_VALUE;
   datetime mostRecentSwingHighTime = 0;
   datetime mostRecentSwingLowTime = 0;
   
   // Сканируем последние бары для поиска актуальных локальных экстремумов
   for(int i = 0; i < 20; i++) // Проверяем последние 20 баров
   {
      // Сбрасываем переменные локальных экстремумов
      fib_high = 0;
      fib_low = 0;
      fib_t1 = 0;
      fib_t2 = 0;
      
      DetectSwingForBar(i, SWING_OB);
      
      if(fib_high > 0 && (mostRecentSwingHighTime == 0 || fib_t1 > mostRecentSwingHighTime))
      {
         mostRecentSwingHigh = fib_high;
         mostRecentSwingHighTime = fib_t1;
      }
      
      if(fib_low < EMPTY_VALUE && (mostRecentSwingLowTime == 0 || fib_t2 > mostRecentSwingLowTime))
      {
         mostRecentSwingLow = fib_low;
         mostRecentSwingLowTime = fib_t2;
      }
   }
   
   // Убеждаемся, что найдены обе точки локального экстремума
   if(mostRecentSwingHighTime == 0 || mostRecentSwingLowTime == 0) return;
   
   // Строим Fibonacci перед торговлей для подтверждения
   if(OB.direction > 0 && inBullZone)
   {
      // Строим Fibonacci от последнего локального минимума к последнему локальному максимуму
      ObjectDelete(0, "FIB_OB_BULL");
      if(ObjectCreate(0, "FIB_OB_BULL", OBJ_FIBO, 0, mostRecentSwingLowTime, mostRecentSwingLow, 
                     mostRecentSwingHighTime, mostRecentSwingHigh))
      {
         // Форматируем Fibonacci
         ObjectSetInteger(0, "FIB_OB_BULL", OBJPROP_COLOR, clrBlack);
         for(int i = 0; i < ObjectGetInteger(0, "FIB_OB_BULL", OBJPROP_LEVELS); i++)
         {
            ObjectSetInteger(0, "FIB_OB_BULL", OBJPROP_LEVELCOLOR, i, clrBlack);
         }
         
         double entLvlBull = mostRecentSwingHigh - (mostRecentSwingHigh - mostRecentSwingLow) * (Fib_Trade_lvls / 100.0);
         
         if(Ask <= entLvlBull)
         {
            T2 = getTimeBar(0);
            OB.draw(T1, T2, BullOB);
            ExecuteTrade(ORDER_TYPE_BUY);
            lastTradedOBTime = OB.time; // Помечаем этот OB как отработанный
            delete OB;
            OB = NULL;
         }
      }
   }
   else if(OB.direction < 0 && inBearZone)
   {
      // Строим Fibonacci от последнего локального максимума к последнему локальному минимуму
      ObjectDelete(0, "FIB_OB_BEAR");
      if(ObjectCreate(0, "FIB_OB_BEAR", OBJ_FIBO, 0, mostRecentSwingHighTime, mostRecentSwingHigh, 
                     mostRecentSwingLowTime, mostRecentSwingLow))
      {
         // Форматируем Fibonacci
         ObjectSetInteger(0, "FIB_OB_BEAR", OBJPROP_COLOR, clrBlack);
         for(int i = 0; i < ObjectGetInteger(0, "FIB_OB_BEAR", OBJPROP_LEVELS); i++)
         {
            ObjectSetInteger(0, "FIB_OB_BEAR", OBJPROP_LEVELCOLOR, i, clrBlack);
         }
         
         double entLvlBear = mostRecentSwingLow + (mostRecentSwingHigh - mostRecentSwingLow) * (Fib_Trade_lvls / 100.0);
         
         if(Bid >= entLvlBear)
         {
            T2 = getTimeBar(0);
            OB.draw(T1, T2, BearOB);
            ExecuteTrade(ORDER_TYPE_SELL);
            lastTradedOBTime = OB.time; // Помечаем этот OB как отработанный
            delete OB;
            OB = NULL;
         }
      }
   }
}

A função DetectAndDrawOrderBlocks() é responsável por identificar e confirmar blocos de ordens, além de executar operações com base neles, utilizando os níveis de Fibonacci como critério adicional de confirmação. A cada nova barra, a função reinicializa a detecção e analisa as velas recentes em busca de padrões de blocos de ordens de alta ou de baixa. Quando identifica um bloco de ordens confirmado, verifica se o preço atual retornou à zona correspondente, indicando uma possível oportunidade de negociação. Antes de executar a operação, a função aciona a detecção de extremos locais para identificar as máximas e mínimas mais recentes e verificar se é possível traçar uma retração de Fibonacci entre esses pontos.

Em seguida, os níveis de Fibonacci são utilizados para confirmar a entrada: a operação só é autorizada quando o preço coincide com o nível de retração previamente definido. Dessa forma, o sistema evita entradas prematuras e executa operações apenas quando há confluência entre a zona do bloco de ordens e o nível de retração de Fibonacci, aumentando a precisão e a consistência dos critérios de confirmação.

//============================== FVG ================================//
// Определение (в стиле ICT):
// Пусть C=i, B=i+1, A=i+2.
// Бычий FVG, если Low(A) > High(C) -> разрыв [High(C), Low(A)]
// Медвежий FVG, если High(A) < Low(C) -> разрыв [High(A), Low(C)]
struct SFVG
{
   int      dir;    // +1 бычий, -1 медвежий
   datetime tLeft;  // левая временная привязка
   double   top;    // верхняя цена зоны
   double   bot;    // нижняя цена зоны

   string Name() const
   {
      string k = TimeToString(tLeft, TIME_DATE|TIME_MINUTES);
      return (dir>0 ? "FVG_B_" : "FVG_S_") + k + "_" + IntegerToString((int)(top*1000.0));
   }
};

bool FVGExistsAt(const string &name){ return ObjectFind(0, name) != -1; }

void DetectAndDrawFVGs()
{
   double point = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
   int counted = 0;

   for(int i=2; i<MathMin(FVG_ScanBars, Bars(_Symbol, _Period))-2; i++)
   {
      // Формируем A,B,C
      double lowA  = getLow(i+2);
      double highA = getHigh(i+2);
      double highC = getHigh(i);
      double lowC  = getLow(i);

      // Бычий FVG: Low A > High C
      if(lowA > highC && (lowA - highC >= FVG_MinPoints * point))
      {
         SFVG z;
         z.dir   = +1;
         z.tLeft = getTimeBar(i+2);  // Изменено с getTimeBar на getTime
         z.top   = lowA;
         z.bot   = highC;
         DrawFVG(z);
         counted++;
      }
      // Медвежий FVG: High A < Low C
      else if(highA < lowC && (lowC - highA >= FVG_MinPoints * point))
      {
         SFVG z;
         z.dir   = -1;
         z.tLeft = getTimeBar(i+2);  // Изменено с getTimeBar на getTime
         z.top   = lowC;          // Исправлено: для верхней границы медвежьего FVG должен быть lowC
         z.bot   = highA;         // Исправлено: для нижней границы медвежьего FVG должен быть highA
         DrawFVG(z);
         counted++;
      }
      
      if(counted > 15) break; // избегаем перегруженности
   }

   // --- Упрощенная торговля по FVG ---
   Bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   Ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);

   // сканируем построенные объекты и торгуем при первом подтвержденном касании EQ (50%)
   int total = ObjectsTotal(0, 0, -1);
   static datetime lastTradeBar = 0;
   
   if(OneTradePerBar)
   {
      datetime barNow = (datetime)SeriesInfoInteger(_Symbol, _Period, SERIES_LASTBAR_DATE);
      if(lastTradeBar == barNow) return; // на этом баре уже торговали
   }

   for(int idx=0; idx<total; idx++)
   {
      string name = ObjectName(0, idx);
      if(StringFind(name, "FVG_", 0) != 0) continue; // только наши FVG

      // Получаем координаты объекта
      datetime t1 = (datetime)ObjectGetInteger(0, name, OBJPROP_TIME, 0);
      double y1 = ObjectGetDouble(0, name, OBJPROP_PRICE, 0);
      datetime t2 = (datetime)ObjectGetInteger(0, name, OBJPROP_TIME, 1);
      double y2 = ObjectGetDouble(0, name, OBJPROP_PRICE, 1);

      double top = MathMax(y1, y2);
      double bot = MathMin(y1, y2);
      bool isBull = (StringFind(name, "FVG_B_", 0) == 0);
      double mid  = (top + bot) * 0.5;

      if(isBull)
      {
         // торговать, когда Ask внутри разрыва и на/ниже EQ
         if(Ask <= top && Ask >= bot && (!FVG_TradeAtEQ || Ask <= mid))
         {
            ExecuteTrade(ORDER_TYPE_BUY);
            lastTradeBar = (datetime)SeriesInfoInteger(_Symbol, _Period, SERIES_LASTBAR_DATE);
            break;
         }
      }
      else
      {
         // торговать, когда Bid внутри разрыва и на/выше EQ
         if(Bid <= top && Bid >= bot && (!FVG_TradeAtEQ || Bid >= mid))
         {
            ExecuteTrade(ORDER_TYPE_SELL);
            lastTradeBar = (datetime)SeriesInfoInteger(_Symbol, _Period, SERIES_LASTBAR_DATE);
            break;
         }
      }
   }
}

Esta função identifica e desenha gaps de valor justo (Fair Value Gaps, FVG), além de executar operações com base nesses padrões, seguindo a lógica ICT. Inicialmente, analisa as barras recentes para identificar gaps de alta, nos quais a mínima (low) da vela A é superior à máxima (high) da vela C, e gaps de baixa, nos quais a máxima (high) da vela A é inferior à mínima (low) da vela C, desde que o tamanho do gap atenda ao mínimo estabelecido em pontos. Após a identificação, o FVG é armazenado em uma estrutura, representado visualmente no gráfico e monitorado para possíveis operações. O sistema acompanha as zonas FVG ativas e verifica quando o preço entra nessas regiões e, caso a opção esteja habilitada, coincide com o nível de equilíbrio (50% do gap). Quando as condições são atendidas, a função abre uma operação de compra em FVGs de alta ou de venda em FVGs de baixa, limitando a execução a uma operação por barra para evitar negociações excessivas. Ao integrar detecção, visualização e execução de operações, a ferramenta FVG não se limita à análise, podendo também ser utilizada diretamente nas operações de negociação.

//=============================== BOS ===============================//
// Используем унифицированные локальные экстремумы (без RSI). Торговая логика повторяет ваш предыдущий код:
// - Продавать, когда цена пробивает последний локальный максимум вверх
// - Покупать, когда цена пробивает последний локальный минимум вниз
void DetectAndDrawBOS()
{
   // Используем DetectSwingForBar для поиска последних локальных экстремумов
   double mostRecentSwingHigh = 0;
   double mostRecentSwingLow = EMPTY_VALUE;
   datetime mostRecentSwingHighTime = 0;
   datetime mostRecentSwingLowTime = 0;
   
   // Сканируем последние бары для поиска актуальных локальных экстремумов для BOS
   for(int i = 0; i < 20; i++) // Проверяем последние 20 баров
   {
      // Сбрасываем переменные локальных экстремумов
      swng_High = 0;
      swng_Low = 0;
      bos_tH = 0;
      bos_tL = 0;
      
      // Обнаруживаем локальный экстремум на этом баре для BOS
      DetectSwingForBar(i, SWING_BOS);
      
      if(swng_High > 0 && (mostRecentSwingHighTime == 0 || bos_tH > mostRecentSwingHighTime))
      {
         mostRecentSwingHigh = swng_High;
         mostRecentSwingHighTime = bos_tH;
      }
      
      if(swng_Low < EMPTY_VALUE && (mostRecentSwingLowTime == 0 || bos_tL > mostRecentSwingLowTime))
      {
         mostRecentSwingLow = swng_Low;
         mostRecentSwingLowTime = bos_tL;
      }
   }
   
   // Обновляем глобальные переменные BOS последними локальными экстремумами
   if(mostRecentSwingHighTime > 0)
   {
      if(mostRecentSwingHighTime != bos_tH)
         Bull_BOS_traded = false;
      swng_High = mostRecentSwingHigh;
      bos_tH = mostRecentSwingHighTime;
   }
   
   if(mostRecentSwingLowTime > 0)
   {
      if(mostRecentSwingLowTime != bos_tL)
         Bear_BOS_traded = false;
      swng_Low = mostRecentSwingLow;
      bos_tL = mostRecentSwingLowTime;
   }
   
   // Теперь проверяем пробой структуры
   Bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   Ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   
   // Получаем время текущего бара, чтобы предотвратить несколько сделок на одном баре
   datetime currentBarTime = iTime(_Symbol, _Period, 0);
   
   // ПОКУПКА при пробое локального максимума вверх
   if(swng_High > 0 && Ask > swng_High && Bull_BOS_traded == false)
   {
      // Проверяем, что этот пробой еще не торговался
      if(lastBOSTradeTime != currentBarTime || lastBOSTradeDirection != -1)
      {
         if(DrawBOSLines)
            DrawBOS("BOS_H_" + TimeToString(bos_tH), bos_tH, swng_High,
                    TimeCurrent(), swng_High, BOSBear, -1);
         
         ExecuteTrade(ORDER_TYPE_BUY);
         
         // Обновляем отслеживание сделок
         lastBOSTradeTime = currentBarTime;
         lastBOSTradeDirection = -1;
         Bull_BOS_traded = true;
         
         // Сбрасываем локальный максимум, чтобы предотвратить немедленную повторную торговлю
         swng_High = -1.0;
      }
   }
   
   // ПРОДАЖА при пробое локального минимума вниз
   if(swng_Low > 0 && Bid < swng_Low && Bear_BOS_traded == false)
   {
      // Проверяем, что этот пробой еще не торговался
      if(lastBOSTradeTime != currentBarTime || lastBOSTradeDirection != 1)
      {
         if(DrawBOSLines)
            DrawBOS("BOS_L_" + TimeToString(bos_tL), bos_tL, swng_Low,
                    TimeCurrent(), swng_Low, BOSBull, +1);
         
         ExecuteTrade(ORDER_TYPE_SELL);
         
         // Обновляем отслеживание сделок
         Bear_BOS_traded = true;
         lastBOSTradeTime = currentBarTime;
         lastBOSTradeDirection = 1;
         
         // Сбрасываем локальный минимум, чтобы предотвратить немедленную повторную торговлю
         swng_Low = -1.0;
      }
   }   
}
A função BOS identifica rompimentos de estrutura (Break of Structure, BOS) e executa operações com base nesses sinais, utilizando a lógica unificada de detecção de extremos locais. Ela analisa as últimas 20 barras para identificar as máximas e mínimas locais mais recentes, atualiza as variáveis globais relacionadas ao BOS e impede a execução de operações duplicadas na mesma barra. O comentário associado à função indica que a lógica de negociação segue a implementação anterior: venda quando o preço rompe a última máxima local para cima e compra quando rompe a última mínima local para baixo. Entretanto, as condições implementadas no código apresentam a lógica oposta: compra no rompimento de uma máxima local para cima e venda no rompimento de uma mínima local para baixo. Essa divergência entre o comentário e a implementação é mantida como uma inconsistência interna do material original, sem correção implícita na tradução. Para facilitar a análise visual, a função também pode desenhar linhas adicionais de BOS no gráfico, enquanto sinalizadores internos impedem a abertura imediata de novas operações com base no mesmo rompimento.
//---------------------------- Интерфейс BOS -------------------------------//
void DrawBOS(const string name, datetime t1, double p1, datetime t2, double p2, color col, int dir)
{
   if(ObjectFind(0, name) == -1)
   {
      ObjectCreate(0, name, OBJ_TREND, 0, t1, p1, t2, p2);
      ObjectSetInteger(0, name, OBJPROP_COLOR, col);
      ObjectSetInteger(0, name, OBJPROP_WIDTH, 2);

      string lbl = name + "_lbl";
      ObjectCreate(0, lbl, OBJ_TEXT, 0, t2, p2);
      ObjectSetInteger(0, lbl, OBJPROP_COLOR, col);
      ObjectSetInteger(0, lbl, OBJPROP_FONTSIZE, 10);
      ObjectSetString(0,  lbl, OBJPROP_TEXT, "Пробой");
      ObjectSetInteger(0, lbl, OBJPROP_ANCHOR, (dir>0)?ANCHOR_RIGHT_UPPER:ANCHOR_RIGHT_LOWER);
   }
}

A função DrawBOS é responsável por representar visualmente os rompimentos de estrutura (Break of Structure, BOS) no gráfico. Para isso, cria uma linha de tendência entre os pontos (t1, p1) e (t2, p2), com cor e espessura definidas. Se ainda não existir um objeto com o nome especificado, a função cria a linha de tendência, configura sua cor e espessura e adiciona uma etiqueta de texto com a inscrição "Break" no ponto final. O posicionamento da etiqueta depende da direção indicada por dir: o texto é ancorado pelo canto superior direito nos rompimentos de alta e pelo canto inferior direito nos rompimentos de baixa. Dessa forma, o gráfico apresenta uma indicação visual clara das mudanças na estrutura do mercado.

void DrawFVG(const SFVG &z)
{
   string name = z.Name();
   datetime tNow = (datetime)SeriesInfoInteger(_Symbol, _Period, SERIES_LASTBAR_DATE);
   
   // Удаляем существующий объект, если он есть
   if(ObjectFind(0, name) != -1) 
      ObjectDelete(0, name);
   
   // Создаем прямоугольный объект для FVG
   if(!ObjectCreate(0, name, OBJ_RECTANGLE, 0, z.tLeft, z.bot, tNow, z.top))
   {
      Print("Ошибка создания объекта FVG: ", GetLastError());
      return;
   }
   
   // Задаем свойства объекта
   ObjectSetInteger(0, name, OBJPROP_COLOR, z.dir>0 ? BullFVG : BearFVG);
   ObjectSetInteger(0, name, OBJPROP_FILL, true);
   ObjectSetInteger(0, name, OBJPROP_BACK, true);
   ObjectSetInteger(0, name, OBJPROP_WIDTH, 1);
   ObjectSetInteger(0, name, OBJPROP_STYLE, STYLE_SOLID);
   
   // Задаем Z-order, чтобы объект был видимым
   ObjectSetInteger(0, name, OBJPROP_ZORDER, 0);
}

A função DrawFVG representa graficamente os gaps de valor justo (Fair Value Gaps, FVG). Inicialmente, verifica se já existe um objeto com o nome do FVG e, caso exista, remove-o para evitar duplicações. Em seguida, desenha um retângulo que se estende da marca de tempo inicial do gap (tLeft) até a barra atual, abrangendo a faixa de preços delimitada por bot (limite inferior) e top (limite superior). A cor do retângulo é definida de acordo com a direção do gap. O objeto recebe preenchimento e borda contínua e é posicionado no plano de fundo do gráfico. A configuração de Z-order como 0 mantém o FVG visível atrás dos demais elementos, oferecendo aos traders uma referência visual clara das regiões de ineficiência de preços em tempo real.

void OnTick()
{
   if(!IsNewBar()) return;

   // Переключатель стратегии
   if(TradeStrategy == STRAT_FVG || TradeStrategy == STRAT_AUTO)
      DetectAndDrawFVGs();

   if(TradeStrategy == STRAT_OB  || TradeStrategy == STRAT_AUTO)
      DetectAndDrawOrderBlocks();

   if(TradeStrategy == STRAT_BOS || TradeStrategy == STRAT_AUTO)
      DetectAndDrawBOS();
}

A função OnTick é acionada a cada tick do mercado, mas só prossegue com o processamento quando uma nova barra é formada, garantindo que os cálculos sejam executados apenas uma vez por vela. Em seguida, verifica a estratégia de negociação selecionada: quando a estratégia FVG ou o modo automático está ativo, chama DetectAndDrawFVGs; quando a estratégia de blocos de ordens (OB) ou o modo automático está ativo, chama DetectAndDrawOrderBlocks; e quando a estratégia de rompimento de estrutura (BOS) ou o modo automático está ativo, chama DetectAndDrawBOS. Essa implementação permite que o EA ou indicador identifique e represente dinamicamente diferentes estruturas do mercado em tempo real, conforme a estratégia selecionada.


Resultados do backtest

O backtest foi realizado no timeframe de 1 hora (H1), durante um período de aproximadamente dois meses, de 1º de julho de 2025 a 1º de setembro de 2025, utilizando a estratégia BOS como configuração padrão.



Conclusão

Com isso, desenvolvemos uma estrutura integrada de negociação baseada em Smart Money Concepts (SMC), reunindo três elementos fundamentais: blocos de ordens (Order Blocks, OB), rompimentos de estrutura (Break of Structure, BOS) e gaps de valor justo (Fair Value Gaps, FVG). Cada conceito foi implementado com funcionalidades de detecção, representação gráfica e execução de operações. Os blocos de ordens foram identificados como zonas de atuação institucional, com confirmação por retrações de Fibonacci. O BOS permitiu identificar eventos de varredura de liquidez quando o preço ultrapassava máximas ou mínimas locais, enquanto os FVGs destacaram regiões de ineficiência de preços que frequentemente funcionam como zonas de forte reação. Integrados em um único sistema, esses elementos permitem identificar dinamicamente cenários de negociação com maior probabilidade de sucesso diretamente no gráfico, combinando referências visuais com execução automática de operações.

Essa abordagem integrada oferece aos traders uma maneira sistemática de aplicar os princípios de SMC, reduzindo a subjetividade frequentemente presente na análise manual dos gráficos. O EA não apenas identifica e acompanha as mudanças na estrutura do mercado, mas também executa operações em tempo real quando o preço atende às condições SMC previamente estabelecidas. Isso proporciona uma metodologia disciplinada, baseada em regras, que reduz os vieses emocionais nas decisões, aumenta a consistência operacional e oferece uma vantagem profissional na identificação de oportunidades associadas à atuação institucional em diferentes condições de mercado.

Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/16340

Arquivos anexados |
SMC_ALL_IN_1.mq5 (21.41 KB)
Últimos Comentários | Ir para discussão (12)
Hlomohang John Borotho
Hlomohang John Borotho | 16 set. 2025 em 15:59
Stanislav Korotky #:

A “Lacuna do Valor Justo” está descrita e ilustrada incorretamente; por favor, consulte a imagem correta neste artigo.

Você está enganado, é a mesma coisa; eu representei a FVG com o preço/velas já retraçados dentro da zona da FVG.
Hlomohang John Borotho
Hlomohang John Borotho | 16 set. 2025 em 16:00
Yata Tema Gea #:

Uau, seu artigo está ótimo. Tenho certeza de que há indonésios mencionados no artigo. Nossa abordagem é a mesma, mas a diferença é que eu uso Python para SMC+GPT.


Entendi :)
Stanislav Korotky
Stanislav Korotky | 16 set. 2025 em 17:37
Hlomohang John Borotho #:
Você está enganado, é a mesma coisa; eu representei o FVG com o preço e as velas já retraçados dentro da zona do FVG.

Você está errado ou preparou mal seu gráfico. Como a 1ª e a 3ª velas (da esquerda) estão em vermelho, elas são de baixa e formam duas grandes lacunas antes e depois da 2ª vela (onde, presumivelmente, ocorreu o FVG).

Se você pesquisar “FVG” na internet, verá que essa formação se refere a um grande salto/lacuna unidirecional no preço, e não um ziguezague de saltos, o que obscureceria todo o efeito para possíveis retrações futuras, pois você não sabe qual (das três lacunas) está prestes a se fechar primeiro (na sua imagem, é a última lacuna ao longo da terceira vela, não a segunda — ela é fechada pela quarta vela).
Bao Thuan Thai
Bao Thuan Thai | 28 set. 2025 em 11:06
Não preciso saber como isso funciona, mas muito obrigado por compartilhar e pela gentileza
ritik pathak
ritik pathak | 4 out. 2025 em 11:01
Ótimo trabalho; poderia ficar ainda melhor se o stop fosse definido abaixo/acima do FVG ou se o bloco de ordens não utilizasse um stop loss em ponto fixo.
Automatização de estratégias de negociação em MQL5 (Parte 30): Criação e visualização do padrão harmônico AB=CD com base em Price Action Automatização de estratégias de negociação em MQL5 (Parte 30): Criação e visualização do padrão harmônico AB=CD com base em Price Action
Neste artigo, desenvolvemos um EA em MQL5 para reconhecer o padrão AB=CD. O sistema identifica padrões harmônicos de alta e de baixa com base em pontos de reversão e níveis de Fibonacci, automatizando a abertura de operações com níveis precisos de entrada, stop-loss e take-profit. Também aprimoramos a visualização dos padrões por meio de objetos gráficos.
Do iniciante ao especialista: Criando um EA animado para negociação baseada em notícias em MQL5 (X) - Visualização de múltiplos símbolos em um único gráfico para negociação baseada em notícias Do iniciante ao especialista: Criando um EA animado para negociação baseada em notícias em MQL5 (X) - Visualização de múltiplos símbolos em um único gráfico para negociação baseada em notícias
Hoje, vamos desenvolver um sistema de visualização de múltiplos gráficos utilizando objetos gráficos. O objetivo é aprimorar a negociação baseada em notícias por meio de algoritmos em MQL5 que ajudam a reduzir o tempo de reação dos traders durante períodos de alta volatilidade, como a divulgação de notícias de grande impacto. Para isso, ofereceremos aos traders uma solução integrada que permite monitorar vários dos principais instrumentos em uma única ferramenta de negociação baseada em notícias. Nosso projeto continua evoluindo com o News Headline EA ("Manchetes de notícias"), que agora conta com um conjunto cada vez maior de funcionalidades que agregam valor tanto para traders que utilizam sistemas totalmente automatizados quanto para aqueles que preferem operar manualmente com o auxílio de algoritmos. Acesse o link e participe desta discussão para ampliar seus conhecimentos, obter informações e conhecer ideias práticas.
Desenvolvimento de um indicador personalizado de sentimento do mercado Desenvolvimento de um indicador personalizado de sentimento do mercado
Neste artigo, desenvolveremos um indicador personalizado de sentimento do mercado que classifica o sentimento como altista, baixista, risk-on, risk-off ou neutro. Por meio da análise de múltiplos timeframes, o indicador oferece aos traders uma visão mais clara do viés direcional geral do mercado e dos sinais de confirmação de curto prazo.
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 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
Este artigo apresenta o Fractal Reaction System, um sistema compacto desenvolvido em MQL5 que transforma pontos de pivô fractais em sinais de estrutura de mercado aplicáveis à negociação. Ao analisar apenas barras fechadas para evitar a repintura dos sinais, o EA emite alertas sobre mudanças de caráter (ChOCh) e confirma rompimentos de estrutura (BOS). Além disso, desenha objetos gráficos persistentes, registra cada evento confirmado e emite alertas para desktop e dispositivos móveis, incluindo notificações sonoras. A seguir, abordaremos a concepção do algoritmo, os detalhes de implementação, os resultados dos testes e o código-fonte completo do EA, para que você possa compilar, testar e executar a ferramenta por conta própria.