Desenvolvimento do Kit de Ferramentas de Análise de Price Action (Parte 11): EA de Sinal Heikin Ashi

Introdução

As fórmulas matemáticas servem como um pilar fundamental na análise de price action, fornecendo um método objetivo para decodificar dados de mercado e orientar decisões de negociação. No mercado forex sul-africano, por exemplo, um trader que avalia o par ZAR/USD pode usar uma Média Móvel Simples de 50 dias para detectar reversões de tendência, enquanto aplica o desvio padrão para medir a volatilidade do mercado, confirmando assim possíveis rompimentos. A incorporação de fórmulas para dimensionamento de posição e gerenciamento de risco, como o cálculo do tamanho da negociação com base em uma porcentagem de risco definida e na distância do stop-loss, permite que o trader gerencie o risco de forma eficaz e estabeleça metas claras de lucro por meio de ferramentas como retrações de Fibonacci.

Neste artigo, temos o prazer de apresentar a técnica Heikin Ashi para cálculos de reversão de tendência, adicionando mais uma camada à nossa estratégia integrada que combina análise quantitativa com métodos clássicos de price action. Uma vantagem significativa do Heikin Ashi é sua capacidade de filtrar o ruído do mercado, permitindo que os traders se concentrem na tendência subjacente sem serem distraídos por pequenas flutuações de preço. Essa abordagem suaviza as flutuações do mercado e garante que as decisões sejam orientadas por dados, fornecendo uma estrutura disciplinada aplicável a diversos mercados financeiros em todo o mundo.

Começaremos definindo o Heikin Ashi e explorando suas origens. Em seguida, sem desvios desnecessários, iremos direto à estratégia para que você possa entender exatamente como ela funciona. Também examinaremos outras funções principais, forneceremos o código completo e, por fim, revisaremos os resultados antes de encerrar o artigo. Agora, vamos dar uma olhada no sumário.

• Heikin Ashi
• Estratégia
• Outras Funções
• Código MQL5
• Resultados
• Conclusão

Heikin Ashi

A técnica Heikin Ashi foi desenvolvida por Munehisa Homma, um comerciante japonês de arroz do século XVIII, que também é creditado como pioneiro dos gráficos de candlestick, uma ferramenta fundamental na análise técnica. Originado no Japão, o Heikin Ashi foi projetado para ajudar os traders a obter uma perspectiva mais clara das tendências de mercado, concentrando-se no movimento médio de preços em vez de formações individuais de candlesticks. Em japonês, Heikin significa “média” ou “equilíbrio”, enquanto Ashi se traduz como “barra” ou “candlestick”. Essa denominação reflete o princípio central dos gráficos Heikin Ashi — suavizar os dados de preço para fornecer uma visão mais equilibrada e menos volátil dos movimentos do mercado. Vamos observar o diagrama abaixo, que ilustra como um gráfico de candlesticks tradicional é transformado em um gráfico Heikin Ashi mais suave.

Fig 1. Gráfico Suavizado

A tabela abaixo compara Candlesticks Tradicionais e Candlesticks Heikin Ashi, destacando suas principais diferenças.

Recurso	Candlesticks Tradicionais	Candlesticks Heikin Ashi
Base de Cálculo	Usa preços reais de abertura, máxima, mínima e fechamento.	Usa uma fórmula modificada que calcula a média dos dados de preço.
Exibição de Volatilidade	Mostra flutuações reais de preço e gaps.	Suaviza o price action, reduzindo o ruído.
Clareza da Tendência	Pode ser irregular, com alternância de velas vermelhas e verdes mesmo em tendências.	Fornece tendências mais suaves com menos mudanças de cor.
Visibilidade de Gaps	Mostra gaps de preço entre os candlesticks.	Raramente mostra gaps devido à fórmula de média.
Sinais de Reversão	Mostra reversões rápidas e pavios.	As reversões são mais lentas, porém mais fortes quando confirmadas.
As reversões são mais lentas, porém mais fortes quando confirmadas.	Reflete os preços reais do mercado.	Calcula a média dos preços, o que significa que o último preço não corresponde ao preço real do mercado.

Estratégia

