Desenvolvimento de ferramentas para análise de Price Action (Parte 23): Indicador de força das moedas

Sumário

• Introdução
• Conhecendo a estratégia
• Análise do código
• Resultado
• Conclusão

Introdução

Imagine que você esteja em uma corrida de carros. Cada carro é diferente e, apenas olhando para eles, não é possível determinar qual é o mais rápido e qual é o mais lento. Em vez disso, você observa o tempo de volta, avalia a aceleração, verifica a eficiência da frenagem e analisa cada modelo separadamente. Somente depois de examinar cuidadosamente cada carro é que você os compara para avaliar o desempenho geral.

Com as moedas, a lógica é bastante semelhante. Este EA analisa cada par de moedas que contém a moeda de interesse. Por exemplo, para o USD, ele considera pares como USDJPY, EURUSD, GBPUSD, USDCHF, entre outros. O EA mede a variação de cada par em diferentes timeframes: primeiro em M15, depois em H1 e, por fim, em H4. Os períodos usados nessa análise são definidos pelos parâmetros Lookback_M15, Lookback_H1 e Lookback_H4.

Quando a moeda analisada é a moeda de cotação do par, o EA inverte o sinal dessa variação para representar corretamente sua força. Depois de calcular as variações de todos os pares relevantes, ele calcula a média dos resultados e obtém um único valor de força para cada moeda. O EA atualiza esses cálculos a cada poucos segundos, de acordo com o parâmetro Update_Seconds. Em seguida, redesenha o painel para exibir os valores atuais de força, registra no log quais moedas estão fortes, fracas ou neutras e atualiza as curvas de patrimônio da conta e de drawdown.

Neste artigo, desenvolveremos uma ferramenta em MQL5 que mede a força de uma moeda analisando o comportamento dos símbolos correspondentes aos diferentes pares. Essa abordagem permite identificar de forma confiável as moedas mais fortes e mais fracas, permitindo tomar decisões de negociação com maior confiança.

Conhecendo a estratégia

O principal objetivo do EA é determinar o grau de força ou fraqueza de cada moeda analisando, em vários timeframes, todos os pares dos quais ela faz parte. Para isso, seguimos as etapas abaixo para calcular sua força com base nesses pares.

Seleção dos pares relevantes

Para cada uma das oito principais moedas, são reunidos todos os pares nos quais ela está presente. Por exemplo, para o USD, temos USDJPY, EURUSD, GBPUSD e USDCHF.

Cálculo da variação percentual

No timeframe selecionado, como M15, H1 ou H4, calcula-se a variação percentual de cada par ao longo do período de análise:

Normalização do sinal

Se a moeda analisada for a moeda de cotação, ou seja, a segunda moeda do par, o sinal da variação percentual é invertido para que a valorização dessa moeda seja sempre representada por um valor de força positivo.

Cálculo da média entre os pares

Consideramos os valores da variação percentual, já com o sinal ajustado, de todos os pares associados à moeda e calculamos a média aritmética simples. O resultado é um único "índice de força" da moeda para o timeframe analisado.

O diagrama acima ilustra esse processo usando o USD como exemplo. Medimos a força do USD em todos os pares dos quais ele faz parte, em vários timeframes. Assim, é possível identificar em qual timeframe o USD apresenta maior força ou fraqueza.

Análise do código

No início do EA, são definidas as principais propriedades: direitos autorais, link, versão e modo de compilação estrito. Essas diretivas ajudam a identificar o EA e garantem sua conformidade com os padrões do ambiente MetaTrader. Em seguida, é incluída a biblioteca SymbolInfo.mqh, que fornece funções para gerenciar símbolos e obter informações sobre eles. Isso é necessário para selecionar, habilitar e obter dinamicamente os dados de vários pares de moedas. Esse recurso é importante porque o EA precisa acessar dados de diferentes símbolos, que podem não estar habilitados por padrão, para operar corretamente com vários pares ao mesmo tempo.

#property copyright "Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com/ru/users/lynnchris"
#property version   "1.0"
#property strict

#include <Trade\SymbolInfo.mqh>

Em seguida, o código define vários parâmetros de entrada, como Lookback_M15, Lookback_H1 e Lookback_H4, que determinam quantas barras históricas serão usadas no cálculo da força da moeda em cada timeframe. O parâmetro Update_Seconds define a frequência de atualização do painel, buscando um equilíbrio entre rapidez de resposta e carga computacional.

