English Русский 中文 Español Deutsch 日本語
preview
Criação de um sistema de negociação profissional baseado em Heikin Ashi (Parte 1): Desenvolvimento de um indicador personalizado

Criação de um sistema de negociação profissional baseado em Heikin Ashi (Parte 1): Desenvolvimento de um indicador personalizado

MetaTrader 5 — Sistemas de negociação |
27 0
Chacha Ian Maroa
Chacha Ian Maroa

Introdução

Os indicadores técnicos são fundamentais para a negociação algorítmica, e aprender a desenvolvê-los é uma etapa importante na trajetória de qualquer programador MQL5. Neste artigo, adotaremos uma abordagem prática para desenvolver um indicador personalizado Heikin Ashi, um dos recursos mais populares para suavizar tendências.

Este artigo é o primeiro de uma série de duas partes. Nesta primeira parte, abordaremos os fundamentos teóricos das velas Heikin Ashi, explicaremos como são calculadas e apresentaremos, passo a passo, o desenvolvimento de um indicador Heikin Ashi do zero utilizando MQL5. O objetivo não é simplesmente copiar e colar o código-fonte, mas compreender de fato a função de cada linha, para que você possa aplicar essas boas práticas ao desenvolver seus próprios indicadores.

Na segunda parte, desenvolveremos um EA que utilizará o indicador Heikin Ashi como base para definir os pontos de entrada e saída das operações. Para começar, vamos entender o que diferencia os gráficos Heikin Ashi dos gráficos tradicionais de velas.

Antes de começarmos, é importante que você já tenha familiaridade com alguns conceitos e ferramentas. Este artigo pressupõe que você:

  • Tenha bons conhecimentos da linguagem de programação MQL5.
  • Saiba utilizar o MetaTrader 5 e o MetaEditor 5.
  • Consiga adicionar indicadores e EAs aos gráficos.
Ao concluir a leitura, você terá adquirido os conhecimentos necessários para implementar indicadores personalizados seguindo as boas práticas modernas de desenvolvimento em MQL5. Embora nosso exemplo seja voltado ao Heikin Ashi, as mesmas técnicas podem ser aplicadas a qualquer indicador que utilize velas não convencionais ou representações visuais dos sinais de negociação por meio de cores.



Qual é a diferença entre um gráfico Heikin Ashi e um gráfico tradicional de velas?

Para começar, vamos comparar dois gráficos lado a lado.

Gráfico tradicional de velas:

Gráfico tradicional de velas

Gráfico Heikin Ashi construído com base nos mesmos dados de preços:

Gráfico Heikin Ashi

Ambos os gráficos representam os movimentos recentes do preço do ouro. Ao compará-los, observe o comportamento das velas durante os períodos de tendência. Os gráficos tradicionais de velas são atualizados a cada nova barra de preços, mas os movimentos frequentemente parecem irregulares, com mudanças constantes de cor mesmo quando a tendência predominante permanece inalterada. Isso gera ruído visual e dificulta a avaliação rápida do momentum do preço. Já as velas Heikin Ashi são calculadas a partir de valores suavizados, proporcionando uma representação visual muito mais limpa. Durante os períodos de tendência, o Heikin Ashi costuma apresentar longas sequências de velas da mesma cor, facilitando a identificação visual de tendências de alta e de baixa.

Em termos simples, as velas Heikin Ashi tendem a permanecer verdes durante as tendências de alta e vermelhas durante as tendências de baixa, filtrando pequenas correções que poderiam parecer reversões em um gráfico tradicional. Isso as torna uma ferramenta poderosa para traders que desejam acompanhar a tendência sem se deixar influenciar por oscilações temporárias.

Na próxima seção, veremos em detalhes como essas velas são calculadas.


Como são calculadas as velas Heikin Ashi

Antes de examinarmos o cálculo das velas Heikin Ashi, precisamos entender como elas diferem das velas convencionais. Em um gráfico tradicional, cada vela é formada a partir de quatro valores fundamentais de mercado.

Estrutura de uma vela

  1. Open: preço de abertura da vela.
  2. High: preço máximo atingido durante a formação da vela.
  3. Low: preço mínimo atingido durante a formação da vela.
  4. Close: preço de fechamento da vela.

Esses valores representam diretamente o comportamento do preço em um determinado período, como uma hora ou um dia. As velas Heikin Ashi, porém, não utilizam esses valores originais diretamente. Em vez disso, empregam um conjunto de valores modificados para suavizar o gráfico e destacar com maior clareza a tendência predominante.

Uma vela Heikin Ashi é composta pelos seguintes elementos:

  1. Heikin Ashi Open: valor suavizado do preço de abertura da vela.
  2. Heikin Ashi High: maior valor entre os dados reais e os valores suavizados considerados no cálculo.
  3. Heikin Ashi Low: menor valor desse mesmo conjunto.
  4. Heikin Ashi Close: média dos preços da vela real atual.

Agora, vamos analisar detalhadamente como cada um desses valores é calculado.


Fórmulas do Heikin Ashi

Heikin Ashi close = (Open + High + Low + Close) / 4.

Esse cálculo representa a média dos quatro preços da vela atual, fornecendo um único valor que resume o comportamento do preço durante o período.

Heikin Ashi open = (Heikin Ashi open da vela anterior + Heikin Ashi close da vela anterior) / 2.

Isso significa que a abertura da vela Heikin Ashi atual não corresponde ao preço de abertura real do mercado, mas ao ponto médio do corpo da vela Heikin Ashi anterior. Esse método suaviza as transições entre as velas, produzindo a aparência suavizada característica desse tipo de gráfico.

Heikin Ashi High = maior valor entre High, Heikin Ashi Open e Heikin Ashi Close.

Heikin Ashi Low = menor valor entre Low, Heikin Ashi Open e Heikin Ashi Close.