Esta estratégia é construída em torno de quatro funções principais no EA em MQL5: cálculo do Heikin Ashi, confirmação de tendência, identificação de sinais de reversão e confirmação de sinal usando RSI. Vamos detalhar cada uma delas abaixo.

Cálculo do Heikin Ashi

Os gráficos Heikin Ashi são construídos usando quatro pontos de dados principais: preços de abertura, máxima, mínima e fechamento para cada período. Esses valores são processados para gerar candlesticks Heikin Ashi, que diferem dos candlesticks tradicionais. Em vez de refletir o price action bruto, os candlesticks Heikin Ashi utilizam cálculos de preços médios — combinando os preços de abertura e fechamento, bem como os preços de máxima e mínima — para criar uma representação mais fluida das tendências de mercado. 

Esse efeito de suavização minimiza o impacto de flutuações repentinas de preço, reduzindo o ruído do mercado e tornando as tendências mais fáceis de identificar. Como resultado, os candlesticks Heikin Ashi geralmente apresentam corpos menores e pavios mais longos, destacando o momentum do mercado enquanto filtram a volatilidade de curto prazo. Para implementar a estratégia Heikin Ashi, o fluxograma a seguir demonstra como os dados tradicionais de candlestick são transformados em um gráfico Heikin Ashi suave e focado na tendência. Esse processo filtra o ruído do mercado e fornece uma perspectiva mais clara da tendência predominante. Abaixo está um detalhamento passo a passo de como isso funciona:

Fig 2. Fluxograma

O fluxograma ilustra como os dados OHLC tradicionais são transformados em candlesticks Heikin Ashi. O processo começa com dados brutos de mercado, que são então suavizados por meio do cálculo de uma média para o preço de fechamento (haClose). O preço de abertura (haOpen) é determinado usando os valores do candle anterior para criar continuidade, enquanto haHigh e haLow garantem que o candle reflita toda a faixa de movimentos de preço. O resultado é um candlestick que reduz a volatilidade de curto prazo, tornando as tendências gerais mais visíveis. Abaixo está o trecho de código MQL5 da função que calcula os candles Heikin Ashi.

void CalculateHeikinAshi()
{
   MqlRates rates[];
   int copied = CopyRates(_Symbol, _Period, 0, Bars(_Symbol, _Period), rates);

   if(copied < TrendCandles + 2)
   {
      Print("Failed to copy rates. Copied: ", copied);
      return;
   }

   ArraySetAsSeries(rates, true);

   // Resize arrays to match the number of copied bars
   ArrayResize(haClose, copied);
   ArrayResize(haOpen, copied);
   ArrayResize(haHigh, copied);
   ArrayResize(haLow, copied);

   // Calculate Heikin-Ashi values for each bar
   for(int i = copied - 1; i >= 0; i--)
   {
      haClose[i] = (rates[i].open + rates[i].high + rates[i].low + rates[i].close) / 4.0;
      haOpen[i] = (i == copied - 1) ? (rates[i].open + rates[i].close) / 2.0
                                   : (haOpen[i + 1] + haClose[i + 1]) / 2.0;
      haHigh[i] = MathMax(rates[i].high, MathMax(haOpen[i], haClose[i]));
      haLow[i] = MathMin(rates[i].low, MathMin(haOpen[i], haClose[i]));
   }

   Print("Heikin-Ashi Calculation Complete");
}

O resultado é uma série de candlesticks Heikin Ashi que filtram grande parte do ruído do mercado, permitindo que a tendência subjacente se torne mais evidente.

Confirmação de Tendência

Antes de tentar identificar quaisquer sinais de reversão, o EA realiza a confirmação da tendência para garantir que um forte movimento direcional esteja em vigor. Isso envolve a análise de um número especificado de candles Heikin Ashi consecutivos. Para uma tendência de alta, o EA verifica se o haClose de cada candle é maior do que o do candle subsequente, enquanto para uma tendência de baixa, verifica se os valores de haClose são consecutivamente menores. O número de candles necessários para confirmar a tendência é controlado por parâmetros de entrada, garantindo que apenas tendências bem estabelecidas sejam consideradas. Essa verificação rigorosa minimiza o risco de sinais falsos ao confirmar que o mercado está decisivamente em tendência antes de avançar para a detecção de reversões.

