De Iniciante a Especialista: Indicador de Força de Suporte e Resistência (SRSI)

Conteúdo

• Introdução
• Visão Geral da Discussão
  
• Evidências da natureza do mercado atual.
• Implementação de MQL5 para desenvolver o SRSI.
• Testes e Resultados
• Conclusão
• Anexo (arquivo fonte do SRSI)

Introdução

Os mercados consistentemente respeitam níveis de preço passados que influenciaram seus movimentos. O dia típico de um trader frequentemente começa com o desenho manual desses níveis-chave utilizando a conhecida ferramenta de linha no MetaTrader 5. No entanto, esse processo manual pode levar à perda de níveis relevantes ou à avaliação incorreta de sua importância, destacando a necessidade de uma solução automatizada.

Alguém pode perguntar por que a automação é necessária. Embora os humanos se destaquem em tarefas complexas, criativas e na adaptação a novas situações, frequentemente enfrentamos dificuldades com consistência e com o processamento de grandes volumes de dados. A pesquisa de Mark Angelo D. Julian, Danilo B. Villarino e Kristine T. Soberano, em seu artigo de 7 de julho de 2024, "O Cérebro Humano Versus o Computador: Qual é Mais Inteligente?", ressalta esse ponto. O estudo revela que, embora os humanos se destaquem na compreensão de contexto, os computadores são muito superiores em velocidade de processamento, precisão de dados e execução de cálculos repetitivos. Esse contraste impulsiona nosso desenvolvimento contínuo de algoritmos para negociação e análise de dados.

Visão Geral da Discussão

Hoje, aplicaremos técnicas de resolução de problemas utilizando programação em MQL5 para enfrentar o desafio mencionado anteriormente. Esta discussão foi projetada para traders de todos os níveis de habilidade, desde iniciantes até especialistas, à medida que abordamos conceitos-chave que impactam todos. Como você sabe, o MetaTrader 5 é essencialmente um vasto repositório de dados de preços, ferramentas analíticas e informações históricas. As séries de candlesticks, por exemplo, são barras calculadas que representam preços de abertura, máxima, mínima e fechamento, e indicadores populares como Médias Móveis são derivados desses valores. Imagine revisar manualmente 5.000 candlesticks — esse processo não é apenas tedioso, mas também propenso a erros. É por isso que automatizar a identificação de níveis de suporte e resistência é tão benéfico.

Embora já existam várias ferramentas disponíveis no mercado — tanto gratuitas quanto pagas — hoje estamos explorando uma abordagem única. Esta sessão não trata apenas do produto final; trata também de compartilhar as habilidades de programação em MQL5 necessárias para que você construa sua própria solução personalizada. Abaixo está um resumo das vantagens do Indicador de Força de Suporte e Resistência (SRSI) que estamos desenvolvendo:

• Processamento Eficiente de Dados: Analisa extensos dados históricos de candlesticks para identificar níveis-chave.
• Automação Contínua: Opera automaticamente e continuamente, reduzindo erros manuais.
• Diferenciação de Níveis: Identifica níveis de suporte e resistência tanto fracos quanto fortes.
• Visualização Clara: Fornece uma representação visual clara desses níveis críticos.
• Notificações Abrangentes: Oferece notificações ao usuário via Terminal e notificações push.

Nas seções a seguir, começaremos coletando dados históricos de preços usando gráficos do MetaTrader 5 e níveis de suporte e resistência identificados manualmente. Essa análise inicial fornecerá evidências comparando o comportamento atual do mercado com o desempenho passado. Em seguida, mergulharemos no processo de desenvolvimento, onde compartilharei e detalharei o código do nosso indicador personalizado — explicando cada linha em detalhes para garantir que você compreenda totalmente como implementar MQL5 e transformar suas ideias em código.

Por fim, revisaremos o processo de testes e apresentaremos nossos resultados, deixando você com habilidades de programação aprimoradas e uma solução funcional. Reserve seu tempo, acompanhe e aproveite a jornada de programação.

Evidências da natureza do mercado atual  

Minha plataforma MetaTrader 5 está conectada a um servidor de corretora, fornecendo acesso a uma ampla variedade de pares de negociação. Dependendo do tipo de conta, posso negociar pares de volatilidade, pares de forex, pares de ações e muito mais. A imagem fornecida mostra uma vasta seleção de pares adicionais disponíveis para negociação. Para esta pesquisa, escolhi vários pares dessa coleção para analisar.