Esses dois últimos cálculos combinam os preços máximos e mínimos reais do mercado com os valores suavizados de abertura e fechamento. Assim, as sombras refletem essa combinação, preservando os benefícios da suavização.

Em resumo:

O Heikin Ashi close representa a média dos preços da vela atual. O Heikin Ashi open é calculado a partir dos valores suavizados da vela anterior. O Heikin Ashi High e o Heikin Ashi Low combinam valores reais e suavizados para representar os extremos das velas Heikin Ashi.

É esse método de cálculo que confere às velas Heikin Ashi uma aparência mais limpa, facilitando a identificação de tendências. Elas geralmente permanecem verdes durante as tendências de alta e vermelhas durante as tendências de baixa, filtrando oscilações de curto prazo que poderiam dificultar a interpretação do gráfico.

Nas próximas seções, colocaremos esses conhecimentos em prática, desenvolvendo passo a passo um indicador Heikin Ashi personalizado em MQL5.


Planejamento da lógica do indicador

Antes de começarmos a escrever o código, é importante definir a lógica do nosso indicador Heikin Ashi. Nosso objetivo é criar um indicador personalizado que exiba velas Heikin Ashi diretamente no gráfico, de maneira semelhante às velas convencionais, mas utilizando valores de preço suavizados.

Além da representação visual padrão, vamos aprimorar o gráfico Heikin Ashi utilizando três cores diferentes: uma para as velas de alta, outra para as velas de baixa e uma terceira para as velas neutras.

Para implementar essa lógica de visualização, nosso indicador utilizará cinco buffers:

  1. Heikin Ashi Open. Array que armazena o preço de abertura Heikin Ashi.
  2. Heikin Ashi High. Array que armazena o preço máximo Heikin Ashi.
  3. Heikin Ashi Low. Array que armazena o preço mínimo Heikin Ashi.
  4. Heikin Ashi Close. Array que armazena o preço de fechamento Heikin Ashi.
  5. Color Buffer. Array que armazena o índice de cor de cada vela Heikin Ashi, conforme sua classificação como vela de alta, de baixa ou neutra.

Cada buffer desempenha um papel importante tanto na construção das velas Heikin Ashi quanto na atribuição dinâmica das cores correspondentes.

Para exibir essas velas, utilizaremos uma única plotagem do tipo DRAW_COLOR_CANDLES, que permite representar as velas com um único identificador de plotagem e um buffer separado para controlar suas cores. Um aspecto exige atenção especial: a primeira barra do gráfico, pois não existe uma vela Heikin Ashi anterior que possa servir de referência para o cálculo. Por isso, inicializaremos manualmente os valores da primeira barra, permitindo que as demais velas sejam calculadas corretamente com base nas fórmulas definidas.

Por fim, para manter o código organizado e acessível aos iniciantes, adotaremos uma estrutura modular, dividindo os principais componentes da lógica em funções pequenas e bem definidas. Isso facilitará a compreensão, a depuração e a ampliação do código nas próximas lições.


Guia passo a passo para desenvolver o indicador Heikin Ashi

Para criar nosso indicador Heikin Ashi personalizado, utilizaremos a linguagem de programação MQL5, a principal linguagem para o desenvolvimento de ferramentas de negociação automatizada no MetaTrader 5.

Como partimos do pressuposto de que os leitores já sabem utilizar o MetaTrader 5 e o MetaEditor e conhecem os procedimentos básicos para adicionar indicadores aos gráficos, não abordaremos os detalhes de configuração. Em vez disso, passaremos diretamente ao desenvolvimento do nosso indicador Heikin Ashi personalizado.

A seguir, apresentamos um código-modelo que servirá de base para o desenvolvimento do indicador. A partir desse modelo, implementaremos gradualmente sua lógica principal.

//|                                          heikinAshiIndicator.mq5 |
//|                                  Copyright 2025, MetaQuotes Ltd. |
//|                          https://www.mql5.com/en/users/chachaian |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com/en/users/chachaian"
#property version   "1.00"

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
  
   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int32_t  rates_total,
                const int32_t  prev_calculated,
                const datetime &time       [],
                const double   &open       [],
                const double   &high       [],
                const double   &low        [],
                const double   &close      [],
                const long     &tick_volume[],
                const long     &volume     [],
                const int32_t  &spread     []) 
{
     
   return(rates_total);
}
//+------------------------------------------------------------------+

Vamos dividir o código em partes lógicas simples para facilitar a compreensão.

Diretivas de propriedades:

...
#property copyright "Copyright 2025, MetaQuotes Ltd. Developer is Chacha Ian"
#property link      "https://www.mql5.com/en/users/chachaian"
#property version   "1.00"

...

Essas linhas definem os metadados do indicador, que serão exibidos no Navegador do MetaTrader 5 e na janela de descrição.

  • #property copyright. Identifica o detentor dos direitos autorais e o desenvolvedor. É útil para reforçar a identidade do projeto e indicar a autoria do código.
  • #property link. Define um link clicável para o arquivo ou a página do projeto.
  • #property version. Facilita o controle de versões em futuras atualizações.
Função de inicialização:

...

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
   return(INIT_SUCCEEDED);
}

...

A função de inicialização (OnInit()) é chamada quando o indicador é adicionado inicialmente ao gráfico. Ela é responsável pelas tarefas de configuração e preparação do indicador. Ao retornar INIT_SUCCEEDED, a função informa ao MetaTrader 5 que a inicialização foi concluída com sucesso. Nas próximas etapas, utilizaremos OnInit() para registrar os buffers do indicador e definir as propriedades visuais das nossas plotagens.

Função de cálculo:

...

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int32_t  rates_total,
                const int32_t  prev_calculated,
                const datetime &time[],
                const double   &open[],
                const double   &high[],
                const double   &low[],
                const double   &close[],
                const long     &tick_volume[],
                const long     &volume[],
                const int32_t  &spread[]) 
{

   return(rates_total);
}

...