int consecutive = 0;
for(int i = 2; i <= TrendCandles + 1; i++)
{
   if((haClose[i] > haClose[i + 1] && isBullish) || (haClose[i] < haClose[i + 1] && !isBullish))
      consecutive++;
   else
      break;
}
if(consecutive < ConsecutiveCandles)
   return false;

Essa etapa garante que um sinal só seja considerado quando houver forte evidência de uma tendência em andamento, reduzindo as chances de sinais falsos causados por flutuações aleatórias do mercado.

Identificação de Sinal de Reversão

Após confirmar uma tendência estabelecida, o EA prossegue para identificar possíveis sinais de reversão examinando cuidadosamente a estrutura do próximo candle Heikin Ashi. Nesta etapa, o EA calcula o corpo do candle como a diferença absoluta entre haClose e haOpen, e mede a sombra com base na direção de interesse — focando na sombra inferior para uma reversão de alta e na sombra superior para uma reversão de baixa. Uma condição fundamental é que a razão entre a sombra e o corpo deve exceder um limite predefinido. Essa alta relação sombra-corpo indica que o mercado rejeitou fortemente a tendência predominante, conforme evidenciado por um pavio longo em relação a um corpo pequeno. Esse padrão serve como um indicador robusto de que uma reversão pode estar em andamento.

// Check for a strong reversal candlestick
double body = MathAbs(haClose[1] - haOpen[1]);
double shadow = (direction > 0) ? MathAbs(haLow[1] - haOpen[1])
                                : MathAbs(haHigh[1] - haOpen[1]);

// Avoid division by zero and confirm shadow-to-body ratio
if(body == 0.0 || (shadow / body) < ShadowToBodyRatio)
   return false;

Essa etapa filtra sinais fracos ou ambíguos ao exigir uma característica forte de reversão na estrutura do candle antes de prosseguir.

Confirmação de Sinal com RSI

A etapa final da estratégia envolve a confirmação do sinal de reversão usando o Índice de Força Relativa (RSI), que adiciona uma camada extra de validação. Assim que uma possível reversão é identificada por meio dos critérios do Heikin Ashi, o EA obtém o valor mais recente do RSI para avaliar o momentum do mercado. Para um sinal de reversão de alta, o RSI deve estar abaixo de um limite de compra designado, indicando que o ativo está sobrevendido; por outro lado, para uma reversão de baixa, o RSI deve exceder um limite de venda especificado, sugerindo que o ativo está sobrecomprado. Somente quando tanto o padrão Heikin Ashi quanto a condição do RSI são atendidos o EA gera um sinal de negociação — como desenhar uma seta de compra ou venda no gráfico. Essa abordagem de confirmação dupla ajuda a reduzir sinais falsos, garantindo que as negociações sejam executadas apenas quando múltiplos indicadores corroboram uma reversão de mercado.

// Get RSI Value
double rsiValue;
if(!GetRSIValue(rsiValue))
{
   Print("Failed to retrieve RSI value.");
   return;
}

// Detect potential reversals with RSI confirmation
if(DetectReversal(true) && rsiValue < RSI_Buy_Threshold)  // Bullish reversal with RSI confirmation
{
   DrawArrow("BuyArrow", iTime(NULL, 0, 0), SymbolInfoDouble(_Symbol, SYMBOL_BID), 233, BuyArrowColor);
   Print("Bullish Reversal Detected - RSI:", rsiValue);
}
else if(DetectReversal(false) && rsiValue > RSI_Sell_Threshold)  // Bearish reversal with RSI confirmation
{
   DrawArrow("SellArrow", iTime(NULL, 0, 0), SymbolInfoDouble(_Symbol, SYMBOL_ASK), 234, SellArrowColor);
   Print("Bearish Reversal Detected - RSI:", rsiValue);
}

A confirmação do RSI adiciona uma camada de análise de momentum. Ao combinar price action por meio do (Heikin Ashi) com momentum por meio do (RSI), o EA melhora a confiabilidade dos sinais, garantindo que as negociações sejam iniciadas apenas quando múltiplos indicadores estejam alinhados.

Outras Funções

Parâmetros de Entrada