FontSize, BackgroundColor, PanelWidth, PanelHeight e os parâmetros de posição inicial permitem personalizar a aparência do painel e sua localização no gráfico, adaptando-o a diferentes tamanhos de tela e preferências do usuário. Os períodos de análise determinam o nível de sensibilidade ou suavização dos cálculos de força da moeda: períodos mais curtos respondem mais rapidamente, mas podem apresentar mais ruído, enquanto períodos mais longos oferecem maior estabilidade, embora reajam mais lentamente às mudanças.

input int    Lookback_M15    = 96;
input int    Lookback_H1     = 48;
input int    Lookback_H4     = 30;
input int    Update_Seconds  = 30;
input int    FontSize        = 12;
input color  BackgroundColor = clrBlack;
input int    PanelWidth      = 280;
input int    PanelHeight     = 240;
input int    InitPanelX      = 10;
input int    InitPanelY      = 10;

Os arrays Currencies e Pairs são estruturas de dados estáticas que armazenam a lista das principais moedas e dos respectivos pares associados. Essa estrutura mantém agrupados os pares relacionados a cada moeda, facilitando a iteração por esses pares durante o cálculo da força. Por exemplo, o array Pairs contém quatro pares para cada moeda, nos quais ela aparece como moeda-base ou moeda de cotação. Essa sistematização permite que as funções de cálculo avaliem com eficiência o comportamento de cada moeda em relação às demais, analisando vários pares simultaneamente e obtendo, assim, uma avaliação mais abrangente de sua força.

static const string Currencies[8] = {"USD","EUR","GBP","JPY","CHF","CAD","AUD","NZD"};
static const string Pairs[8][4] = {
   {"USDJPY","EURUSD","GBPUSD","USDCHF"},
   {"EURUSD","EURJPY","EURGBP","EURCHF"},
   // ... .........
};

Para armazenar os valores de força calculados em diferentes timeframes, são declaradas variáveis globais cujos valores são gravados no array bidimensional Strength. Esses dados são usados tanto para exibição no painel quanto para registro no log. Variáveis adicionais, como LastUpdate, armazenam o momento da última atualização dos dados e evitam recálculos desnecessários.

As variáveis dragging, dragOffsetX e dragOffsetY controlam a interação com o usuário, permitindo, em particular, que o trader mova o painel arrastando-o com o mouse. Para visualizar a evolução da conta, são declarados os arrays times[] e equities[], que armazenam, respectivamente, as marcas de tempo e os valores de patrimônio da conta, enquanto dataCount registra quantos desses pontos já foram coletados. Esses dados são usados para traçar, ao longo do tempo, as curvas de patrimônio da conta e de drawdown.

double Strength[8][3]; // [currency][timeframe]
datetime LastUpdate;
int dataCount;
double equities[MAX_POINTS];
datetime times[MAX_POINTS];
int PanelX, PanelY;
bool dragging;
int dragOffsetX, dragOffsetY;

Durante a inicialização (OnInit()), o EA define a posição inicial do painel com base nos parâmetros especificados pelo usuário. Em seguida, percorre todos os pares de moedas e chama SymbolSelect() para cada um deles, habilitando o acesso aos respectivos dados. Essa etapa é importante porque, se os símbolos não estiverem habilitados, as funções de obtenção de dados usadas posteriormente, como iClose(), não funcionarão, o que poderá resultar em cálculos incorretos ou erros.

Depois, o código inicializa a marca de tempo LastUpdate e reinicia o contador de dados dataCount. Em seguida, executa o cálculo inicial da força das moedas por meio de UpdateStrengths(), para que o painel exiba dados atualizados assim que o EA for iniciado. A função DrawPanel() é chamada para criar o painel com rótulos, barras coloridas e cabeçalhos, formando uma interface visual clara e intuitiva.

Além disso, LogCurrencyStrengths() é chamada para exibir no terminal um breve resumo textual do status das moedas, oferecendo ao trader uma visão rápida da situação. Por fim, EventSetTimer() configura a chamada periódica da rotina de atualização no intervalo definido por Update_Seconds, fazendo com que o painel seja atualizado automaticamente, sem necessidade de intervenção manual.

int OnInit()
{
   PanelX = InitPanelX;
   PanelY = InitPanelY;

   for(int i=0; i<8; i++)
      for(int j=0; j<4; j++)
         SymbolSelect(Pairs[i][j], true);

   LastUpdate = 0;
   dataCount = 0;

   UpdateStrengths();
   DrawPanel();
   LogCurrencyStrengths(1);
   EventSetTimer(Update_Seconds);
   return(INIT_SUCCEEDED);
}