Essa é a função central do indicador. Ela é chamada repetidamente à medida que novas velas são formadas. Seus parâmetros fornecem acesso aos seguintes dados:

  • Rates_total. Indica o número total de barras disponíveis.
  • Prev_calculated. Indica quantas barras foram processadas na chamada anterior da função OnCalculate, permitindo otimizar os cálculos.
  • Os arrays time, open, high, low e close, que fornecem os dados históricos de tempo e preços.
  • Volume, tick_volume e spread, que fornecem dados adicionais de negociação.

É importante destacar que a função OnCalculate é chamada automaticamente sempre que novos dados de ticks chegam ou quando o histórico de preços é atualizado. Isso também ocorre, por exemplo, quando uma lacuna nos dados históricos é preenchida. É nessa função que implementaremos a maior parte da lógica do nosso indicador.

No MetaTrader 5, os indicadores podem ser exibidos de duas maneiras principais: na janela principal do gráfico, sobre os preços, ou em uma subjanela separada, abaixo do gráfico principal.

Para definir onde o indicador será exibido, utilizamos a diretiva #property indicator_chart_window quando queremos apresentá-lo na janela principal, sobre os preços, ou #property indicator_separate_window para indicadores exibidos em uma subjanela separada. Como estamos desenvolvendo um indicador que será exibido diretamente sobre os preços na janela principal do gráfico, utilizaremos a primeira opção.

Portanto, vamos adicionar a seguinte linha logo abaixo das diretivas #property existentes:

#property copyright "Copyright 2025, MetaQuotes Ltd. Developer is Chacha Ian"
#property link      "https://www.mql5.com/en/users/chachaian"
#property version   "1.00"
#property indicator_chart_window

...

Em MQL5, os indicadores personalizados geralmente armazenam os valores calculados em arrays dinâmicos específicos, chamados buffers de indicador. Esses buffers são registrados por meio da função nativa SetIndexBuffer() do MQL5 e são essenciais para representar os dados visualmente no gráfico, seja por meio de linhas, histogramas, setas ou outros elementos gráficos.

Antes de utilizá-los no código-fonte, precisamos especificar quantos buffers o indicador terá. Para isso, usamos a diretiva #property indicator_buffers N, em que N representa o número total de buffers necessários. No nosso caso, utilizaremos cinco buffers, portanto, faremos a seguinte declaração: #property indicator_buffers 5.

Vamos adicionar essa linha logo abaixo das demais diretivas existentes no nosso código-fonte.

...

#property indicator_chart_window
#property indicator_buffers 5
...

Os indicadores geralmente utilizam plotagens para representar visualmente seus cálculos no gráfico. Esses elementos gráficos, como linhas, histogramas ou setas, também são chamados de plotagens e ajudam os traders a interpretar rapidamente as informações apresentadas pelo indicador.

O número de plotagens que o indicador exibirá é definido pela diretiva #property indicator_plots P, em que P representa a quantidade de plotagens do indicador. No nosso caso, utilizaremos apenas uma plotagem.

Vamos adicionar a seguinte linha de código logo abaixo das demais diretivas #property existentes.

...
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_plots   1
...

Em seguida, declararemos os arrays que serão utilizados como buffers do indicador. Normalmente, essa declaração é feita no escopo global. O tipo de dados desses arrays é quase sempre double, pois os valores dos indicadores geralmente são números de ponto flutuante. Vamos declará-los agora, logo antes da função OnInit(), para que fiquem acessíveis em todo o código do indicador.

...
#property indicator_plots   1

//Global variables
double haOpen [];
double haHigh [];
double haLow  [];
double haClose[];
double colorBuffer [];
...

Com os arrays declarados, o próximo passo é registrar cada um deles como um buffer do indicador utilizando a função nativa SetIndexBuffer() do MQL5. Essa função associa os arrays declarados ao sistema de indicadores do MetaTrader, permitindo que sejam utilizados na representação gráfica e nos cálculos. Faremos esse registro dentro da função OnInit(), associando cada array ao seu respectivo buffer.

...

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
   
   // Registration of indicator buffers
   if(!SetIndexBuffer(0, haOpen, INDICATOR_DATA)){
      Print("Error while registering an indicator buffer: ", GetLastError());
      return INIT_FAILED;
   }
   
   if(!SetIndexBuffer(1, haHigh, INDICATOR_DATA)){
      Print("Error while registering an indicator buffer: ", GetLastError());
      return INIT_FAILED;
   }
   
   if(!SetIndexBuffer(2, haLow,   INDICATOR_DATA)){
      Print("Error while registering an indicator buffer: ", GetLastError());
      return INIT_FAILED;
   }
   
   if(!SetIndexBuffer(3, haClose, INDICATOR_DATA)){
      Print("Error while registering an indicator buffer: ", GetLastError());
      return INIT_FAILED;
   }
   
   if(!SetIndexBuffer(4, colorBuffer, INDICATOR_COLOR_INDEX)){
      Print("Error while registering an indicator buffer: ", GetLastError());
      return INIT_FAILED;
   }
   
}

...

Agora, vamos implementar a lógica principal do indicador na função OnCalculate(). Essa função é chamada sempre que o indicador precisa ser atualizado: quando é adicionado ao gráfico pela primeira vez, quando uma nova vela é formada ou quando chega um novo tick de preço.

Normalmente, dividimos essa função em três blocos condicionais principais para tratar cada uma dessas situações de maneira eficiente:

  1. Quando o indicador é adicionado ao gráfico pela primeira vez, a condição prev_calculated == 0 é atendida. Esse bloco é utilizado para executar a lógica de inicialização, como preencher os valores históricos ou definir as condições iniciais.
  2. Quando uma nova vela é aberta, a condição prev_calculated != rates_total e prev_calculated != 0 é atendida. Nesse bloco, podemos executar a lógica que deve ser acionada apenas uma vez por nova barra, evitando cálculos repetidos desnecessariamente.
  3. Quando um novo tick de preço chega durante a formação da barra atual, a condição prev_calculated == rates_total é atendida. Nesse bloco, atualizamos os valores da vela atual em tempo real, utilizando os dados de preços mais recentes.