Antes de mergulhar na lógica principal, precisamos definir um conjunto de parâmetros de entrada que nos permitirá ajustar com precisão o comportamento do EA. Esses parâmetros nos permitem controlar as regras de confirmação de tendência, condições de reversão, limites de volume, configurações do RSI e a visualização dos sinais, tudo isso sem modificar o código.

input int TrendCandles = 3;                 // Number of candles for trend detection
input double ShadowToBodyRatio = 1.5;       // Shadow-to-body ratio for reversal detection
input int ConsecutiveCandles = 2;           // Consecutive candles to confirm trend
input int RSI_Period = 14;                  // RSI Period
input double RSI_Buy_Threshold = 34.0;      // RSI level for buy confirmation
input double RSI_Sell_Threshold = 65.0;     // RSI level for sell confirmation
input color BuyArrowColor = clrGreen;       // Buy signal color
input color SellArrowColor = clrRed;        // Sell signal color

Esses parâmetros nos dão controle sobre aspectos-chave da estratégia. A configuração TrendCandles define quantos candles Heikin Ashi consideramos ao identificar tendências. O ShadowToBodyRatio garante que consideremos apenas candles de reversão fortes. ConsecutiveCandles filtra tendências fracas ao exigir pelo menos dois candles para confirmar uma direção. RSI_Buy_Threshold e RSI_Sell_Threshold adicionam outra camada de confirmação usando o RSI. BuyArrowColor e SellArrowColor nos permitem personalizar como os sinais aparecem no gráfico.

Variáveis Globais

Para garantir que nossos cálculos sejam executados de forma eficiente, declaramos arrays globais para armazenar os valores do Heikin Ashi, bem como um handle para o indicador RSI.

double haClose[], haOpen[], haHigh[], haLow[];
int rsiHandle;

Usamos essas variáveis para armazenar os valores calculados do Heikin Ashi e obter leituras do RSI dinamicamente em nosso EA.

Inicialização (OnInit)

Quando anexamos o EA ao gráfico, a função OnInit() é executada primeiro. Ela configura nossos arrays do Heikin Ashi e inicializa o indicador RSI.

int OnInit()
{
   ArraySetAsSeries(haClose, true);
   ArraySetAsSeries(haOpen, true);
   ArraySetAsSeries(haHigh, true);
   ArraySetAsSeries(haLow, true);

   if(Bars(_Symbol, _Period) < TrendCandles + 2)
   {
      Print("Not enough bars for initialization.");
      return INIT_FAILED;
   }

   rsiHandle = iRSI(_Symbol, _Period, RSI_Period, PRICE_CLOSE);
   if(rsiHandle == INVALID_HANDLE)
   {
      Print("Failed to create RSI indicator.");
      return INIT_FAILED;
   }

   Print("EA Initialized Successfully");
   return INIT_SUCCEEDED;
}

Aqui, definimos nossos arrays em ordem inversa, para que o candle mais recente esteja sempre no índice 0. Verificamos se há barras suficientes disponíveis antes de executar os cálculos. Inicializamos o indicador RSI e tratamos quaisquer erros caso ele falhe. Se tudo estiver configurado corretamente, o EA imprime uma mensagem de confirmação e começa a ser executado.

Processamento de Tick (OnTick)

Essa função é executada a cada novo tick de preço, garantindo que analisemos continuamente o mercado e identifiquemos possíveis sinais de negociação.

void OnTick()
{
   if(Bars(_Symbol, _Period) < TrendCandles + 2)
   {
      Print("Not enough bars for tick processing.");
      return;
   }

   CalculateHeikinAshi();

   double rsiValue;
   if(!GetRSIValue(rsiValue))
   {
      Print("Failed to retrieve RSI value.");
      return;
   }

   if(DetectReversal(true) && rsiValue < RSI_Buy_Threshold)
   {
      DrawArrow("BuyArrow", iTime(NULL, 0, 0), SymbolInfoDouble(_Symbol, SYMBOL_BID), 233, BuyArrowColor);
      Print("Bullish Reversal Detected - RSI:", rsiValue);
   }
   else if(DetectReversal(false) && rsiValue > RSI_Sell_Threshold)
   {
      DrawArrow("SellArrow", iTime(NULL, 0, 0), SymbolInfoDouble(_Symbol, SYMBOL_ASK), 234, SellArrowColor);
      Print("Bearish Reversal Detected - RSI:", rsiValue);
   }
}