Durante a desinicialização do EA, realizada em OnDeinit(), são executadas as rotinas de limpeza. EventKillTimer() desativa o temporizador e, em seguida, são excluídos todos os objetos gráficos do painel, incluindo o fundo, os rótulos, as barras e os cabeçalhos, além das linhas de patrimônio da conta e de drawdown. Essa limpeza evita que objetos remanescentes se acumulem no gráfico e consumam recursos, mantendo o ambiente de trabalho limpo após a remoção ou reinicialização do EA.

void OnTimer()
{
   if(TimeCurrent() - LastUpdate < Update_Seconds)
      return;

   LastUpdate = TimeCurrent();
   UpdateStrengths();
   DrawPanel();
   LogCurrencyStrengths(1);

   double eq = AccountInfoDouble(ACCOUNT_EQUITY);
   if(dataCount < MAX_POINTS)
   {
      times[dataCount] = TimeCurrent();
      equities[dataCount] = eq;
      dataCount++;
   }
   DrawEquityLines();
   DrawDrawdownLines();
}

A principal lógica de atualização está implementada na função OnTimer(), executada periodicamente. Primeiro, a função verifica se já transcorreu tempo suficiente desde a última atualização, comparando o tempo atual com LastUpdate. Se o intervalo especificado ainda não tiver decorrido, a função é encerrada antecipadamente para evitar cálculos desnecessários. Quando a condição é atendida, LastUpdate recebe o tempo atual e UpdateStrengths() é chamada para recalcular os valores de força das moedas com base nos dados de mercado mais recentes.

Em seguida, DrawPanel() é chamada para atualizar o painel, ajustando rótulos, cores e barras aos valores atuais de força. LogCurrencyStrengths() também registra no log o status atual das moedas, fornecendo um resumo textual da situação. Depois disso, a função obtém o valor atual do patrimônio da conta por meio de AccountInfoDouble(ACCOUNT_EQUITY) e, se o número máximo de pontos de dados ainda não tiver sido atingido, adiciona aos arrays correspondentes a marca de tempo e o respectivo valor.

Os pontos de dados armazenados são usados pelas funções DrawEquityLines() e DrawDrawdownLines() para atualizar as linhas de patrimônio da conta e de drawdown, mostrando visualmente a evolução da conta e o nível de risco ao longo do tempo. Esse ciclo mantém todo o painel sincronizado, em tempo real, com as condições do mercado e o estado da conta.

void OnChartEvent(const int id, const long &lparam, const double &dparam, const string &sparam)
{
   if(id==CHARTEVENT_OBJECT_CLICK && sparam=="CS_BG")
   {
      dragging = true;
      dragOffsetX = (int)lparam - PanelX;
      dragOffsetY = (int)dparam - PanelY;
   }
   else if(id==CHARTEVENT_MOUSE_MOVE && dragging)
   {
      PanelX = (int)lparam - dragOffsetX;
      PanelY = (int)dparam - dragOffsetY;
      DrawPanel();
   }
   else if(dragging && id==CHARTEVENT_OBJECT_CLICK)
   {
      dragging = false;
   }
}

A interação com o usuário é tratada em OnChartEvent(). Quando o usuário clica no retângulo de fundo ("CS_BG"), o modo de arraste é ativado e o deslocamento entre a posição do mouse e a posição atual do painel é armazenado. À medida que o mouse se move (CHARTEVENT_MOUSE_MOVE), a posição do painel é atualizada dinamicamente, permitindo que o trader o reposicione com facilidade para melhorar a visualização. Quando o usuário solta o botão do mouse ou clica em outro local, o modo de arraste é desativado e o painel permanece na nova posição. Esse recurso torna a interação mais prática e permite adaptar o painel a diferentes layouts do ambiente de trabalho.

double CalculateStrength(int ci, ENUM_TIMEFRAMES tf, int lookback)
{
   double sum = 0;
   int cnt = 0;

   for(int j=0; j<4; j++)
   {
      string sym = Pairs[ci][j];
      if(Bars(sym, tf) < lookback+1) continue;
      double now = iClose(sym, tf, 0);
      double prev = iClose(sym, tf, lookback);
      if(prev == 0) continue;

      double pct = (now - prev) / prev * 100.0;

      if(StringFind(sym, Currencies[ci]) > 0)
         pct = -pct;

      sum += pct;
      cnt++;
   }
   return (cnt == 0) ? 0 : sum / cnt;
}