A seguir, apresentamos a estrutura básica que incluiremos na função OnCalculate():

...

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int32_t  rates_total,
                const int32_t  prev_calculated,
                const datetime &time[],
                const double   &open[],
                const double   &high[],
                const double   &low[],
                const double   &close[],
                const long     &tick_volume[],
                const long     &volume[],
                const int32_t  &spread[]) 
{
   // This block is executed when the indicator is initially attached on a chart
   if(prev_calculated == 0){
   }
   
   // This block is executed on every new bar open
   if(prev_calculated != rates_total && prev_calculated != 0){
   }
   
   // This block is executed on arrival of new price (tick) data
   if(prev_calculated == rates_total){
   }
   
   return(rates_total);
}

...

Em seguida, definiremos a paleta de cores das nossas velas Heikin Ashi utilizando a diretiva #property indicator_color1. Essa diretiva permite especificar as cores padrão da plotagem que definimos anteriormente. Para nosso indicador, utilizaremos três cores:

  1. clrDarkGreen para as velas Heikin Ashi de alta.
  2. clrDarkRed para as velas Heikin Ashi de baixa.
  3. clrYellow para as velas neutras.

Adicionaremos essa configuração de cores logo abaixo das demais diretivas #property, para que seja aplicada durante a inicialização do indicador. A seguir, apresentamos a linha de código que deve ser adicionada:

...
#property indicator_plots   1
#property indicator_color1 clrDarkGreen, clrDarkRed, clrYellow
...

Agora, vamos adicionar uma diretiva para definir nomes descritivos para cada buffer do indicador. Isso ajuda os usuários a identificar o significado de cada linha ao consultar as informações na Janela de Dados do MetaTrader. Adicione a seguinte linha de código logo abaixo das diretivas #property existentes:

...
#property indicator_color1 clrDarkGreen, clrDarkRed, clrYellow
#property indicator_label1 "HeikinAshiOpen;HeikinAshiHigh;HeikinAshiLow;HeikinAshiClose"
...

Antes de implementar toda a lógica no manipulador de eventos OnCalculate, vamos definir algumas funções auxiliares responsáveis pelos cálculos do Heikin Ashi e pela interpretação visual dos resultados. Essas funções terão três responsabilidades principais:

  • Calcular os valores Heikin Ashi (OHLC) a partir dos dados convencionais de preços.
  • Determinar a direção visual (cor) de cada vela Heikin Ashi.
  • Separar o processamento completo dos dados históricos das atualizações em tempo real para melhorar a eficiência.

Agora, vamos adicionar essas funções logo abaixo da função OnCalculate(). Depois, vamos chamá-las a partir de OnCalculate conforme necessário, seguindo cada etapa da implementação.

...

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int32_t  rates_total,
                const int32_t  prev_calculated,
                const datetime &time       [],
                const double   &open       [],
                const double   &high       [],
                const double   &low        [],
                const double   &close      [],
                const long     &tick_volume[],
                const long     &volume     [],
                const int32_t  &spread     []) 
{
   ...
    
   return(rates_total);
}

// Utility functions

//+----------------------------------------------------------------------------------+
//| Calculates Heikin Ashi values for all historical candles using price data arrays.|
//+----------------------------------------------------------------------------------+
void GetHeikinAshiValues(const double &open[], const double &high[], const double &low[], const double &close[], const int32_t rates_total)
{ 

   if(ArraySize(open) < rates_total){
      return;
   }
    
   // Run a loop through all historical bars
   for(int i=0; i<rates_total; i++){      
      if(i == 0){
         haOpen [i] = (open[i] + close[i]) / 2.0;
         haClose[i] = (open[i] + high[i] + low[i] + close[i]) / 4.0;
         haHigh [i] = MathMax(high[i], MathMax(open[i], close[i]));
         haLow  [i] = MathMin(low [i], MathMin(open[i], close[i]));
      }else{
         haOpen [i] = (haOpen[i-1] + haClose[i-1]) / 2.0;
         haClose[i] = (open[i] + high[i] + low[i] + close[i]) / 4.0;
         haHigh [i] = MathMax(high[i], MathMax(haOpen[i], haClose[i]));
         haLow  [i] = MathMin(low [i], MathMin(haOpen[i], haClose[i]));  
      }
   }
   
}


//+---------------------------------------------------------------------------------------+
//| Calculates Heikin Ashi values for the most recent candle only (for real-time updates).|
//+---------------------------------------------------------------------------------------+
void GetCurrentHeikinAshiValue(const double &open[], const double &high[], const double &low[], const double &close[], const int32_t rates_total)
{
   haOpen [rates_total - 1] = (haOpen[rates_total-2] + haClose[rates_total-2]) / 2.0;
   haClose[rates_total - 1] = (open[rates_total - 1] + high[rates_total - 1] + low[rates_total - 1] + close[rates_total - 1]) / 4.0;
   haHigh [rates_total - 1] = MathMax(high[rates_total - 1], MathMax(haOpen[rates_total - 1], haClose[rates_total - 1]));
   haLow  [rates_total - 1] = MathMin(low [rates_total - 1], MathMin(haOpen[rates_total - 1], haClose[rates_total - 1])); 
}


//+------------------------------------------------------------------------------------------------------------------+
//| Assigns a color code to each historical Heikin Ashi candle based on its direction (bullish, bearish, or neutral).|
//+------------------------------------------------------------------------------------------------------------------+
void GetHeikinAshiColors(const int32_t rates_total){
   
   for(int i=0; i<rates_total; i++){
      if(haOpen[i] < haClose[i]){
         colorBuffer[i] = 0;
      }
      
      else if(haOpen[i] > haClose[i]){
         colorBuffer[i] = 1;
      }
      
      else {
         colorBuffer[i] = 2;
      }
   }
   
}