Geramos um nome exclusivo para cada seta com base no timestamp do sinal. Se uma seta existente com o mesmo nome for encontrada, nós a excluímos para evitar poluição visual. Em seguida, criamos um novo objeto de seta e definimos suas propriedades (cor, tamanho e tipo). Se for bem-sucedido, imprimimos uma mensagem confirmando que a seta foi posicionada.

Limpeza na Desinicialização (OnDeinit)

Quando removemos o EA do gráfico, precisamos liberar os recursos do indicador para evitar problemas de memória.

void OnDeinit(const int reason)
{
   if(rsiHandle != INVALID_HANDLE)
      IndicatorRelease(rsiHandle);
}

Essa função garante que o indicador RSI seja corretamente removido quando o EA para de ser executado.

Código MQL5

//+------------------------------------------------------------------+
//|                                        Heikin Ashi Signal EA.mq5 |
//|                              Copyright 2025, Christian Benjamin. |
//|                                             https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Christian Benjamin."
#property link      "https://www.mql5.com/en/users/lynnchris"
#property version   "1.00"
#property strict

//--- Input parameters
input int TrendCandles = 3;                 // Number of candles for trend detection
input double ShadowToBodyRatio = 1.5;       // Shadow-to-body ratio for reversal detection
input int ConsecutiveCandles = 2;           // Consecutive candles to confirm trend
input int RSI_Period = 14;                  // RSI Period
input double RSI_Buy_Threshold = 34.0;      // RSI level for buy confirmation
input double RSI_Sell_Threshold = 65.0;     // RSI level for sell confirmation
input color BuyArrowColor = clrGreen;       // Buy signal color
input color SellArrowColor = clrRed;        // Sell signal color

//--- Global variables
double haClose[], haOpen[], haHigh[], haLow[];
int rsiHandle;

//+------------------------------------------------------------------+
//| Expert initialization                                            |
//+------------------------------------------------------------------+
int OnInit()
  {
   ArraySetAsSeries(haClose, true);
   ArraySetAsSeries(haOpen, true);
   ArraySetAsSeries(haHigh, true);
   ArraySetAsSeries(haLow, true);

   if(Bars(_Symbol, _Period) < TrendCandles + 2)
     {
      Print("Not enough bars for initialization.");
      return INIT_FAILED;
     }

// Initialize RSI indicator
   rsiHandle = iRSI(_Symbol, _Period, RSI_Period, PRICE_CLOSE);
   if(rsiHandle == INVALID_HANDLE)
     {
      Print("Failed to create RSI indicator.");
      return INIT_FAILED;
     }

   Print("EA Initialized Successfully");
   return INIT_SUCCEEDED;
  }

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   if(Bars(_Symbol, _Period) < TrendCandles + 2)
     {
      Print("Not enough bars for tick processing.");
      return;
     }

// Calculate Heikin-Ashi
   CalculateHeikinAshi();

// Get RSI Value
   double rsiValue;
   if(!GetRSIValue(rsiValue))
     {
      Print("Failed to retrieve RSI value.");
      return;
     }

// Detect potential reversals with RSI confirmation
   if(DetectReversal(true) && rsiValue < RSI_Buy_Threshold)  // Bullish reversal with RSI confirmation
     {
      DrawArrow("BuyArrow", iTime(NULL, 0, 0), SymbolInfoDouble(_Symbol, SYMBOL_BID), 233, BuyArrowColor);
      Print("Bullish Reversal Detected - RSI:", rsiValue);
     }
   else
      if(DetectReversal(false) && rsiValue > RSI_Sell_Threshold)  // Bearish reversal with RSI confirmation
        {
         DrawArrow("SellArrow", iTime(NULL, 0, 0), SymbolInfoDouble(_Symbol, SYMBOL_ASK), 234, SellArrowColor);
         Print("Bearish Reversal Detected - RSI:", rsiValue);
        }
  }