As funções UpdateStrengths() e CalculateStrength() calculam a força das moedas. UpdateStrengths() percorre os índices de todas as moedas e chama CalculateStrength() para cada um dos três timeframes.

CalculateStrength() obtém, por meio de iClose(), o preço de fechamento mais recente de cada par relevante e, em seguida, recupera os preços de fechamento históricos correspondentes ao período de análise. A função verifica se há barras suficientes para realizar o cálculo; caso contrário, o par é ignorado para evitar erros. Em seguida, calcula-se a variação percentual ao longo do período analisado. Se a moeda em questão for a moeda de cotação do par, o sinal dessa variação percentual é invertido, para que sua valorização também seja representada por um valor de força positivo.

Essa inversão garante que o fortalecimento da moeda de cotação corresponda ao enfraquecimento da moeda-base, mantendo a consistência dos cálculos. A função soma as variações percentuais dos quatro pares associados a cada moeda e, em seguida, calcula a média desses valores. O resultado é o índice final de força, armazenado no array Strength para exibição no painel e registro no log.

void DrawPanel()
{
   RemovePanel();
   ObjectCreate(0, "CS_BG", OBJ_RECTANGLE_LABEL, 0, 0, 0);
   ObjectSetInteger(0, "CS_BG", OBJPROP_CORNER, CORNER_LEFT_UPPER);
   ObjectSetInteger(0, "CS_BG", OBJPROP_XDISTANCE, PanelX);
   ObjectSetInteger(0, "CS_BG", OBJPROP_YDISTANCE, PanelY);
   ObjectSetInteger(0, "CS_BG", OBJPROP_XSIZE, PanelWidth);
   ObjectSetInteger(0, "CS_BG", OBJPROP_YSIZE, PanelHeight);
   // Add headers, labels, colored bars for each currency
}

A representação visual desses dados fica a cargo de DrawPanel(), que cria um retângulo delimitando a área definida para o painel. Para facilitar a leitura, são adicionados na parte superior cabeçalhos correspondentes a cada timeframe. Em seguida, a função percorre todas as moedas, criando rótulos com o nome da moeda, o valor numérico de sua força com duas casas decimais e uma barra colorida que representa visualmente seu grau de força ou fraqueza.

O esquema de cores utiliza tons de verde para moedas fortes, laranja para moedas neutras e vermelho para moedas fracas, permitindo que o trader avalie rapidamente o cenário do mercado. A largura da barra é proporcional ao valor de força e funciona como um indicador visual adicional. A padronização desses elementos gráficos torna o painel informativo e facilita a interpretação dos dados com uma rápida olhada.

void RemovePanel()
{
   for(int i=ObjectsTotal(0)-1; i>=0; i--)
   {
      string name = ObjectName(0, i);
      if(StringFind(name, "CS_") == 0 || StringFind(name, "Lbl_") == 0 || StringFind(name, "Bar_") == 0)
         ObjectDelete(0, name);
   }
}

Quando o painel precisa ser atualizado ou removido, RemovePanel() exclui todos os objetos associados a ele que utilizam determinados prefixos nos nomes, como "CS_", "Hdr_", "Lbl_", "Val_" e "Bar_". Essa remoção sistemática mantém o gráfico limpo e evita o acúmulo de elementos visuais residuais, permitindo que, a cada atualização, o painel seja recriado do zero sem deixar objetos de versões anteriores.

void DrawEquityLines()
{
   for(int i=1; i< dataCount; i++)
   {
      string id = StringFormat("EQ_%d", i);
      ObjectDelete(0, id);
      ObjectCreate(0, id, OBJ_TREND, 0,
                   times[i-1], equities[i-1],
                   times[i], equities[i]);
      ObjectSetInteger(0, id, OBJPROP_COLOR, clrYellow);
      ObjectSetInteger(0, id, OBJPROP_WIDTH, 2);
   }
}

As funções DrawEquityLines() e DrawDrawdownLines() representam visualmente a evolução da conta. Sempre que novos dados de patrimônio da conta são registrados, essas funções removem os objetos de linha anteriores ("EQ_" e "DD_"), mantendo o gráfico limpo. Em seguida, criam novos objetos de linha conectando os pontos de dados armazenados e usam cores diferentes, amarelo para o patrimônio e vermelho para o drawdown, facilitando a distinção entre eles.