//+-----------------------------------------------------------------------------------------------+
//| Assigns a color code to the latest Heikin Ashi candle only (used for real-time color updates).|
//+-----------------------------------------------------------------------------------------------+
void GetCurrentHeikinAshiColor(const int32_t rates_total){
      if(haOpen[rates_total - 1] < haClose[rates_total - 1]){
         colorBuffer[rates_total - 1] = 0;
      }
      
      else if(haOpen[rates_total - 1] > haClose[rates_total - 1]){
         colorBuffer[rates_total - 1] = 1;
      }
      
      else {
         colorBuffer[rates_total - 1] = 2;
      }
}

...

Em seguida, chamaremos a função GetHeikinAshiValues() dentro do manipulador de eventos OnCalculate(), especificamente nas seguintes condições:

  • Quando prev_calculated == 0, indicando que o indicador está sendo carregado pela primeira vez e precisamos processar todas as velas históricas.
  • Quando prev_calculated != rates_total e prev_calculated != 0, indicando que novas barras foram adicionadas ou que o gráfico foi atualizado, sendo necessário recalcular os dados a partir do ponto em que o processamento anterior terminou.

Essa função calcula toda a série de velas Heikin Ashi, obtendo os valores de abertura, máxima, mínima e fechamento a partir dos arrays convencionais de preços. Ela garante o preenchimento correto dos buffers desde a inicialização e sua atualização adequada quando novos dados ficam disponíveis.

...

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int32_t  rates_total,
                const int32_t  prev_calculated,
                const datetime &time       [],
                const double   &open       [],
                const double   &high       [],
                const double   &low        [],
                const double   &close      [],
                const long     &tick_volume[],
                const long     &volume     [],
                const int32_t  &spread     []) 
{
   // This block is executed when the indicator is initially attached on a chart
   if(prev_calculated == 0){
      GetHeikinAshiValues(open, high, low, close, rates_total);
   }
   
   // This block is executed on every new bar open
   if(prev_calculated != rates_total && prev_calculated != 0){
      GetHeikinAshiValues(open, high, low, close, rates_total);
   }
   
   // This block is executed on arrival of new price (tick) data
   if(prev_calculated == rates_total){
   }
   
   return(rates_total);
}

...

Em seguida, chamaremos a função GetHeikinAshiColors() nos mesmos blocos condicionais de OnCalculate(). Ou seja:

  • Quando prev_calculated == 0, para atribuir cores a todas as velas históricas durante o carregamento inicial.
  • Quando prev_calculated != rates_total e prev_calculated != 0, para atualizar as cores das velas correspondentes ao conjunto de dados modificado.

Essa função atribui um código numérico de cor a cada vela Heikin Ashi com base na relação entre seus preços de abertura e fechamento:

  • 0 para velas de alta.
  • 1 para velas de baixa.
  • 2 para velas neutras.

Posteriormente, esses códigos serão associados às cores efetivamente exibidas no gráfico, permitindo distinguir visualmente os movimentos de alta, de baixa e neutros na representação final do indicador.

...

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int32_t  rates_total,
                const int32_t  prev_calculated,
                const datetime &time       [],
                const double   &open       [],
                const double   &high       [],
                const double   &low        [],
                const double   &close      [],
                const long     &tick_volume[],
                const long     &volume     [],
                const int32_t  &spread     []) 
{
   // This block is executed when the indicator is initially attached on a chart
   if(prev_calculated == 0){
      ...
      GetHeikinAshiColors(rates_total);
   }
   
   // This block is executed on every new bar open
   if(prev_calculated != rates_total && prev_calculated != 0){
      ...
      GetHeikinAshiColors(rates_total);
   }
   
   // This block is executed on arrival of new price (tick) data
   if(prev_calculated == rates_total){
   }
   
   return(rates_total);
}

...

Por fim, chamaremos as funções GetCurrentHeikinAshiValue() e GetCurrentHeikinAshiColor() dentro do bloco if(prev_calculated == rates_total){}. Esse bloco é executado quando o indicador recebe atualizações em tempo real, ou seja, quando chega um novo tick, mas uma nova vela ainda não foi formada.

Ao chamar:

  • GetCurrentHeikinAshiValue(), recalculamos os valores Heikin Ashi mais recentes da vela atual com base nos últimos dados de ticks.
  • GetCurrentHeikinAshiColor(), atribuímos imediatamente o código de cor correspondente à vela Heikin Ashi atual.

Essa estrutura mantém o indicador responsivo às atualizações do mercado e garante que a última vela do gráfico reflita corretamente os dados disponíveis, mesmo enquanto ainda está sendo formada.

...

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int32_t  rates_total,
                const int32_t  prev_calculated,
                const datetime &time       [],
                const double   &open       [],
                const double   &high       [],
                const double   &low        [],
                const double   &close      [],
                const long     &tick_volume[],
                const long     &volume     [],
                const int32_t  &spread     []) 
{
   ...  
   
   // This block is executed on arrival of new price (tick) data
   if(prev_calculated == rates_total){
      GetCurrentHeikinAshiValue(open, high, low, close, rates_total);
      GetCurrentHeikinAshiColor(rates_total);
   }
   
   
   return(rates_total);
}

...

Agora, vamos configurar nossa plotagem utilizando a função PlotIndexSetInteger(), para que o indicador Heikin Ashi seja exibido corretamente ao ser iniciado. Definiremos cada configuração separadamente, especificando como os dados dos nossos buffers serão representados no gráfico, incluindo o tipo de plotagem.