Para visualizar os pares oferecidos pela sua corretora e adicioná-los à sua lista de Observação de Mercado, basta pressionar CTRL + U no seu teclado ou clicar no ícone vermelho arredondado (como mostrado na imagem abaixo) para abrir a janela de Símbolos. Em seguida, clique duas vezes no par desejado para adicioná-lo automaticamente à sua lista.

Símbolos do MetaTrader 5

Pares Sintéticos

Iniciei minha análise com um par sintético sob Índices de Volatilidade — Volatility 75 (1s) Index — no timeframe semanal. Quando esse par foi introduzido por volta de 2020, inicialmente era caro, mas logo experimentou uma queda prolongada, formando uma forte tendência de baixa por semanas. Os traders que venderam o par durante esse período provavelmente obtiveram lucros significativos. No entanto, meu foco principal está na estrutura de mercado, particularmente nos últimos três anos.

A tendência de baixa sustentada provavelmente condicionou os traders a adotarem uma mentalidade de seguir tendência, esperando novas quedas. No entanto, como mostrado na imagem abaixo, a dinâmica do mercado mudou. O timeframe mais alto agora apresenta uma estrutura lateral irregular, com características semelhantes observadas em timeframes menores. Tais condições dificultam a navegação eficaz para traders de swing.

Nessas circunstâncias, a ação do preço baseada em suporte e resistência torna-se crucial para identificar oportunidades-chave de negociação. A imagem abaixo ilustra esse comportamento de mercado, reforçando a importância de uma abordagem estruturada para análise técnica.

Índice Volatility 75(1s)

Par de Ações

Analisei o gráfico semanal do US Tech, e é evidente que o mercado tem apresentado tendência de alta, com correções periódicas ao longo do caminho. Essas correções frequentemente levam a fases de consolidação, onde o movimento de preço desacelera antes de retomar a tendência. Em um mercado em tendência de alta, as correções geralmente estabelecem zonas fortes de suporte, reforçando o momentum de alta.

Nesse timeframe mais alto, é difícil identificar os padrões precisos que influenciam a ação do preço em timeframes menores. No entanto, à medida que nos aprofundamos, veremos como o conceito de suporte e resistência permanece aplicável em diferentes timeframes, permitindo observar vários padrões de mercado com mais detalhe.

    

US Tech 100Semanal

Par Forex

O gráfico semanal do EUR/USD revela uma pequena fase de impulso seguida por um período prolongado de flutuações. Esse comportamento é evidente no timeframe mais alto e se estende também para timeframes menores. O ponto principal aqui é a ação de preço prolongada dentro de uma faixa, destacando como o mercado passa uma quantidade significativa de tempo em consolidação em vez de tendência. A imagem abaixo serve como prova desse comportamento prolongado do mercado dentro de uma faixa definida.

EURUSDWeekly

Em conclusão, a partir do exercício acima, fica claro que, embora os preços de mercado experimentem tendências de alta ou de baixa, eles dependem fortemente de níveis de preço anteriores para teste e validação. Durante fases de consolidação, esses níveis horizontais, com base no timeframe escolhido, tornam-se áreas-chave onde o preço tende a reagir.

No entanto, nem todo nível é forte o suficiente para desencadear um movimento significativo de preço. Além disso, mesmo níveis bem estabelecidos de suporte ou resistência não garantem uma reação do preço, mas oferecem maior probabilidade de influenciar o comportamento do mercado se comprovadamente forem fortes.

Na próxima seção, revisaremos brevemente os fundamentos de suporte e resistência antes de mergulhar no desenvolvimento do algoritmo.

Implementação de MQL5 para desenvolver o SRSI 

Definindo Suporte e Resistência

Suporte é geralmente definido como uma zona de demanda onde múltiplos níveis de preço convergem, indicando que os compradores estão inclinados a entrar e impulsionar o preço para cima. Essa área representa um "piso" para o mercado, onde o acúmulo de interesse comprador tende a impedir quedas adicionais.