Essas linhas mostram de forma clara como o valor da conta evoluiu e quais foram os maiores drawdowns observados. Esses elementos visuais só são realmente relevantes quando o EA gerencia operações ativamente, pois dependem das alterações no patrimônio da conta provocadas pelas negociações executadas.

void DrawDrawdownLines()
{
   double peak = -DBL_MAX;
   for(int i=1; i< dataCount; i++)
   {
      peak = MathMax(peak, equities[i-1]);
      double dd = equities[i-1] - peak;
      string id = StringFormat("DD_%d", i);
      ObjectDelete(0, id);
      ObjectCreate(0, id, OBJ_TREND, 0,
                   times[i-1], dd,
                   times[i], equities[i] - peak);
      ObjectSetInteger(0, id, OBJPROP_COLOR, clrRed);
      ObjectSetInteger(0, id, OBJPROP_WIDTH, 2);
   }
}

Esse é um ponto importante: embora o código responsável por traçar as linhas de patrimônio e drawdown esteja incluído e efetivamente as desenhe, sua utilidade prática depende, em grande parte, de o EA realizar operações automaticamente. Se o EA tiver caráter exclusivamente informativo ou for utilizado apenas como apoio à negociação manual, o patrimônio da conta só mudará quando o próprio trader abrir ou fechar operações, ou quando houver depósitos ou saques. Nesses casos, o gráfico de patrimônio pode não refletir com precisão a dinâmica das negociações em tempo real, e as linhas podem permanecer praticamente estáticas ou simplesmente oferecer menos informações úteis.

Por isso, esses elementos de visualização são mais valiosos quando integrados a um EA que negocia ativamente em modo automático e altera continuamente o estado da conta por meio das operações executadas. Quando um sistema de negociação automatizada desse tipo está em funcionamento, o gráfico de patrimônio em tempo real permite acompanhar o crescimento da conta, os drawdowns e a evolução geral dos resultados, o que pode ser especialmente útil para a gestão de risco e a avaliação de desempenho.

void LogCurrencyStrengths(int tfIdx)
{
   string sStrong="", sWeak="", sNeutral="";
   for(int i=0; i<8; i++)
   {
      double v = Strength[i][tfIdx];
      if(v > 0.3) sStrong += Currencies[i] + " ";
      else if(v < -0.3) sWeak += Currencies[i] + " ";
      else sNeutral += Currencies[i] + " ";
   }
   Print("Strong: ", sStrong, "| Weak: ", sWeak, "| Neutral: ", sNeutral);
}

Por fim, LogCurrencyStrengths() gera um resumo textual classificando cada moeda como forte, fraca ou neutra com base nos limiares definidos, por exemplo, acima de +0,3% ou abaixo de -0,3%. A função agrupa os códigos das moedas em strings correspondentes a cada categoria e exibe esses resumos na janela do terminal. Esse resumo textual oferece uma visão rápida da situação das principais moedas e complementa a representação gráfica para traders que precisam avaliar o cenário geral de forma imediata.

Resultado

Nesta seção, analisaremos os resultados dos testes do nosso EA no MetaTrader 5.

Acima, é apresentado um diagrama que ilustra o funcionamento do EA após sua execução em um gráfico do MetaTrader 5. Abaixo, os resultados são apresentados em uma tabela, na qual cada valor corresponde à variação percentual.

Moeda	M15	H1	H4
USD	-0,11	+1,12	+2,20
EUR	-0,23	-0,38	-0,38
GBP	+0,20	+0,49	+0,67
JPY	+0,01	-1,44	-2,48
CHF	+0,32	-0,25	-0,33
CAD	+0,17	+0,34	+0,16
AUD	+0,05	+0,71	+0,52
NZD	+0,10	+0,76	+0,13

• O USD continua sendo a moeda mais forte tanto no H1 (+1,12) quanto no H4 (+2,20), apesar da queda de curto prazo observada no M15.
• JPY e EUR continuam sendo as moedas mais fracas no H1 (-1,44 e -0,38) e no H4 (-2,48 e -0,38).
• GBP, CAD, AUD e NZD apresentam força baixa ou moderada no H1/H4 e, portanto, podem ser considerados candidatos secundários à categoria de moedas fortes.