Essas configurações são necessárias para que o terminal MetaTrader 5 saiba como representar graficamente os valores calculados. Após concluirmos essa etapa, o indicador Heikin Ashi estará pronto para ser exibido sobre o gráfico quando for aplicado. Vamos examinar cada configuração. Primeiro, utilizaremos a função PlotIndexSetInteger() para definir o tipo de plotagem. Essa instrução informa ao MetaTrader que nossa plotagem deve utilizar velas coloridas. Vamos adicioná-la logo abaixo das chamadas de SetIndexBuffer(), dentro do manipulador de eventos OnInit(). Se a configuração falhar, uma mensagem de erro será registrada no Diário dos Experts para facilitar a depuração.

...

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
   ...
  
   if(!SetIndexBuffer(4, colorBuffer, INDICATOR_COLOR_INDEX)){
      Print("Error while registering an indicator buffer: ", GetLastError());
      return INIT_FAILED;
   }
   
   // Configuration of Graphic Plots
   if(!PlotIndexSetInteger(0, PLOT_DRAW_TYPE, DRAW_COLOR_CANDLES)){
      Print("Error while configuring graphic plots: ", GetLastError());
      return INIT_FAILED;
   }
   
}

...

Agora, vamos garantir que os dados do Heikin Ashi sejam exibidos na Janela de Dados quando o usuário posicionar o cursor sobre o gráfico. Para isso, utilizaremos PlotIndexSetInteger() com a propriedade PLOT_SHOW_DATA definida como true. Essa instrução também deve ser adicionada dentro da função OnInit(), logo após a anterior. Caso a configuração falhe, uma mensagem de erro será exibida.

...

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
   ...
   
   // Configuration of Graphic Plots
   if(!PlotIndexSetInteger(0, PLOT_DRAW_TYPE, DRAW_COLOR_CANDLES)){
      Print("Error while configuring graphic plots: ", GetLastError());
      return INIT_FAILED;
   }
   
   if(!PlotIndexSetInteger(0, PLOT_SHOW_DATA, true)){
      Print("Error while configuring graphic plots: ", GetLastError());
      return INIT_FAILED;
   }
   
}

...

Em seguida, configuraremos algumas propriedades gerais do indicador. A primeira define o número de casas decimais (digits) dos valores do indicador, utilizando IndicatorSetInteger() com a propriedade INDICATOR_DIGITS. Isso ajuda a manter a precisão dos valores exibidos compatível com a precisão do símbolo negociado. Se ocorrer algum problema, exibiremos uma mensagem de erro para facilitar a depuração.

Vamos adicionar as seguintes linhas de código abaixo das chamadas de PlotIndexSetInteger(), na função OnInit().

...

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
   ...
   
   if(!PlotIndexSetInteger(0, PLOT_SHOW_DATA, true)){
      Print("Error while configuring graphic plots: ", GetLastError());
      return INIT_FAILED;
   }
   
   // Configure Indicator
   if(!IndicatorSetInteger(INDICATOR_DIGITS, Digits())){
      Print("Error while setting indicator values accuracy: ", GetLastError());
      return INIT_FAILED;
   }
   
}

...

Em seguida, definiremos um nome curto para o indicador utilizando IndicatorSetString(). Esse nome, "HeikinAshi,", será exibido na Janela de Dados e no gráfico, facilitando a identificação do indicador pelos usuários. Se não for possível definir o nome, exibiremos uma mensagem de erro para identificar a causa do problema.

...

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{
   ...
   
   // Configure Indicator
   if(!IndicatorSetInteger(INDICATOR_DIGITS, Digits())){
      Print("Error while setting indicator values accuracy: ", GetLastError());
      return INIT_FAILED;
   }
   
   if(!IndicatorSetString(INDICATOR_SHORTNAME, "HeikinAshi")){
      Print("Error while setting indicator shortname: ", GetLastError());
      return INIT_FAILED;
   }
   
   return INIT_SUCCEEDED;
   
}

...

Neste ponto, já implementamos todos os componentes principais do nosso indicador Heikin Ashi personalizado. Agora, clique no botão Compile do MetaEditor. Se todas as etapas tiverem sido executadas corretamente, o indicador deverá ser compilado sem erros e estará pronto para ser utilizado no gráfico. O código-fonte completo deverá apresentar a estrutura mostrada a seguir. Caso encontre algum problema ou receba erros de compilação, compare seu código com a versão abaixo para identificar e corrigir as diferenças.

//+------------------------------------------------------------------+
//|                                          heikinAshiIndicator.mq5 |
//|                                  Copyright 2025, MetaQuotes Ltd. |
//|                          https://www.mql5.com/en/users/chachaian |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com/en/users/chachaian"
#property version   "1.00"
#property indicator_chart_window
#property indicator_buffers 5
#property indicator_plots   1
#property indicator_color1 C'38,166,154', C'239,83,80', clrYellow
#property indicator_label1 "HeikinAshiOpen;HeikinAshiHigh;HeikinAshiLow;HeikinAshiClose"

//Global variables
double haOpen      [];
double haHigh      [];
double haLow       [];
double haClose     [];
double colorBuffer [];

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{  
   //--- Registration of indicator buffers
   if(!SetIndexBuffer(0, haOpen, INDICATOR_DATA)){
      Print("Error while registering an indicator buffer: ", GetLastError());
      return INIT_FAILED;
   }
   
   if(!SetIndexBuffer(1, haHigh, INDICATOR_DATA)){
      Print("Error while registering an indicator buffer: ", GetLastError());
      return INIT_FAILED;
   }
   
   if(!SetIndexBuffer(2, haLow,   INDICATOR_DATA)){
      Print("Error while registering an indicator buffer: ", GetLastError());
      return INIT_FAILED;
   }
   
   if(!SetIndexBuffer(3, haClose, INDICATOR_DATA)){
      Print("Error while registering an indicator buffer: ", GetLastError());
      return INIT_FAILED;
   }
   
   if(!SetIndexBuffer(4, colorBuffer, INDICATOR_COLOR_INDEX)){
      Print("Error while registering an indicator buffer: ", GetLastError());
      return INIT_FAILED;
   }
   
   //--- Configuration of graphic plots
   if(!PlotIndexSetInteger(0, PLOT_DRAW_TYPE, DRAW_COLOR_CANDLES)){
      Print("Error while configuring graphic plots: ", GetLastError());
      return INIT_FAILED;
   }
   
   if(!PlotIndexSetInteger(0, PLOT_SHOW_DATA, true)){
      Print("Error while configuring graphic plots: ", GetLastError());
      return INIT_FAILED;
   }
   
   //--- General indicator configurations
   if(!IndicatorSetInteger(INDICATOR_DIGITS, Digits())){
      Print("Error while setting indicator values accuracy: ", GetLastError());
      return INIT_FAILED;
   }
   
   if(!IndicatorSetString(INDICATOR_SHORTNAME, "HeikinAshi")){
      Print("Error while setting indicator shortname: ", GetLastError());
      return INIT_FAILED;
   }
   
   return INIT_SUCCEEDED;
}