• Em termos práticos, o suporte geralmente não é um único ponto de preço, mas uma zona onde mínimas anteriores ou múltiplos pontos de toque estabeleceram confiança dos compradores.

Por outro lado, Resistência é uma zona de oferta onde múltiplos níveis de preço convergem, sugerindo que os vendedores provavelmente intervirão e levarão o preço para baixo. Essa área atua como um "teto" para o mercado, onde a pressão vendedora supera a pressão compradora, frequentemente impedindo que o preço suba ainda mais. Assim como o suporte, a resistência é tipicamente observada como uma faixa, e não como um nível preciso, devido à presença de múltimas máximas ou pontos de toque que reforçam o interesse vendedor.

Com esse entendimento em mente, trabalhar com suporte e resistência torna-se muito mais simples. No vídeo abaixo, vou mostrar minha rotina para demonstrar como geralmente desenho essas linhas.

Projeto e Implementação do Algoritmo

Precisamos que o programa replique como eu identifico e marco manualmente zonas de Suporte e Resistência. Após revisar o vídeo, resumi aqui as etapas principais:

1. Identificar Pontos de Reversão Extremos: São máximas significativas (para resistência) ou mínimas (para suporte) onde o preço muda de direção.
2. Encontrar Outros Pontos de Teste: Procure níveis adicionais onde o preço seja igual ou esteja dentro de 5 pips do ponto de reversão extremo, confirmando sua relevância.
3. Formar Zonas de Rejeição: Crie zonas retangulares que englobem os pontos de reversão extremos e seus pontos de teste, com a zona se estendendo ao redor desses toques.
4. Personalizar Dimensões da Zona:

• Altura: O tamanho vertical do retângulo da zona (em pips) deve ser ajustável.
• Largura: O tamanho horizontal da zona (em barras de candlestick à direita) deve ser ajustável.

De modo geral, configuraremos nosso programa para escanear um número personalizável de candles, identificando condições que atendam aos nossos critérios e desenhando as formas, linhas e rótulos apropriados. Também forneceremos opções de entrada para controlar vários recursos do programa. Para alertas, implementaremos notificações push e alertas no terminal, entregando-os periodicamente dentro de um intervalo personalizável de 4 horas. Diferente de outros indicadores, níveis de suporte e resistência não exigem monitoramento constante, portanto essa abordagem garante notificações oportunas sem excesso de alertas. Abaixo, explico os detalhes passo a passo, juntamente com trechos de código.

Quando você abre o MetaEditor e escolhe criar um novo indicador personalizado, ele fornece um modelo básico para trabalhar. Esse modelo é como uma tela em branco que ajuda os desenvolvedores a começar, e é onde construiremos nosso indicador SRSI. Veja como ele se parece:

//+------------------------------------------------------------------+
//|                                                        _SRSI.mq5 |
//|                                   Copyright 2025, Metaquotes Ltd |
//|                                            https://www.mql5.com/ |
//+------------------------------------------------------------------+
#property copyright "Copyright 2025, Metaquotes Ltd"
#property link      "https://www.mql5.com/"
#property version   "1.00"
#property indicator_chart_window
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int 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 int &spread[])
  {
//---
   
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

Usaremos isso como um guia fundamental, garantindo que todas as funções-chave sejam implementadas corretamente. Nas etapas subsequentes, completaremos o modelo, integraremos novos recursos e forneceremos explicações detalhadas de suas funcionalidades. Por favor, acompanhe até o final para uma compreensão completa.

Etapa 1: Personalizando as Propriedades do Indicador

Para começar, personalizamos as propriedades do indicador para adaptá-lo e atender aos requisitos do MetaTrader 5. Atualizamos os detalhes de copyright e link para refletir nossas próprias informações. Adicionamos uma configuração para verificação de erros mais rigorosa, a fim de detectar falhas durante o desenvolvimento. O indicador é configurado para ser exibido na janela principal do gráfico. Como o MetaTrader 5 exige pelo menos um buffer, definimos um único buffer "dummy" oculto, já que nosso indicador utilizará objetos personalizados (linhas e retângulos) em vez de dados plotados em buffer.

#property copyright "Clemence Benjamin"
#property link      "https://www.mql5.com/en/users/billionaire2024/seller"
#property version   "1.00"
#property strict          // Enforces stricter error checking
#property indicator_chart_window
#property indicator_buffers 1  // MT5 requires at least one buffer
#property indicator_plots 1    // Ties to the buffer (even if unused for plotting)

Etapa 2: Adicionando Entradas do Usuário

Em seguida, adicionamos entradas configuráveis pelo usuário para tornar o indicador adaptável. Incluímos uma opção para definir quantas barras passadas o indicador analisará, um intervalo de preço (por exemplo, padrão de 7 pips) para detectar testes de nível, um número mínimo de testes necessários para que um nível seja considerado forte, e uma opção para mostrar ou ocultar zonas retangulares ao redor de níveis fortes. Essas entradas permitem que os usuários ajustem o comportamento do indicador sem alterar o código.

input int InpLookBack = 1000;        // Number of bars to analyze
input double InpTestProximity = 0.0007; // Price range for tests (e.g., 7 pips)
input int InpMinTests = 3;           // Minimum tests for strong levels
input bool InpShowRectangles = true; // Show zones as rectangles

Etapa 3: Criando um Buffer Dummy

O MetaTrader 5 exige que todo indicador tenha pelo menos um buffer, mesmo que não seja exibido. Criamos um array global para atuar como esse buffer dummy. Durante a inicialização, vinculamos esse buffer a um slot de buffer e o ocultamos do gráfico. Isso atende ao requisito do MetaTrader 5 enquanto nos permite focar no desenho de níveis personalizados de suporte e resistência.

double DummyBuffer[];

Usando-o:

int OnInit()
{
   SetIndexBuffer(0, DummyBuffer, INDICATOR_DATA);   // Bind buffer to index 0
   PlotIndexSetInteger(0, PLOT_DRAW_TYPE, DRAW_NONE); // Hide it from the chart
   return(INIT_SUCCEEDED);
}

Etapa 4: Definindo Estruturas de Dados

Para manter nossos dados organizados, utilizamos enums e structs. Definimos um enum para categorizar níveis (por exemplo, suporte forte, resistência fraca) para maior clareza. Uma struct para níveis de preço armazena o preço de cada nível, contagem de testes, tipo e tempo de identificação. Outra struct define zonas ao redor de níveis fortes, contendo seus preços superior e inferior e o intervalo de tempo. Também configuramos arrays globais para armazenar níveis fortes, níveis fracos e zonas, além de uma variável para rastrear o último horário de alerta.

enum ENUM_LEVEL_TYPE {
   LEVEL_STRONG_SUPPORT,      // Strong support level
   LEVEL_STRONG_RESISTANCE,   // Strong resistance level
   LEVEL_WEAK_SUPPORT,        // Weak support level
   LEVEL_WEAK_RESISTANCE      // Weak resistance level
};

struct PriceLevel {
   double price;           // Price value of the level
   int test_count;         // Number of times price tested it
   ENUM_LEVEL_TYPE type;   // Strong or weak, support or resistance
   datetime time;          // Time the level was identified
};

struct Zone {
   double top;             // Top price of the zone
   double bottom;          // Bottom price of the zone
   datetime start_time;    // When the zone starts
   datetime end_time;      // When the zone ends (current time)
};

PriceLevel StrongLevels[];    // Array for strong levels
PriceLevel WeakLevels[];      // Array for weak levels
Zone Zones[];                 // Array for strong level zones
datetime LastAlertTime = 0;   // Tracks the last alert time

Etapa 5: Detectando Pontos de Swing

Níveis de suporte e resistência frequentemente se formam em topos e fundos de swing. Criamos uma função para identificar topos de swing verificando se a máxima de uma barra excede as máximas das 5 barras anteriores e das 5 posteriores, marcando um pico. Da mesma forma, uma função para fundos de swing verifica se a mínima de uma barra está abaixo das mínimas das 5 barras ao redor, indicando um vale. O uso de uma janela de 5 barras de cada lado garante que esses pontos sejam significativos.

bool IsSwingHigh(int index, const double &high[])
{
   int window = 5;  // Check 5 bars on each side
   for (int i = 1; i <= window; i++) {
      if (index - i < 0 || index + i >= ArraySize(high)) return false; // Out of bounds
      if (high[index] <= high[index - i] || high[index] <= high[index + i]) return false; // Not a peak
   }
   return true;
}

bool IsSwingLow(int index, const double &low[])
{
   int window = 5;  // Check 5 bars on each side
   for (int i = 1; i <= window; i++) {
      if (index - i < 0 || index + i >= ArraySize(low)) return false; // Out of bounds
      if (low[index] >= low[index - i] || low[index] >= low[index + i]) return false; // Not a trough
   }
   return true;
}

Etapa 6: Contando Testes de Preço

A força de um nível depende da frequência com que o preço o testa. Adicionamos uma função para contar esses testes examinando as barras após um ponto de swing. Ela verifica se a máxima ou mínima de cada barra está dentro do intervalo de preço definido do nível, incrementando um contador para cada teste. A contagem total de testes determina se o nível é forte ou fraco com base no limite mínimo definido pelo usuário.

int CountLevelTests(double price, int start_index, const double &high[], const double &low[])
{
   int tests = 0;
   for (int i = start_index + 1; i < ArraySize(high); i++) {
      if (MathAbs(high[i] - price) <= InpTestProximity || MathAbs(low[i] - price) <= InpTestProximity) {
         tests++;
      }
   }
   return tests;
}

Etapa 7: Processando Níveis

Processamos cada ponto de swing em um nível usando uma função dedicada. Ela registra o preço, a contagem de testes, o tempo e o tipo (forte/fraco, suporte/resistência) com base em ser um topo ou fundo de swing e atender ao limite de testes. Para níveis fortes, ela também define uma zona com um intervalo de preço ao redor do nível. O nível é então armazenado no array apropriado (forte ou fraco) para uso posterior.

void ProcessLevel(int index, double price, bool is_high, const double &high[], const double &low[], const datetime &time[])
{
   PriceLevel level;
   level.price = price;
   level.test_count = CountLevelTests(price, index, high, low);
   level.time = time[index];
   
   if (is_high) {
      level.type = (level.test_count >= InpMinTests) ? LEVEL_STRONG_RESISTANCE : LEVEL_WEAK_RESISTANCE;
   } else {
      level.type = (level.test_count >= InpMinTests) ? LEVEL_STRONG_SUPPORT : LEVEL_WEAK_SUPPORT;
   }
   
   if (level.test_count >= InpMinTests) {
      ArrayResize(StrongLevels, ArraySize(StrongLevels) + 1);
      StrongLevels[ArraySize(StrongLevels) - 1] = level;
      Zone zone;
      zone.start_time = time[index];
      zone.end_time = TimeCurrent();
      zone.top = price + InpTestProximity;
      zone.bottom = price - InpTestProximity;
      ArrayResize(Zones, ArraySize(Zones) + 1);
      Zones[ArraySize(Zones) - 1] = zone;
   } else {
      ArrayResize(WeakLevels, ArraySize(WeakLevels) + 1);
      WeakLevels[ArraySize(WeakLevels) - 1] = level;
   }
}

Etapa 8: Desenhando no Gráfico

Para exibir os níveis, utilizamos duas funções de renderização. Uma desenha níveis fortes com um retângulo cinza (se habilitado) para a zona e uma linha sólida — azul para suporte, vermelha para resistência — além de um rótulo ("SS" ou "SR"). A outra desenha níveis fracos com uma linha tracejada — azul claro para suporte, rosa para resistência — e um rótulo ("WS" ou "WR"). Cada objeto recebe um nome único baseado em seu tempo para garantir o gerenciamento adequado no gráfico.

void RenderZone(const Zone &zone, const PriceLevel &level)
{
   string name = "Zone_" + TimeToString(zone.start_time);
   if (InpShowRectangles) {
      ObjectCreate(0, name, OBJ_RECTANGLE, 0, zone.start_time, zone.top, zone.end_time, zone.bottom);
      ObjectSetInteger(0, name, OBJPROP_COLOR, clrLightGray);
      ObjectSetInteger(0, name, OBJPROP_FILL, true);
   }
   
   string line_name = "Line_" + TimeToString(level.time);
   ObjectCreate(0, line_name, OBJ_HLINE, 0, 0, level.price);
   ObjectSetInteger(0, line_name, OBJPROP_COLOR, (level.type == LEVEL_STRONG_SUPPORT) ? clrBlue : clrRed);
   ObjectSetString(0, line_name, OBJPROP_TEXT, (level.type == LEVEL_STRONG_SUPPORT) ? "SS" : "SR");
}

void RenderWeakLine(const PriceLevel &level)
{
   string name = "WeakLine_" + TimeToString(level.time);
   ObjectCreate(0, name, OBJ_HLINE, 0, 0, level.price);
   ObjectSetInteger(0, name, OBJPROP_STYLE, STYLE_DASH);
   ObjectSetInteger(0, name, OBJPROP_COLOR, (level.type == LEVEL_WEAK_SUPPORT) ? clrLightBlue : clrPink);
   ObjectSetString(0, name, OBJPROP_TEXT, (level.type == LEVEL_WEAK_SUPPORT) ? "WS" : "WR");
}

Etapa 9: Enviando Alertas

Incluímos uma função para enviar alertas sobre níveis fortes sem sobrecarregar o usuário. Ela verifica se uma hora se passou desde o último alerta e se existem níveis fortes. Se sim, cria uma mensagem com o tipo do nível forte mais recente, seu preço e o preço atual, e então a exibe. O horário do alerta é atualizado para evitar notificações frequentes.

void SendPeriodicAlert(double current_price)
{
   if (TimeCurrent() - LastAlertTime < 3600) return; // Wait 1 hour between alerts
   if (ArraySize(StrongLevels) == 0) return;         // No strong levels, no alert
   
   PriceLevel latest = StrongLevels[ArraySize(StrongLevels) - 1];
   string message = "SRZones Alert: Strong " + 
                    ((latest.type == LEVEL_STRONG_SUPPORT) ? "Support" : "Resistance") + 
                    " at " + DoubleToString(latest.price, 5) + 
                    ", Current Price: " + DoubleToString(current_price, 5);
   Alert(message);
   LastAlertTime = TimeCurrent();
}

Etapa 10: Limpando Desenhos Antigos

Para manter o gráfico limpo, adicionamos uma função para remover objetos antigos. Ela exclui todas as zonas previamente desenhadas, linhas de níveis fortes e linhas de níveis fracos usando prefixos de nomes específicos. Isso é executado antes de cada recálculo completo para atualizar a exibição com os níveis atuais.

void ClearDisplayObjects()
{
   ObjectsDeleteAll(0, "Zone_");       // Delete all zones
   ObjectsDeleteAll(0, "Line_");       // Delete strong lines
   ObjectsDeleteAll(0, "WeakLine_");   // Delete weak lines
}

Etapa 11: Executando a Lógica em OnCalculate

Por fim, integramos tudo na função principal de cálculo. Na inicialização ou quando uma nova barra é formada, ela limpa objetos antigos e redefine os arrays. Determina um ponto inicial com base no período de análise definido pelo usuário, garantindo dados suficientes para detecção de swings. Percorre as barras, identifica topos e fundos de swing, processa-os em níveis e os armazena. Em seguida, renderiza todos os níveis fortes e fracos e verifica alertas. A função retorna o número de barras processadas ao MetaTrader 5.

int OnCalculate(const int rates_total,
                const int 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 int &spread[])
{
   if (prev_calculated == 0 || rates_total > prev_calculated) { // Full recalc on start or new bar
      ClearDisplayObjects();
      ArrayResize(StrongLevels, 0);
      ArrayResize(WeakLevels, 0);
      ArrayResize(Zones, 0);
      
      int start = MathMax(5, rates_total - InpLookBack); // Start within lookback period
      for (int i = start; i < rates_total - 5; i++) {    // Leave room for swing checks
         if (IsSwingHigh(i, high)) ProcessLevel(i, high[i], true, high, low, time);
         if (IsSwingLow(i, low)) ProcessLevel(i, low[i], false, high, low, time);
      }
      
      for (int i = 0; i < ArraySize(StrongLevels); i++) {
         RenderZone(Zones[i], StrongLevels[i]);
      }
      for (int i = 0; i < ArraySize(WeakLevels); i++) {
         RenderWeakLine(WeakLevels[i]);
      }
      
      SendPeriodicAlert(close[rates_total - 1]);
   }
   return(rates_total); // Tell MT5 how many bars were processed
}

Após reunir todas as partes e resolver diversos problemas, compilamos com sucesso nosso produto final, que está anexado ao final desta discussão. Na próxima seção, compartilharemos nossa experiência de testes e apresentaremos considerações finais na conclusão.

Testes e Resultados 

O primeiro passo envolveu iniciar o indicador e adicioná-lo ao gráfico com as configurações padrão, utilizando EURUSD como referência. Outros pares de moedas podem exigir ajustes iniciais, especialmente no valor do pip, para que o indicador seja exibido corretamente. Por exemplo, ao testar no índice Volatility 75 (1s), nenhuma zona apareceu até que eu ajustasse a configuração de pip para 70.

Inicialmente, como mostrado na imagem abaixo, a largura do retângulo era relativamente pequena e exigia personalização para aumentar seu tamanho, o que ajustamos na imagem seguinte. Todas as configurações responderam bem, com mudanças perceptíveis no gráfico. Além disso, todos os rótulos são exibidos claramente, e você tem a opção de ocultá-los conforme necessário.

Adicionando o Indicador de Força de Suporte e Resistência (SRSI) ao gráfico.

Personalizando as configurações do SRSI

Ao iniciar pela primeira vez, o indicador envia um alerta exibindo o nível predominante de suporte ou resistência juntamente com o preço atual. Isso ajuda os usuários a antecipar possíveis zonas de oferta e demanda. Abaixo está um log de especialista mostrando os detalhes do alerta.

2025.03.10 07:44:42.548 _SRSI (EURUSD,M15)      Alert: Key Level: SR at 1.08715 | Current Price: 1.09021
2025.03.10 07:54:04.239 _SRSI (EURUSD,M15)      Alert: Key Level: SR at 1.08715 | Current Price: 1.09033
2025.03.10 07:55:04.965 _SRSI (EURUSD,M5)       Alert: Key Level: SR at 1.09013 | Current Price: 1.09044
2025.03.10 09:25:13.506 _SRSI (EURUSD,M5)       Alert: Key Level: SR at 1.09013 | Current Price: 1.09210
2025.03.10 11:26:46.761 _SRSI (EURUSD,M5)       Alert: Key Level: SR at 1.09013 | Current Price: 1.09192

Além disso, há uma opção para notificações push nas configurações, enquanto as notificações do terminal estão habilitadas por padrão. Se um alerta for acionado, a janela de alerta aparecerá automaticamente na tela do terminal.

Janela de Alertas do Terminal: indicador SRSI em funcionamento

Conclusão 

Nosso objetivo de discussão foi alcançado com sucesso com o desenvolvimento de um indicador sem erros. A partir de nossos testes, os objetivos de design foram atendidos, entregando a funcionalidade esperada. Agora, posso desenhar facilmente minhas linhas de suporte e resistência com apenas alguns cliques, e o algoritmo automaticamente avalia sua confiabilidade. Como você pode ter notado no vídeo, o processo manual pode ser bastante lento, mas com o algoritmo, esses níveis são calculados instantaneamente a cada tick. Ao longo deste processo, adquirimos insights valiosos de MQL5 para o desenvolvimento de indicadores, e embora o desempenho do indicador possa ser avaliado ao longo do tempo, existem várias maneiras de desenvolvedores avançados refinarem e expandirem essa solução.

Nesta abordagem, introduzimos structs como um meio de escrever código mais profissional e organizado. No entanto, sempre há espaço para melhorias, e acredito que você tenha suas próprias ideias e sugestões para aprimorar essa ferramenta. Você é bem-vindo para modificá-la e experimentar com ela, e não hesite em compartilhar seus pensamentos nos comentários abaixo.

Espero que você tenha achado esta discussão esclarecedora. Até a próxima — boa programação e negociações bem-sucedidas, desenvolvedores!

Anexo (arquivo fonte do SRSI) 

Arquivo	Descrição
_SRSI.mq5	Um Indicador de Força de Suporte e Resistência que desenha dinamicamente zonas retangulares ajustáveis, rotulando claramente suporte forte (SS) e resistência forte (SR). Além disso, plota linhas tracejadas para indicar níveis mais fracos de suporte (WS) e resistência (WR) para melhor visualização.

Voltar ao Conteúdo