Agora, vejamos quais conclusões para a negociação podem ser extraídas das nossas estimativas de força. No timeframe H4, o USD apresenta +2,20%, enquanto o JPY está em -2,48%. Essa grande diferença indica um claro domínio do USD e fraqueza do JPY, o que favorece a abertura de uma posição comprada em USDJPY. Da mesma forma, o EUR apresenta -0,38% no H4, confirmando novamente o domínio do USD. Nesse caso, vale a pena considerar oportunidades de posições vendidas em EURUSD.

Conclusão

O medidor de força das moedas ajuda a identificar mudanças nos pares de moedas em vários timeframes. Ele oferece uma visão clara da possível direção do mercado. Isso não significa que você deva entrar imediatamente em uma operação; em vez disso, use este EA para encontrar os melhores pontos de entrada e aplique suas próprias estratégias de gestão de risco e seus critérios de confirmação. Esta ferramenta serve como ponto de partida para avaliar a força das moedas e, futuramente, a análise poderá ser aprofundada e a apresentação dos resultados, aprimorada. Acompanhe a evolução deste tema nos próximos projetos.

Data	Nome da ferramenta	Descrição	Versão	Atualizações	Observações
01/10/24	Chart Projector	Script para sobrepor um efeito fantasma ao movimento do preço do dia anterior	1.0	Versão inicial	Ferramenta número 1
18/11/24	Analytical Comment	Apresenta informações do dia anterior em formato de tabela e também projeta a possível direção futura do mercado	1.0	Versão inicial	Ferramenta número 2
27/11/24	Analytics Master	Atualização periódica dos indicadores de mercado a cada duas horas	1.01	Segunda versão	Ferramenta número 3
02/12/24	Analytics Forecaster	Atualização periódica dos indicadores de mercado a cada duas horas, com integração ao Telegram	1.1	Terceira versão	Ferramenta número 4
09/12/24	Volatility Navigator	O EA analisa as condições de mercado usando Bandas de Bollinger, RSI e ATR	1.0	Versão inicial	Ferramenta número 5
19/12/24	Mean Reversion Signal Reaper	Analisa o mercado e gera sinais usando uma estratégia de reversão à média	1.0	Versão inicial	Ferramenta número 6
9/01/25	Signal Pulse	Analisa vários timeframes	1.0	Versão inicial	Ferramenta número 7
17/01/25	Metrics Board	Painel com botões para análise	1.0	Versão inicial	Ferramenta número 8
21/01/25	External Flow	Análise usando bibliotecas externas	1.0	Versão inicial	Ferramenta número 9
27/01/25	VWAP	Preço médio ponderado pelo volume	1.3	Versão inicial	Ferramenta número 10
02/02/25	Heikin Ashi	Suavização da tendência e identificação de sinais de reversão	1.0	Versão inicial	Ferramenta número 11
04/02/25	FibVWAP	Geração de sinais por meio de análise em Python	1.0	Versão inicial	Ferramenta número 12
14/02/25	RSI DIVERGENCE	Divergência entre preço e RSI	1.0	Versão inicial	Ferramenta número 13
17/02/25	Parabolic Stop and Reverse (PSAR)	Automatização da estratégia PSAR	1.0	Versão inicial	Ferramenta número 14
20/02/25	Script Quarters Drawer	Marcação dos níveis de quartos no gráfico	1.0	Versão inicial	Ferramenta número 15
27/02/25	Intrusion Detector	Detecção e emissão de alertas quando o preço atinge os níveis de quartos	1.0	Versão inicial	Ferramenta número 16
27/02/25	TrendLoom Tool	Painel de análise multitimeframe	1.0	Versão inicial	Ferramenta número 17
11/03/25	Quarters Board	Painel com botões para ativar e desativar os níveis de quartos	1.0	Versão inicial	Ferramenta número 18
26/03/25	ZigZag Analyzer	Traçado de linhas de tendência usando o indicador ZigZag	1.0	Versão inicial	Ferramenta número 19
10/04/25	Correlation Pathfinder	Geração de gráficos de correlação entre taxas de câmbio usando bibliotecas Python.	1.0	Versão inicial	Ferramenta número 20
23/04/25	Market Structure Flip Detector Tool	Detecção de reversões na estrutura de mercado	1.0	Versão inicial	Ferramenta número 21
08/05/25	Correlation Dashboard	Correlações entre diferentes pares	1.0	Versão inicial	Ferramenta número 22
13/05/25	Currency Strength Meter	Mede a força de uma moeda com base em vários pares dos quais ela faz parte	1.0	Versão inicial	Ferramenta número 22