//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int32_t  rates_total,
                const int32_t  prev_calculated,
                const datetime &time       [],
                const double   &open       [],
                const double   &high       [],
                const double   &low        [],
                const double   &close      [],
                const long     &tick_volume[],
                const long     &volume     [],
                const int32_t  &spread     []) 
{
   //--- This block is executed when the indicator is initially attached on a chart
   if(prev_calculated == 0){
      GetHeikinAshiValues(open, high, low, close, rates_total);
      GetHeikinAshiColors(rates_total);
   }
   
   //--- This block is executed on every new bar open
   if(prev_calculated != rates_total && prev_calculated != 0){
      GetHeikinAshiValues(open, high, low, close, rates_total);
      GetHeikinAshiColors(rates_total);
   }
   
   //--- This block is executed on arrival of new price (tick) data
   if(prev_calculated == rates_total){
      GetCurrentHeikinAshiValue(open, high, low, close, rates_total);
      GetCurrentHeikinAshiColor(rates_total);
   }
   
   return(rates_total);
}

//--- Utility functions
//+----------------------------------------------------------------------------------+
//| Calculates Heikin Ashi values for all historical candles using price data arrays.|
//+----------------------------------------------------------------------------------+
void GetHeikinAshiValues(const double &open[], const double &high[], const double &low[], const double &close[], const int32_t rates_total)
{ 

   if(ArraySize(open) < rates_total){
      return;
   }
    
   //--- Run a loop through all historical bars
   for(int i=0; i<rates_total; i++){      
      if(i == 0){
         haOpen [i] = (open[i] + close[i]) / 2.0;
         haClose[i] = (open[i] + high[i] + low[i] + close[i]) / 4.0;
         haHigh [i] = MathMax(high[i], MathMax(open[i], close[i]));
         haLow  [i] = MathMin(low [i], MathMin(open[i], close[i]));
      }else{
         haOpen [i] = (haOpen[i-1] + haClose[i-1]) / 2.0;
         haClose[i] = (open[i] + high[i] + low[i] + close[i]) / 4.0;
         haHigh [i] = MathMax(high[i], MathMax(haOpen[i], haClose[i]));
         haLow  [i] = MathMin(low [i], MathMin(haOpen[i], haClose[i]));  
      }
   }
   
}

//+---------------------------------------------------------------------------------------+
//| Calculates Heikin Ashi values for the most recent candle only (for real-time updates).|
//+---------------------------------------------------------------------------------------+
void GetCurrentHeikinAshiValue(const double &open[], const double &high[], const double &low[], const double &close[], const int32_t rates_total)
{
   haOpen [rates_total - 1] = (haOpen[rates_total-2] + haClose[rates_total-2]) / 2.0;
   haClose[rates_total - 1] = (open[rates_total - 1] + high[rates_total - 1] + low[rates_total - 1] + close[rates_total - 1]) / 4.0;
   haHigh [rates_total - 1] = MathMax(high[rates_total - 1], MathMax(haOpen[rates_total - 1], haClose[rates_total - 1]));
   haLow  [rates_total - 1] = MathMin(low [rates_total - 1], MathMin(haOpen[rates_total - 1], haClose[rates_total - 1])); 
}


//+------------------------------------------------------------------------------------------------------------------+
//| Assigns a color code to each historical Heikin Ashi candle based on its direction (bullish, bearish, or neutral).|
//+------------------------------------------------------------------------------------------------------------------+
void GetHeikinAshiColors(const int32_t rates_total)
{
   
   for(int i=0; i<rates_total; i++){
      if(haOpen[i] < haClose[i]){
         colorBuffer[i] = 0;
      }
      
      if(haOpen[i] > haClose[i]){
         colorBuffer[i] = 1;
      }
      
      if(haOpen[i] == haClose[i]){
         colorBuffer[i] = 2;
      }
   }
   
}

//+-----------------------------------------------------------------------------------------------+
//| Assigns a color code to the latest Heikin Ashi candle only (used for real-time color updates).|
//+-----------------------------------------------------------------------------------------------+
void GetCurrentHeikinAshiColor(const int32_t rates_total)
{
      if(haOpen[rates_total - 1] < haClose[rates_total - 1]){
         colorBuffer[rates_total - 1] = 0;
      }
      
      else if(haOpen[rates_total - 1] > haClose[rates_total - 1]){
         colorBuffer[rates_total - 1] = 1;
      }
      
      else {
         colorBuffer[rates_total - 1] = 2;
      }
}
//+------------------------------------------------------------------+


Testes e ajustes visuais

Antes de começar a testar visualmente o indicador Heikin Ashi, vale a pena ajustar a aparência do gráfico para facilitar a visualização. Para isso, criaremos uma pequena função que configura o fundo, a grade e as cores do gráfico, proporcionando uma apresentação mais limpa e destacando as velas. Veja o código:

...