//+------------------------------------------------------------------+
//| Calculate Heikin-Ashi                                            |
//+------------------------------------------------------------------+
void CalculateHeikinAshi()
  {
   MqlRates rates[];
   int copied = CopyRates(_Symbol, _Period, 0, Bars(_Symbol, _Period), rates);

   if(copied < TrendCandles + 2)
     {
      Print("Failed to copy rates. Copied: ", copied);
      return;
     }

   ArraySetAsSeries(rates, true);

// Resize arrays to match the number of copied bars
   ArrayResize(haClose, copied);
   ArrayResize(haOpen, copied);
   ArrayResize(haHigh, copied);
   ArrayResize(haLow, copied);

// Calculate Heikin-Ashi
   for(int i = copied - 1; i >= 0; i--)
     {
      haClose[i] = (rates[i].open + rates[i].high + rates[i].low + rates[i].close) / 4.0;
      haOpen[i] = (i == copied - 1) ? (rates[i].open + rates[i].close) / 2.0 : (haOpen[i + 1] + haClose[i + 1]) / 2.0;
      haHigh[i] = MathMax(rates[i].high, MathMax(haOpen[i], haClose[i]));
      haLow[i] = MathMin(rates[i].low, MathMin(haOpen[i], haClose[i]));
     }

   Print("Heikin-Ashi Calculation Complete");
  }

//+------------------------------------------------------------------+
//| Detect Reversals with Trend Confirmation                         |
//+------------------------------------------------------------------+
bool DetectReversal(bool isBullish)
  {
   int direction = isBullish ? 1 : -1;

// Confirm trend location: Check for consecutive candles in the same direction
   int consecutive = 0;
   for(int i = 2; i <= TrendCandles + 1; i++)
     {
      if((haClose[i] > haClose[i + 1] && isBullish) || (haClose[i] < haClose[i + 1] && !isBullish))
         consecutive++;
      else
         break;
     }
   if(consecutive < ConsecutiveCandles)
      return false;

// Check for a strong reversal candlestick
   double body = MathAbs(haClose[1] - haOpen[1]);
   double shadow = (direction > 0) ? MathAbs(haLow[1] - haOpen[1]) : MathAbs(haHigh[1] - haOpen[1]);

// Avoid division by zero and confirm shadow-to-body ratio
   if(body == 0.0 || (shadow / body) < ShadowToBodyRatio)
      return false;

// Confirm the reversal with the next candlestick (opposite direction)
   return ((haClose[0] - haOpen[0]) * direction < 0);
  }

//+------------------------------------------------------------------+
//| Get RSI Value                                                    |
//+------------------------------------------------------------------+
bool GetRSIValue(double &rsiValue)
  {
   double rsiBuffer[];
   if(CopyBuffer(rsiHandle, 0, 0, 1, rsiBuffer) > 0)
     {
      rsiValue = rsiBuffer[0];
      return true;
     }
   return false;
  }

//+------------------------------------------------------------------+
//| Draw Arrow                                                       |
//+------------------------------------------------------------------+
void DrawArrow(string name, datetime time, double price, int code, color clr)
  {
   name += "_" + IntegerToString(time);
   if(ObjectFind(0, name) != -1)
      ObjectDelete(0, name);

   if(ObjectCreate(0, name, OBJ_ARROW, 0, time, price))
     {
      ObjectSetInteger(0, name, OBJPROP_ARROWCODE, code);
      ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
      ObjectSetInteger(0, name, OBJPROP_WIDTH, 2);
      Print("Arrow Drawn: ", name, " at ", price);
     }
   else
     {
      Print("Failed to create arrow: ", GetLastError());
     }
  }

//+------------------------------------------------------------------+
//| Expert deinitialization                                          |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
   if(rsiHandle != INVALID_HANDLE)
      IndicatorRelease(rsiHandle);
  }
//+------------------------------------------------------------------+

Resultados

No meu processo de testes, utilizei tanto backtesting quanto testes em mercado ao vivo para avaliar o desempenho do EA.

• Backtesting

Executei o EA em dados históricos para verificar sua viabilidade básica e identificar seus pontos fortes e fracos. Essa fase confirma que a abordagem funciona sob condições de mercado conhecidas, embora não consiga replicar totalmente fatores do mundo real, como slippage ou spreads variáveis. Vamos dar uma olhada no GIF abaixo.