//+-----------------------------------------------------------------------------------------------+
//| Assigns a color code to the latest Heikin Ashi candle only (used for real-time color updates).|
//+-----------------------------------------------------------------------------------------------+ 
void GetCurrentHeikinAshiColor(const int32_t rates_total){
      if(haOpen[rates_total - 1] < haClose[rates_total - 1]){
         colorBuffer[rates_total - 1] = 0;
      }
      
      else if(haOpen[rates_total - 1] > haClose[rates_total - 1]){
         colorBuffer[rates_total - 1] = 1;
      }
      
      else {
         colorBuffer[rates_total - 1] = 2;
      }
}

//+-------------------------------------------------+
//| This function configures the chart's appearance.|
//+-------------------------------------------------+
bool ConfigureChartAppearance()
{
   if(!ChartSetInteger(0, CHART_COLOR_BACKGROUND, clrWhite)){
      Print("Error while setting chart background, ", GetLastError());
      return false;
   }
   
   if(!ChartSetInteger(0, CHART_SHOW_GRID, false)){
      Print("Error while setting chart grid, ", GetLastError());
      return false;
   }
   
   if(!ChartSetInteger(0, CHART_MODE, CHART_LINE)){
      Print("Error while setting chart mode, ", GetLastError());
      return false;
   }

   if(!ChartSetInteger(0, CHART_COLOR_FOREGROUND, clrBlack)){
      Print("Error while setting chart foreground, ", GetLastError());
      return false;
   }
   
   return true;
}

Pense nessa função como um estilista pessoal para o seu gráfico. Ela realiza os seguintes ajustes:

  • Define o fundo como branco para facilitar a visualização.
  • Remove a grade para deixar o gráfico mais limpo.
  • Altera o tipo de gráfico para linha, evitando interferências na visualização das velas personalizadas.
  • Define a cor do primeiro plano como preto para garantir um bom contraste.

Se alguma dessas configurações falhar, uma mensagem de erro será exibida no terminal para facilitar a depuração. Agora, vamos chamar a função ConfigureChartAppearance() dentro do manipulador de eventos OnInit(), para que a aparência do gráfico seja configurada automaticamente quando o indicador for carregado. Veja como fazer isso:

...

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
{

   if(!ConfigureChartAppearance()){
      Print("Error while configuring chart appearance: ", GetLastError());
      return INIT_FAILED;
   }
   
   // Registration of indicator buffers
   if(!SetIndexBuffer(0, haOpen, INDICATOR_DATA)){
      Print("Error while registering an indicator buffer: ", GetLastError());
      return INIT_FAILED;
   }
      
   ...
   
}

...

Concluímos o desenvolvimento do nosso indicador Heikin Ashi personalizado. Tudo está pronto, desde o cálculo das velas Heikin Ashi até sua representação no gráfico, com uma aparência visual cuidadosamente configurada. Agora, vamos adicionar o indicador ao gráfico e conferir seu funcionamento na prática.

gráfico do ouro no H1

Adicionamos nosso indicador Heikin Ashi personalizado ao gráfico do ouro no timeframe H1, e ele está funcionando perfeitamente. Todos os elementos são exibidos conforme o esperado, confirmando que o código está funcionando corretamente e que o gráfico está pronto para novos ajustes visuais e testes.


Conclusão

Nesta parte, desenvolvemos com sucesso um indicador Heikin Ashi personalizado e totalmente funcional em MQL5. Percorremos todas as etapas, desde a configuração dos buffers e o cálculo dos valores até os ajustes visuais do gráfico. Em seguida, adicionamos o indicador ao gráfico do ouro no timeframe H1 e confirmamos que tudo funciona conforme o esperado. Para facilitar o acompanhamento deste tutorial e a identificação de possíveis problemas, disponibilizamos tanto o código-fonte completo quanto a versão compilada do indicador.

Na próxima parte desta série, avançaremos para o desenvolvimento de um EA que utilizará nosso indicador Heikin Ashi para tomar decisões de negociação. Acompanhe a continuação.

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

Arquivos anexados |
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.
Superando as limitações do aprendizado de máquina (Parte 3): Uma nova perspectiva sobre o erro irredutível Superando as limitações do aprendizado de máquina (Parte 3): Uma nova perspectiva sobre o erro irredutível
Neste artigo, examinaremos sob uma nova perspectiva uma fonte oculta de erro, de natureza geométrica, que influencia silenciosamente cada previsão gerada pelos seus modelos. Ao repensar a forma como avaliamos e utilizamos as previsões de aprendizado de máquina no trading, mostraremos como essa perspectiva frequentemente negligenciada pode contribuir para decisões mais fundamentadas, melhores retornos e uma forma mais criteriosa de trabalhar com modelos que acreditávamos já compreender.
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 ferramentas para análise de Price Action (Parte 38): VWAP baseada em buffer de ticks e módulo de cálculo de desequilíbrio em janela curta Desenvolvimento de ferramentas para análise de Price Action (Parte 38): VWAP baseada em buffer de ticks e módulo de cálculo de desequilíbrio em janela curta
Na Parte 38, desenvolvemos para o MT5 um painel de monitoramento de nível industrial que transforma dados brutos de ticks em sinais práticos de negociação. O EA acumula dados de ticks para calcular a VWAP baseada em ticks (Volume Weighted Average Price, preço médio ponderado pelo volume), uma métrica de desequilíbrio em janela curta (indicador de fluxo Flow) e o tamanho da posição com base no ATR. Em seguida, apresenta o spread, o ATR e o indicador de fluxo por meio de barras, com o mínimo de cintilação. O sistema calcula o tamanho de lote recomendado e o nível de stop correspondente a 1R de risco, além de emitir alertas configuráveis para spreads reduzidos, fluxo intenso e condições que oferecem vantagem nas operações. A negociação automática foi intencionalmente desativada, pois o foco está na geração confiável de sinais e na facilidade de uso.