Fig 3. Backtesting do Índice V100

Abaixo, apresentei resultados adicionais de backtesting para três pares diferentes ao longo de um período de 27 dias para avaliar a precisão dos sinais. Um sinal foi considerado bem-sucedido se o mercado mudou de direção após a confirmação.

• EURUSD

Sinal	Total	Verdadeiro	% Precisão
Compra	20	17	85%
Venda	10	8	80%

• Índice Crash 900

Sinal	Total	Verdadeiro	% Precisão
Compra	18	14	77.8%
Venda	25	15	60%

• Índice Step

Sinal	Total	Verdadeiro	% Precisão
Compra	18	15	83.3.%
Venda	22	14	63.6%

O EA demonstrou ser altamente eficaz, alcançando um mínimo de 77,8% de precisão em sinais de compra e pelo menos 60% de precisão em sinais de venda nos pares testados.

• Testes em Mercado ao Vivo

Os testes ao vivo forneceram uma visão sobre o desempenho do EA sob as condições atuais do mercado. Essa avaliação em tempo real revelou o quão bem o EA lida com a volatilidade do mercado e os desafios de execução. Diante dos riscos envolvidos, comecei com uma pequena alocação para gerenciar a exposição.

Fig 4. Teste em Mercado ao Vivo do Índice V25

Ponto-Chave

Backtesting valida a estratégia em teoria, enquanto os testes ao vivo demonstram seu desempenho prático. Ambas as etapas são cruciais para refinar o EA e garantir que ele seja robusto o suficiente para negociações no mundo real.

Conclusão

A técnica Heikin-Ashi é particularmente eficaz na filtragem de flutuações do mercado. Também a considerei útil para identificar pontos de reversão do mercado. Após testá-la como qualquer outra ferramenta, descobri que ela funciona de forma mais eficiente quando utilizada em conjunto com outras estratégias. É importante experimentar as entradas do código e testar em uma conta demo ou por meio de backtesting até alcançar o melhor desempenho de acordo com suas preferências. Suas sugestões são muito bem-vindas.

Data	Nome da Ferramenta	Descrição	Versão	Atualizações	Notas
01/10/24	Projetor de Gráficos	Script para sobrepor a ação de preço do dia anterior com efeito fantasma.	1.0	Lançamento Inicial	Primeira ferramenta na caixa de ferramentas Lynnchris
18/11/24	Comentário Analítico	Ela fornece informações do dia anterior em formato tabular, além de antecipar a direção futura do mercado.	1.0	Lançamento Inicial	Segunda ferramenta na caixa de ferramentas Lynnchris
27/11/24	Mestre em Análise	Atualização regular das métricas de mercado a cada duas horas	1.01	Segundo Lançamento	Terceira ferramenta na caixa de ferramentas Lynnchris
02/12/24	Previsor Analítico	Atualização regular das métricas de mercado a cada duas horas com integração ao Telegram	1.1	Terceira Edição	Ferramenta número 4
09/12/24	Navegador de Volatilidade	O EA analisa as condições de mercado usando os indicadores Bandas de Bollinger, RSI e ATR	1.0	Lançamento Inicial	Ferramenta número 5
19/12/24	Reversão à Média Ceifador de Sinal	Analisa o mercado usando a estratégia de reversão à média e fornece sinais	1.0	Lançamento Inicial	Ferramenta número 6
9/01/25	Pulso de sinal	Analisador de múltiplos períodos de tempo	1.0	Lançamento Inicial	Ferramenta número 7
17/01/25	Quadro de Métricas	Painel com botão para análise	1.0	Lançamento Inicial	Ferramenta número 8
21/01/25	Fluxo externo	Análises por meio de bibliotecas externas	1.0	Lançamento Inicial	Ferramenta número 9
27/01/25	VWAP	Preço médio ponderado por volume	1.3	Lançamento Inicial	Ferramenta número 10
02/02/25	EA de Sinal Heikin Ashi	Suavização de Tendência e identificação de sinais de reversão	1.0	Lançamento Inicial	Ferramenta número 11