English Русский Español Deutsch 日本語
preview
Desenvolvimento de um indicador personalizado de matriz de desempenho da conta de negociação

Desenvolvimento de um indicador personalizado de matriz de desempenho da conta de negociação

MetaTrader 5 — Exemplos |
29 0
Hlomohang John Borotho
Hlomohang John Borotho

Introdução

Muitos traders enfrentam dificuldades relacionadas ao excesso de operações, à falta de disciplina e à tomada de decisões emocionais, especialmente quando precisam operar seguindo as regras rigorosas de uma empresa de prop trading ou administrar seu próprio capital. A tentação de recuperar perdas, aumentar o tamanho dos lotes após uma sequência de operações perdedoras ou ignorar os limites diários frequentemente leva ao descumprimento das regras de drawdown e ao esgotamento prematuro das contas. Até mesmo traders experientes podem deixar de respeitar os limites diários de risco, resultando em retornos inconsistentes e incapacidade de alcançar a rentabilidade de longo prazo ou obter aprovação nas avaliações de prop trading.

A matriz de desempenho da conta oferece uma solução prática ao funcionar como um gestor de riscos integrado e uma ferramenta de orientação para a disciplina operacional. O sistema permite que os traders definam seu próprio percentual de risco diário, sempre respeitando os limites máximos de drawdown, e monitora automaticamente, em tempo real, a situação da conta, os lucros e prejuízos diários e o drawdown. Quando o limite diário de risco é atingido, o indicador sinaliza o estado de risco e emite um alerta para que o trader considere encerrar as posições, ajudando a prevenir a negociação por vingança (revenge trading) e o excesso de operações motivado por emoções. Essa estrutura ajuda os traders a manter a consistência, proteger seu capital e aumentar as chances de aprovação nas avaliações das empresas de prop trading ou de crescimento sustentável de suas contas pessoais.



Planejamento e lógica

1. Configuração de preservação do capital:

  • Saldo da conta = US$ 10.000
  • Drawdown total máximo (6%) = US$ 600
  • Drawdown diário máximo (8%) = US$ 800
  • Risco diário (1%) = US$ 100

As perdas nas operações ficam limitadas a US$ 100 por dia. Isso permite ao trader atingir o drawdown total máximo após 6 dias consecutivos de perdas de US$ 100, dentro dos limites permitidos pela empresa de investimentos.

2. Configuração moderada:

  • Saldo da conta = US$ 10.000
  • Drawdown total máximo (6%) = US$ 600
  • Drawdown diário máximo (8%) = US$ 800
  • Risco diário (2%) = US$ 200

O trader arrisca US$ 200 por dia. Agora, restam cerca de 3 dias até atingir o drawdown máximo. Isso permite negociar de forma mais agressiva, mas reduz a margem de manobra.

3. Configuração agressiva (não recomendada):

  • Saldo da conta = US$ 10.000
  • Drawdown total máximo (6%) = US$ 600
  • Drawdown diário máximo (8%) = US$ 800
  • Risco diário (2%) = US$ 200

Um único dia de perdas pode resultar em um prejuízo de US$ 500, deixando apenas US$ 100 de margem até atingir o limite máximo de drawdown de US$ 600. Sem um controle rigoroso dos riscos, essa configuração praticamente garante o fracasso.

Funcionalidades do indicador:

  • O painel de controle apresenta os indicadores de desempenho da conta.
  • Exibição visual do status de risco das operações.
  • Exibição dos lucros e prejuízos (P/L) das posições abertas diretamente no gráfico.


Lógica de gerenciamento de riscos


Primeiros passos

//+------------------------------------------------------------------+
//|                                                   Acc_Matrix.mq5 |
//|                        GIT under Copyright 2025, MetaQuotes Ltd. |
//|                     https://www.mql5.com/en/users/johnhlomohang/ |
//+------------------------------------------------------------------+
#property copyright "GIT under Copyright 2025, MetaQuotes Ltd."
#property link      "https://www.mql5.com/en/users/johnhlomohang/"
#property version   "1.00"
#property indicator_chart_window
#property indicator_buffers 2
#property indicator_plots   2
#property indicator_type1   DRAW_LINE
#property indicator_color1  clrDodgerBlue
#property indicator_style1  STYLE_SOLID
#property indicator_width1  1
#property indicator_type2   DRAW_LINE
#property indicator_color2  clrCrimson
#property indicator_style2  STYLE_SOLID
#property indicator_width2  1
#include <Trade\Trade.mqh>

//+------------------------------------------------------------------+
//| Input variables                                                  |
//+------------------------------------------------------------------+
input bool     ShowDashboard = true;           // Show performance dashboard
input bool     ShowProfit_Loss = true;         // Show Profit and Loss on the chart
input color    DashboardBGColor = clrWhiteSmoke; // Dashboard background color
input color    TextColor = clrBlack;           // Text color
input int      DashboardX = 20;                // Dashboard X position
input int      DashboardY = 20;                // Dashboard Y position
input int      DashboardWidth = 280;           // Dashboard width
input int      FontSize = 10;                  // Font size

// Performance tracking mode
input bool     TrackFromIndicatorStart = true; // Track from indicator start (true) or overall (false)

// Risk management parameters
input double   DailyRiskPercent = 1.0;         // Daily risk percentage
input double   MaxDailyDrawdownPercent = 10.0; // Max daily drawdown percentage
input double   MaxOverallDrawdownPercent = 8.0; // Max overall drawdown percentage
input bool     EnableRiskManagement = true;    // Enable risk management
input ulong    MagicNumber = 123456;           // Magic number for position identification

Começaremos pela seção de parâmetros de entrada, que permite aos traders personalizar a aparência e o funcionamento do indicador. É possível ativar ou desativar a exibição do painel de monitoramento, mostrar os lucros e prejuízos diretamente no gráfico e ajustar propriedades visuais, como cor de fundo, cor do texto, posicionamento e tamanho da fonte. Essas opções oferecem flexibilidade para adaptar a interface às preferências individuais, mantendo o acesso aos principais dados da conta em tempo real.

Mais importante ainda, os parâmetros de gerenciamento de riscos transformam o indicador em algo além de uma simples ferramenta de visualização. Os traders podem definir seu percentual de risco diário, o percentual máximo de drawdown diário e o percentual máximo de drawdown total, permitindo que o sistema ajude a manter a disciplina e evitar operações imprudentes. Ao ativar a função de gerenciamento de riscos, o indicador pode monitorar as operações por meio de sua identificação pelo número mágico (Magic Number) e emitir alertas quando os limites forem ultrapassados. Essa funcionalidade ajuda os traders a manter a consistência, evitar o excesso de operações e cumprir as regras de avaliação das empresas de prop trading ou seguir estratégias de crescimento de suas contas pessoais.

//+------------------------------------------------------------------+
//| Indicator buffers                                                |
//+------------------------------------------------------------------+
double         BidBuffer[];
double         AskBuffer[];

//+------------------------------------------------------------------+
//| Global variables                                                 |
//+------------------------------------------------------------------+
double         currentProfit;
double         balance;
double         equity;
double         margin;
double         freeMargin;
double         marginLevel;
int            totalOrders;
double         totalProfit;
double         dailyProfit;
datetime       lastTradeTime;
int            winCount;
int            lossCount;
double         maxDrawdown;
double         maxDrawdownPercent;

// Risk management variables
double         initialBalance;
double         dailyHighEquity;
double         dailyLowEquity;
double         dailyStartEquity;
bool           tradingEnabled = true;
string         riskStatus = "Trading Enabled";
color          riskStatusColor = clrGreen;

// Performance tracking variables
int            totalClosedTrades;
int            closedWinCount;
int            closedLossCount;
double         totalGains;
double         totalLosses;
double         largestWin;
double         largestLoss;
double         averageWin;
double         averageLoss;
double         profitFactor;

// Track the last time history was updated
datetime       lastHistoryUpdate;
bool           firstUpdate = true;

Esta seção do código define as variáveis globais utilizadas pelo indicador para monitorar o desempenho, gerenciar riscos e acompanhar o histórico de negociação ao longo das sessões. O primeiro grupo reúne métricas de desempenho da conta, como lucro atual, saldo, patrimônio líquido (equity), margem, margem livre e nível de margem. Também acompanha a quantidade de ordens abertas, o lucro total, o lucro diário, o horário da última operação e a quantidade de operações lucrativas e perdedoras. Além disso, essas variáveis permitem monitorar o drawdown máximo do patrimônio líquido, tanto em valores absolutos quanto percentuais, uma informação fundamental para avaliar a exposição ao risco.

O segundo grupo de variáveis é dedicado ao gerenciamento de riscos. Nele, o código armazena o saldo inicial registrado quando o monitoramento começou, além dos valores máximo, mínimo e inicial do patrimônio líquido em cada dia. Essas métricas permitem acompanhar as variações diárias de desempenho e reforçar a disciplina operacional, identificando violações dos limites de risco diários ou totais. A variável booleana tradingEnabled registra o estado de negociação; quando os limites de risco são atingidos, o sistema emite alertas. A interface visual, implementada por meio da variável de texto riskStatus e da variável riskStatusColor, fornece informações claras diretamente no gráfico, exibindo, por exemplo, a mensagem "Negociação permitida" em verde ou alertas de risco em vermelho.

O último grupo reúne as variáveis de monitoramento de desempenho utilizadas na análise das operações encerradas. Entre elas estão o número total de operações encerradas, a quantidade de operações lucrativas e perdedoras, os lucros e prejuízos acumulados, além do maior lucro e do maior prejuízo registrados em uma única operação. O sistema também calcula os lucros e prejuízos médios e o fator de lucro (profit factor), um importante indicador de desempenho que relaciona os lucros brutos às perdas brutas. Para garantir a precisão das atualizações, o sistema registra o momento da última atualização do histórico e verifica se esta é a primeira atualização desde a inicialização. Em conjunto, essas variáveis oferecem aos traders uma visão abrangente de seu desempenho nas negociações, ajudando a melhorar a consistência dos resultados.

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

   IndicatorSetString(INDICATOR_SHORTNAME, "ACCOUNT PERFORMANCE MATRIX");
   IndicatorSetInteger(INDICATOR_DIGITS, _Digits);
   
   // Initialize variables
   currentProfit = 0.0;
   balance = AccountInfoDouble(ACCOUNT_BALANCE);
   equity = AccountInfoDouble(ACCOUNT_EQUITY);
   
   // Set initial balance based on tracking mode
   if(TrackFromIndicatorStart)
   {
      initialBalance = balance;
   }
   else
   {
      // For overall tracking, use the actual account balance
      initialBalance = AccountInfoDouble(ACCOUNT_BALANCE);
   }
   
   dailyStartEquity = equity;
   dailyHighEquity = equity;
   dailyLowEquity = equity;
   lastHistoryUpdate = TimeCurrent();
   
   // Load historical trade data based on tracking mode
   LoadHistory();
   
   // Create dashboard objects if enabled
   if(ShowDashboard)
   {
      CreateDashboard();
   }
   
   // Set timer to update every second
   EventSetTimer(1);
   
   return(INIT_SUCCEEDED);
}

A função OnInit() inicializa o indicador personalizado, definindo seu nome de exibição e a precisão numérica, além de preparar todas as variáveis utilizadas no monitoramento de desempenho. Ela zera o lucro atual, recupera os valores do saldo e do patrimônio líquido (equity) da conta e determina o saldo inicial conforme a preferência do usuário: acompanhar os resultados desde a instalação do indicador ou considerar todo o histórico da conta. A função também estabelece o patrimônio líquido inicial do dia e registra seus valores máximo e mínimo para avaliar a rentabilidade intradiária. O histórico de operações é carregado por meio de LoadHistory(), fornecendo os dados necessários para os cálculos. Se a exibição do painel estiver ativada, a função CreateDashboard() cria o painel visual de desempenho. Por fim, OnInit() configura um temporizador para executar atualizações a cada segundo, mantendo os indicadores da conta e os elementos visuais do painel sincronizados com a atividade de negociação em tempo real.

//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
{
   // Delete all objects created by the indicator
   ObjectsDeleteAll(0, 0, -1);
   EventKillTimer();
}

//+------------------------------------------------------------------+
//| Timer function                                                   |
//+------------------------------------------------------------------+
void OnTimer()
{
   // Update account information
   UpdateAccountInfo();
   
   // Update historical data periodically to capture new closed trades
   if(TimeCurrent() - lastHistoryUpdate >= 5 || firstUpdate) // Update every 5 seconds or on first run
   {
      LoadHistory();
      lastHistoryUpdate = TimeCurrent();
      firstUpdate = false;
   }
   
   // Update dashboard if enabled
   if(ShowDashboard)
   {
      UpdateDashboard();
   }
   
   // Check risk management rules
   if(EnableRiskManagement)
   {
      CheckRiskManagement();
   }
}

//+------------------------------------------------------------------+
//| 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[])
{
   // Update bid and ask buffers
   if(ShowProfit_Loss)
   {
      UpdatePriceBuffers(rates_total, BidBuffer, AskBuffer, time);
   }
   
   return(rates_total);
}

//+------------------------------------------------------------------+
//| Update account information function                              |
//+------------------------------------------------------------------+
void UpdateAccountInfo()
{
   balance = AccountInfoDouble(ACCOUNT_BALANCE);
   equity = AccountInfoDouble(ACCOUNT_EQUITY);
   margin = AccountInfoDouble(ACCOUNT_MARGIN);
   freeMargin = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
   marginLevel = AccountInfoDouble(ACCOUNT_MARGIN_LEVEL);
   
   // Update daily high/low equity
   if(equity > dailyHighEquity) dailyHighEquity = equity;
   if(equity < dailyLowEquity) dailyLowEquity = equity;
   
   CalculateProfitMetrics();
   CalculateTradeMetrics();
}

A função OnDeinit() garante o encerramento adequado do indicador, removendo todos os objetos gráficos criados por ele e desativando o temporizador para interromper as atualizações periódicas. Isso evita que objetos desnecessários permaneçam no gráfico após a remoção do indicador e impede a continuidade de rotinas que já não precisam ser executadas. A função OnTimer(), acionada a cada segundo, é fundamental para o funcionamento do indicador: atualiza continuamente as informações da conta, mantém os dados do histórico de operações atualizados a cada cinco segundos (ou na primeira execução) e atualiza o painel de desempenho, caso esteja ativado. Além disso, verifica e aplica as regras de gerenciamento de riscos, emitindo alertas em tempo real quando os limites de risco estabelecidos são atingidos.

Enquanto isso, a função OnCalculate() integra o indicador às atualizações do gráfico, garantindo que, quando a exibição de lucros e prejuízos estiver ativada, as linhas Bid e Ask sejam atualizadas por meio dos buffers de preços. A função UpdateAccountInfo() obtém dados atualizados da conta, como saldo, patrimônio líquido (equity), margem e margem livre, além de registrar os valores máximo e mínimo do patrimônio líquido ao longo do dia para monitorar o desempenho com precisão. Em seguida, chama funções auxiliares, como CalculateProfitMetrics() e CalculateTradeMetrics(), para realizar análises adicionais de desempenho. Juntas, essas funções formam um painel de monitoramento que se atualiza automaticamente, considera os riscos da negociação, oferece aos traders uma visão completa da situação da conta e contribui ativamente para a manutenção da disciplina operacional.

//+------------------------------------------------------------------+
//| Update account information function                              |
//+------------------------------------------------------------------+
void UpdateAccountInfo()
{
   balance = AccountInfoDouble(ACCOUNT_BALANCE);
   equity = AccountInfoDouble(ACCOUNT_EQUITY);
   margin = AccountInfoDouble(ACCOUNT_MARGIN);
   freeMargin = AccountInfoDouble(ACCOUNT_MARGIN_FREE);
   marginLevel = AccountInfoDouble(ACCOUNT_MARGIN_LEVEL);
   
   // Update daily high/low equity
   if(equity > dailyHighEquity) dailyHighEquity = equity;
   if(equity < dailyLowEquity) dailyLowEquity = equity;
   
   CalculateProfitMetrics();
   CalculateTradeMetrics();
}

//+------------------------------------------------------------------+
//| Update price buffers with Bid and Ask values                     |
//+------------------------------------------------------------------+
void UpdatePriceBuffers(int rates_total, double &bidBuffer[], double &askBuffer[], const datetime &time[])
{
   double bid = SymbolInfoDouble(_Symbol, SYMBOL_BID);
   double ask = SymbolInfoDouble(_Symbol, SYMBOL_ASK);
   
   // Calculate current profit for open positions
   currentProfit = 0.0;
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      if(PositionGetSymbol(i) == _Symbol)
      {
         currentProfit += PositionGetDouble(POSITION_PROFIT);
      }
   }
   
   // Fill buffers with current bid and ask values
   if(ShowProfit_Loss && rates_total > 0)
   {
      for(int i = 0; i < rates_total; i++)
      {
         bidBuffer[i] = bid;
         askBuffer[i] = ask;
      }
      
      // Calculate position for labels (2 bars to the right of current candle)
      int currentBar = rates_total - 1;
      datetime labelTime = (currentBar + 2 < rates_total) ? time[currentBar + 2] : time[currentBar] + PeriodSeconds() * 2;
      
      // Add profit/loss label with color coding
      string plLabelText;
      color plColor;
      if(currentProfit >= 0)
      {
         plLabelText = "Profit: " + DoubleToString(currentProfit, 2);
         plColor = clrBlue;
      }
      else
      {
         plLabelText = "Loss: " + DoubleToString(currentProfit, 2);
         plColor = clrRed;
      }
      
      CreateOrUpdateLabel("PLLabel", plLabelText, labelTime, (bid + ask) / 2, plColor, ANCHOR_RIGHT);
   }
}

A função UpdateAccountInfo() é responsável por recuperar os dados atualizados da conta e monitorar os principais indicadores de desempenho. Ela obtém o saldo atual, o patrimônio líquido, a margem, a margem livre e o nível de margem da conta de negociação. Além disso, acompanha as variações intradiárias do patrimônio líquido, atualizando seus valores máximo e mínimo sempre que um novo extremo é atingido. Após atualizar os dados básicos da conta, a função chama CalculateProfitMetrics() e CalculateTradeMetrics(), responsáveis por análises mais detalhadas, como o cálculo dos lucros, o acompanhamento das operações lucrativas e perdedoras e a avaliação do desempenho. Isso garante que o painel apresente continuamente as informações mais recentes da conta.

A função UpdatePriceBuffers() concentra-se na visualização dos preços e dos lucros e prejuízos. Primeiro, obtém os preços Bid e Ask atuais e, em seguida, percorre as posições abertas para calcular o lucro ou prejuízo corrente das posições do símbolo ativo. Quando a exibição de lucros e prejuízos está ativada, a função preenche os buffers do indicador com os valores Bid e Ask mais recentes ao longo do gráfico e cria um rótulo posicionado ligeiramente à direita da barra atual. Esse rótulo apresenta o lucro em azul ou o prejuízo em vermelho, conforme o resultado atual da operação. Ao combinar o monitoramento do desempenho da conta com a visualização dos preços e dos resultados em tempo real, a função oferece aos traders informações numéricas e gráficas, ampliando a percepção das condições de negociação e facilitando a tomada de decisões.

//+------------------------------------------------------------------+
//| Create or update text label                                      |
//+------------------------------------------------------------------+
void CreateOrUpdateLabel(string name, string text, datetime time, double price, color clr, ENUM_ANCHOR_POINT anchor)
{
   if(ObjectFind(0, name) < 0)
   {
      ObjectCreate(0, name, OBJ_TEXT, 0, time, price);
      ObjectSetString(0, name, OBJPROP_TEXT, text);
      ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
      ObjectSetInteger(0, name, OBJPROP_ANCHOR, anchor);
      ObjectSetInteger(0, name, OBJPROP_FONTSIZE, FontSize);
   }
   else
   {
      ObjectMove(0, name, 0, time, price);
      ObjectSetString(0, name, OBJPROP_TEXT, text);
      ObjectSetInteger(0, name, OBJPROP_COLOR, clr);
   }
}

//+------------------------------------------------------------------+
//| Calculate profit metrics                                         |
//+------------------------------------------------------------------+
void CalculateProfitMetrics()
{
   totalProfit = equity - initialBalance;
   
   // Calculate max drawdown - FIXED: Prevent division by zero
   double drawdown = dailyHighEquity - equity;
   if(drawdown > maxDrawdown)
   {
      maxDrawdown = drawdown;
      // Avoid division by zero - use a small epsilon if dailyHighEquity is zero
      double denominator = (dailyHighEquity == 0) ? 0.000001 : dailyHighEquity;
      maxDrawdownPercent = (drawdown / denominator) * 100;
   }
}

A função UpdateAccountInfo() é responsável por recuperar os dados atualizados da conta e monitorar os principais indicadores de desempenho. Ela obtém o saldo atual, o patrimônio líquido, a margem, a margem livre e o nível de margem da conta de negociação. Além disso, acompanha as variações intradiárias do patrimônio líquido, atualizando seus valores máximo e mínimo sempre que um novo extremo é atingido. Após atualizar os dados básicos da conta, a função chama CalculateProfitMetrics() e CalculateTradeMetrics(), responsáveis por análises mais detalhadas, como o cálculo dos lucros, o acompanhamento das operações lucrativas e perdedoras e a avaliação do desempenho. Isso garante que o painel apresente continuamente as informações mais recentes da conta.<br0/>

A função UpdatePriceBuffers() concentra-se na visualização dos preços e dos lucros e prejuízos. Primeiro, obtém os preços Bid e Ask atuais e, em seguida, percorre as posições abertas para calcular o lucro ou prejuízo corrente das posições do símbolo ativo. Quando a exibição de lucros e prejuízos está ativada, a função preenche os buffers do indicador com os valores Bid e Ask mais recentes ao longo do gráfico e cria um rótulo posicionado ligeiramente à direita da barra atual. Esse rótulo apresenta o lucro em azul ou o prejuízo em vermelho, conforme o resultado atual da operação. Ao combinar o monitoramento do desempenho da conta com a visualização dos preços e dos resultados em tempo real, a função oferece aos traders informações numéricas e gráficas, ampliando a percepção das condições de negociação e facilitando a tomada de decisões.

//+------------------------------------------------------------------+
//| Calculate trade metrics                                          |
//+------------------------------------------------------------------+
void CalculateTradeMetrics()
{
   totalOrders = PositionsTotal();
   winCount = 0;
   lossCount = 0;
   
   // Count winning and losing positions
   for(int i = PositionsTotal() - 1; i >= 0; i--)
   {
      ulong ticket = PositionGetTicket(i);
      if(PositionSelectByTicket(ticket))
      {
         double profit = PositionGetDouble(POSITION_PROFIT);
         if(profit > 0) winCount++;
         else if(profit < 0) lossCount++;
      }
   }
}

//+------------------------------------------------------------------+
//| Load historical trade data                                       |
//+------------------------------------------------------------------+
void LoadHistory()
{
   datetime startDate = 0;
   if(TrackFromIndicatorStart)
   {
      // Only load history from when the indicator was started
      startDate = TimeCurrent() - 86400; // Load from 24 hours ago to ensure we capture all recent trades
   }
   
   HistorySelect(startDate, TimeCurrent());
   int totalHistory = HistoryDealsTotal();
   
   // Reset counters
   int newClosedTrades = 0;
   int newClosedWinCount = 0;
   int newClosedLossCount = 0;
   double newTotalGains = 0;
   double newTotalLosses = 0;
   double newLargestWin = 0;
   double newLargestLoss = 0;
   
   for(int i = 0; i < totalHistory; i++)
   {
      ulong ticket = HistoryDealGetTicket(i);
      if(ticket > 0)
      {
         // Check if this is a closing deal (not a deposit/withdrawal or opening trade)
         long dealType = HistoryDealGetInteger(ticket, DEAL_TYPE);
         if(dealType == DEAL_TYPE_BUY || dealType == DEAL_TYPE_SELL)
         {
            double profit = HistoryDealGetDouble(ticket, DEAL_PROFIT);
            if(profit != 0)
            {
               newClosedTrades++;
               if(profit > 0)
               {
                  newClosedWinCount++;
                  newTotalGains += profit;
                  if(profit > newLargestWin) newLargestWin = profit;
               }
               else
               {
                  newClosedLossCount++;
                  newTotalLosses += MathAbs(profit);
                  if(profit < newLargestLoss) newLargestLoss = profit;
               }
            }
         }
      }
   }
   
   // Update the global variables
   totalClosedTrades = newClosedTrades;
   closedWinCount = newClosedWinCount;
   closedLossCount = newClosedLossCount;
   totalGains = newTotalGains;
   totalLosses = newTotalLosses;
   largestWin = newLargestWin;
   largestLoss = newLargestLoss;
   
   // Calculate averages and profit factor
   averageWin = (closedWinCount > 0) ? totalGains / closedWinCount : 0;
   averageLoss = (closedLossCount > 0) ? totalLosses / closedLossCount : 0;
   profitFactor = (totalLosses > 0) ? totalGains / totalLosses : (totalGains > 0) ? 1000 : 0;
}

A função CalcculateTradeMetrics() fornece informações atualizadas sobre as posições abertas, contabilizando quantas estão atualmente com lucro e quantas apresentam prejuízo. Primeiro, obtém o número total de posições abertas e, em seguida, percorre cada uma delas em um laço para verificar seu resultado financeiro. Quando uma posição apresenta lucro, incrementa o contador de posições lucrativas; quando apresenta prejuízo, incrementa o contador de posições perdedoras. Essa função oferece aos traders uma visão imediata dos resultados de suas posições abertas, ajudando-os a avaliar, em tempo real, se essas operações estão alinhadas ao plano de negociação.

A função LoadHistory() permite analisar o desempenho histórico com maior profundidade, examinando as operações encerradas dentro de um período específico. Quando o monitoramento está configurado para começar a partir da inicialização do indicador, a função carrega o histórico das últimas 24 horas para garantir a inclusão das operações recentes. Em seguida, percorre os registros históricos e seleciona apenas os negócios de compra e venda que representam o encerramento de posições, ignorando depósitos, saques e outros registros que não correspondem a essas operações. Para cada negócio de encerramento, registra o lucro ou prejuízo, atualiza os contadores de operações lucrativas e perdedoras, acumula os lucros e prejuízos totais e identifica o maior lucro e o maior prejuízo individuais. Por fim, calcula os resultados médios e o fator de lucro (profit factor), uma métrica fundamental que relaciona os lucros brutos às perdas brutas. Essa análise abrangente do desempenho permite aos traders identificar padrões em seu comportamento operacional, avaliar a rentabilidade e manter uma gestão de riscos disciplinada ao longo do tempo.

//+------------------------------------------------------------------+
//| Check risk management rules                                      |
//+------------------------------------------------------------------+
void CheckRiskManagement()
{
   // Check if it's a new day (reset daily equity)
   MqlDateTime today, lastCheck;
   TimeToStruct(TimeCurrent(), today);
   TimeToStruct(TimeCurrent(), lastCheck);
   
   static int lastDay = -1;
   if(today.day != lastDay)
   {
      dailyStartEquity = equity;
      dailyHighEquity = equity;
      dailyLowEquity = equity;
      lastDay = today.day;
      
      // Re-enable trading at the start of a new day
      if(!tradingEnabled)
      {
         tradingEnabled = true;
         riskStatus = "Trading Enabled";
         riskStatusColor = clrGreen;
      }
   }
   
   // Calculate daily drawdown percentage - FIXED: Prevent division by zero
   double dailyDrawdownPercent = 0;
   if(dailyHighEquity > 0) 
   {
      dailyDrawdownPercent = (dailyHighEquity - equity) / dailyHighEquity * 100;
   }
   
   // Calculate overall drawdown percentage - FIXED: Prevent division by zero
   double overallDrawdownPercent = 0;
   if(initialBalance > 0) 
   {
      overallDrawdownPercent = (initialBalance - equity) / initialBalance * 100;
   }
   
   double dailyRiskEquity = dailyStartEquity * (1 - DailyRiskPercent / 100);
   
   // Check if we've hit risk limits
   if(tradingEnabled)
   {
      if(equity <= dailyRiskEquity)
      {
         riskStatus = "Daily Risk Limit Reached";
         riskStatusColor = clrRed;
         tradingEnabled = false;
         Alert("Daily Risk Limit Reached, Consider Closing Open Positions!!!");
         
      }
      else if(dailyDrawdownPercent >= MaxDailyDrawdownPercent)
      {
         riskStatus = "Max Daily Drawdown Reached";
         riskStatusColor = clrRed;
         tradingEnabled = false;
         Alert("Max Daily Drawdown Reached!!!");
         
      }
      else if(overallDrawdownPercent >= MaxOverallDrawdownPercent)
      {
         riskStatus = "Max Overall Drawdown Reached";
         riskStatusColor = clrRed;
         tradingEnabled = false;
         Alert("Max Overall Drawdown Reached!!!");
         
      }
   }
}

//+------------------------------------------------------------------+
//| Create dashboard function                                        |
//+------------------------------------------------------------------+
void CreateDashboard()
{
   // Create background rectangle
   ObjectCreate(0, "DashboardBG", OBJ_RECTANGLE_LABEL, 0, 0, 0);
   ObjectSetInteger(0, "DashboardBG", OBJPROP_XDISTANCE, DashboardX);
   ObjectSetInteger(0, "DashboardBG", OBJPROP_YDISTANCE, DashboardY);
   ObjectSetInteger(0, "DashboardBG", OBJPROP_XSIZE, DashboardWidth);
   ObjectSetInteger(0, "DashboardBG", OBJPROP_YSIZE, 320);
   ObjectSetInteger(0, "DashboardBG", OBJPROP_BGCOLOR, DashboardBGColor);
   ObjectSetInteger(0, "DashboardBG", OBJPROP_BORDER_TYPE, BORDER_FLAT);
   ObjectSetInteger(0, "DashboardBG", OBJPROP_BORDER_COLOR, clrGray);
   ObjectSetInteger(0, "DashboardBG", OBJPROP_BACK, true);
   ObjectSetInteger(0, "DashboardBG", OBJPROP_SELECTABLE, false);
   ObjectSetInteger(0, "DashboardBG", OBJPROP_SELECTED, false);
   ObjectSetInteger(0, "DashboardBG", OBJPROP_HIDDEN, true);
   ObjectSetInteger(0, "DashboardBG", OBJPROP_ZORDER, 0);
   
   // Create title
   ObjectCreate(0, "DashboardTitle", OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, "DashboardTitle", OBJPROP_XDISTANCE, DashboardX + 10);
   ObjectSetInteger(0, "DashboardTitle", OBJPROP_YDISTANCE, DashboardY + 10);
   ObjectSetString(0, "DashboardTitle", OBJPROP_TEXT, "ACCOUNT PERFORMANCE MATRIX");
   ObjectSetInteger(0, "DashboardTitle", OBJPROP_COLOR, TextColor);
   ObjectSetInteger(0, "DashboardTitle", OBJPROP_FONTSIZE, FontSize + 2);
   
   // Create tracking mode indicator
   string trackingMode = TrackFromIndicatorStart ? "From Indicator Start" : "Overall Account";
   ObjectCreate(0, "TrackingModeLabel", OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, "TrackingModeLabel", OBJPROP_XDISTANCE, DashboardX + 10);
   ObjectSetInteger(0, "TrackingModeLabel", OBJPROP_YDISTANCE, DashboardY + 30);
   ObjectSetString(0, "TrackingModeLabel", OBJPROP_TEXT, "Tracking: " + trackingMode);
   ObjectSetInteger(0, "TrackingModeLabel", OBJPROP_COLOR, clrDarkBlue);
   ObjectSetInteger(0, "TrackingModeLabel", OBJPROP_FONTSIZE, FontSize);
   
   // Create information labels
   CreateDashboardLabel("RiskStatusLabel", "Trading Status: ", 50, DashboardX, DashboardY);
   CreateDashboardLabel("BalanceLabel", "Balance: ", 70, DashboardX, DashboardY);
   CreateDashboardLabel("EquityLabel", "Equity: ", 90, DashboardX, DashboardY);
   CreateDashboardLabel("DailyProfitLabel", "Daily P/L: ", 110, DashboardX, DashboardY);
   CreateDashboardLabel("TotalProfitLabel", "Total P/L: ", 130, DashboardX, DashboardY);
   CreateDashboardLabel("PositionsLabel", "Open Positions: ", 150, DashboardX, DashboardY);
   CreateDashboardLabel("WinRateLabel", "Win Rate: ", 170, DashboardX, DashboardY);
   CreateDashboardLabel("DailyRiskLabel", "Daily Risk: ", 190, DashboardX, DashboardY);
   CreateDashboardLabel("DailyDrawdownLabel", "Daily Drawdown: ", 210, DashboardX, DashboardY);
   CreateDashboardLabel("TotalDrawdownLabel", "Total Drawdown: ", 230, DashboardX, DashboardY);
   CreateDashboardLabel("ProfitFactorLabel", "Profit Factor: ", 250, DashboardX, DashboardY);
   CreateDashboardLabel("TradesLabel", "Total Trades: ", 270, DashboardX, DashboardY);
   CreateDashboardLabel("AvgWinLossLabel", "Avg Win/Loss: ", 290, DashboardX, DashboardY);
}

A função CheckRiskManagement() atua como um mecanismo de controle para ajudar os traders a cumprir seu plano de gerenciamento de riscos e evitar que os limites da conta sejam ultrapassados. A função calcula os percentuais de drawdown diário e total, verificando cuidadosamente os denominadores para evitar erros de divisão por zero. Em seguida, compara o saldo atual da conta com os limites previamente definidos pelo trader: risco diário, drawdown diário máximo e drawdown total máximo. Se qualquer um desses limites for ultrapassado, a mensagem de status passa a ser exibida em vermelho e são emitidos alertas para avisar o trader. Essa abordagem não apenas ajuda a prevenir perdas catastróficas, mas também reforça a disciplina operacional, reduzindo a tentação de continuar negociando após atingir os limites de risco estabelecidos.

A função CreateDashboard() cria uma interface visual que apresenta todos os indicadores monitorados em um painel bem estruturado e de fácil interpretação. Primeiro, cria um retângulo de fundo com as cores, dimensões e bordas definidas pelo usuário, que serve como área de exibição dos dados de desempenho. Em seguida, adiciona um título e uma identificação do modo de monitoramento, indicando se o painel acompanha os resultados desde a inicialização do indicador ou considera todo o histórico da conta. Abaixo, os indicadores são distribuídos em linhas, com campos e rótulos correspondentes, incluindo saldo, patrimônio líquido (equity), lucro e prejuízo diário e total, percentual de operações lucrativas, drawdown, fator de lucro (profit factor) e lucro e prejuízo médios. Esse painel permite que os traders avaliem rapidamente a situação da conta e o nível de risco, sem precisar consultar diversos relatórios, facilitando o acompanhamento dos resultados e a manutenção da disciplina operacional.

//+------------------------------------------------------------------+
//| Create dashboard label helper function                           |
//+------------------------------------------------------------------+
void CreateDashboardLabel(string name, string text, int yOffset, int x, int y)
{
   ObjectCreate(0, name, OBJ_LABEL, 0, 0, 0);
   ObjectSetInteger(0, name, OBJPROP_XDISTANCE, x + 10);
   ObjectSetInteger(0, name, OBJPROP_YDISTANCE, y + yOffset);
   ObjectSetString(0, name, OBJPROP_TEXT, text);
   ObjectSetInteger(0, name, OBJPROP_COLOR, TextColor);
   ObjectSetInteger(0, name, OBJPROP_FONTSIZE, FontSize);
}

//+------------------------------------------------------------------+
//| Update dashboard function                                        |
//+------------------------------------------------------------------+
void UpdateDashboard()
{
   // Update risk status with color coding
   ObjectSetString(0, "RiskStatusLabel", OBJPROP_TEXT, "Trading Status: " + riskStatus);
   ObjectSetInteger(0, "RiskStatusLabel", OBJPROP_COLOR, riskStatusColor);
   
   // Update values for all dashboard labels
   UpdateDashboardLabel("BalanceLabel", "Balance: " + DoubleToString(balance, 2));
   UpdateDashboardLabel("EquityLabel", "Equity: " + DoubleToString(equity, 2));
   
   // Color code profit values
   double dailyPL = equity - dailyStartEquity;
   string dailyPLText = "Daily P/L: ";
   if(dailyPL >= 0) dailyPLText += "+" + DoubleToString(dailyPL, 2);
   else dailyPLText += DoubleToString(dailyPL, 2);
   UpdateDashboardLabel("DailyProfitLabel", dailyPLText);
   
   string totalPLText = "Total P/L: ";
   if(totalProfit >= 0) totalPLText += "+" + DoubleToString(totalProfit, 2);
   else totalPLText += DoubleToString(totalProfit, 2);
   UpdateDashboardLabel("TotalProfitLabel", totalPLText);
   
   UpdateDashboardLabel("PositionsLabel", "Open Positions: " + IntegerToString(totalOrders));
   
   // Calculate and display win rate from closed trades
   int totalTrades = closedWinCount + closedLossCount;
   string winRateText = "Win Rate: ";
   if(totalTrades > 0) 
   {
      double winRate = (double)closedWinCount / totalTrades * 100;
      winRateText += DoubleToString(winRate, 1) + "% (" + IntegerToString(closedWinCount) + 
                    "/" + IntegerToString(totalTrades) + ")";
   }
   else winRateText += "N/A";
   UpdateDashboardLabel("WinRateLabel", winRateText);
   
   // Risk metrics
   double dailyRiskEquity = dailyStartEquity * (1 - DailyRiskPercent / 100);
   
   // Calculate drawdown percentages with zero division protection
   double dailyDrawdownPercent = 0;
   if(dailyHighEquity > 0) 
   {
      dailyDrawdownPercent = (dailyHighEquity - equity) / dailyHighEquity * 100;
   }
   
   double overallDrawdownPercent = 0;
   if(initialBalance > 0) 
   {
      overallDrawdownPercent = (initialBalance - equity) / initialBalance * 100;
   }
   
   UpdateDashboardLabel("DailyRiskLabel", "Daily Risk: " + DoubleToString(DailyRiskPercent, 1) + 
                       "% (" + DoubleToString(dailyRiskEquity, 2) + ")");
   
   string dailyDrawdownText = "Daily Drawdown: " + DoubleToString(dailyDrawdownPercent, 1) + "%";
   UpdateDashboardLabel("DailyDrawdownLabel", dailyDrawdownText);
   
   string totalDrawdownText = "Total Drawdown: " + DoubleToString(overallDrawdownPercent, 1) + "%";
   UpdateDashboardLabel("TotalDrawdownLabel", totalDrawdownText);
   
   // Performance metrics
   UpdateDashboardLabel("ProfitFactorLabel", "Profit Factor: " + DoubleToString(profitFactor, 2));
   UpdateDashboardLabel("TradesLabel", "Total Trades: " + IntegerToString(totalClosedTrades));
   UpdateDashboardLabel("AvgWinLossLabel", "Avg Win/Loss: " + DoubleToString(averageWin, 2) + 
                       "/" + DoubleToString(MathAbs(averageLoss), 2));
}

//+------------------------------------------------------------------+
//| Update dashboard label helper function                           |
//+------------------------------------------------------------------+
void UpdateDashboardLabel(string name, string text)
{
   ObjectSetString(0, name, OBJPROP_TEXT, text);
}

A função CreateDashboardLabel() é uma função auxiliar que facilita a criação de campos identificados por rótulos no painel de monitoramento. Cada rótulo é criado com um nome, texto e deslocamento de posição específicos, seguindo uma formatação padronizada, que inclui propriedades como tamanho e cor da fonte. Isso garante que todos os indicadores do painel sejam apresentados com clareza e consistência visual, oferecendo aos traders uma visão organizada do desempenho da conta e de seu nível de risco.

A função UpdateDashboard() mantém o painel de monitoramento atualizado com os dados mais recentes da conta e seus indicadores de desempenho. Ela atualiza todas as principais métricas, incluindo saldo, patrimônio líquido, lucro e prejuízo diário e total, posições abertas, percentual de operações lucrativas, drawdown, risco diário, fator de lucro, número total de operações e percentuais médios de operações lucrativas e perdedoras. Além disso, utiliza cores para destacar informações importantes, como lucros, prejuízos e status das operações, permitindo uma interpretação visual imediata. Ao apresentar continuamente a situação da conta em tempo real, o sistema ajuda os traders a tomar decisões fundamentadas, reforça a disciplina operacional e contribui para evitar o excesso de operações, indicando claramente quando os limites de risco são atingidos.

Demonstração do indicador:



Conclusão

Em resumo, desenvolvemos um indicador personalizado de matriz de desempenho da conta que monitora tanto a atividade de negociação em tempo real quanto os resultados históricos. O indicador acompanha as principais métricas da conta, como saldo, patrimônio líquido, margem, posições abertas, lucro e prejuízo diário e total, percentual de operações lucrativas, drawdown, fator de lucro (profit factor) e relação média entre operações lucrativas e perdedoras. Ele conta com um painel dinâmico, com rótulos visuais e alertas por cores, que oferece aos traders uma visão clara e organizada do desempenho da conta. O sistema também incorpora regras de gerenciamento de riscos para controlar o cumprimento dos limites diários de risco e de drawdown máximo. Quando esses limites são atingidos, o sistema emite alertas, mantendo o trader informado sobre a situação atual da conta.

Em conclusão, esse indicador ajuda os traders a manter a disciplina, evitar o excesso de operações e tomar decisões mais fundamentadas, oferecendo uma visão clara da situação da conta e de sua exposição ao risco. Ao indicar claramente quando os limites de risco estão próximos de ser atingidos ou já foram ultrapassados, a ferramenta incentiva um comportamento operacional consistente e contribui para o crescimento sustentável do capital. Seja para se preparar para uma avaliação de uma empresa de prop trading ou para gerenciar uma conta pessoal de negociação, o indicador oferece orientações estruturadas para gerenciar riscos, aprimorar as decisões de negociação e, em última análise, aumentar a rentabilidade no longo prazo.

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

Arquivos anexados |
Acc_Matrix.mq5 (25.52 KB)
Oscilador Parafrac V2: integração do Parabolic SAR e da amplitude média verdadeira (Average True Range) Oscilador Parafrac V2: integração do Parabolic SAR e da amplitude média verdadeira (Average True Range)
O oscilador Parafrac V2 é uma ferramenta avançada de análise técnica que combina o indicador Parabolic SAR (indicador parabólico de "parada e reversão") com o indicador de amplitude média verdadeira (Average True Range, ATR) para superar as limitações de seu antecessor, que utilizava fractais e apresentava picos de sinal capazes de encobrir os sinais anteriores e atuais. Ao incorporar o ATR como medida de volatilidade, a versão 2 oferece um método mais suave e confiável para identificar tendências, reversões e divergências, ajudando os traders a reduzir a sobrecarga visual dos gráficos e a paralisia por análise.
Pipelines de processamento de dados em MQL5 Pipelines de processamento de dados em MQL5
Neste artigo, vamos explorar uma etapa fundamental da preparação de dados para machine learning, cuja importância vem crescendo rapidamente: os pipelines de pré-processamento de dados. Em essência, eles consistem em uma sequência simplificada de etapas de transformação que preparam os dados brutos antes de sua entrada no modelo. Embora essa "padronização dos dados" possa parecer pouco interessante para quem não está familiarizado com o assunto, ela não apenas reduz o tempo de treinamento e os custos de execução, como também contribui significativamente para melhorar a capacidade de generalização do modelo. Vamos nos concentrar em algumas funcionalidades de pré-processamento do SCIKIT-LEARN. Embora não utilizemos o Assistente MQL5 neste artigo, voltaremos a abordá-lo nas próximas publicações.
Introdução à linguagem MQL5 (Parte 21): Detecção automática do padrão de Gartley Introdução à linguagem MQL5 (Parte 21): Detecção automática do padrão de Gartley
Aprenda a detectar e visualizar o padrão harmônico de Gartley no MetaTrader 5 usando a linguagem MQL5. Este artigo explica cada etapa, desde a identificação dos pontos de swing até a aplicação das proporções de Fibonacci e o desenho completo do padrão no gráfico, permitindo uma confirmação visual clara.
Do iniciante ao especialista: negociação com níveis de Fibonacci após a divulgação do NFP Do iniciante ao especialista: negociação com níveis de Fibonacci após a divulgação do NFP
Nos mercados financeiros, as correções de preço estão entre os fenômenos mais recorrentes e consolidados. Existe uma regra empírica segundo a qual o preço sempre apresenta movimentos de retorno, seja após movimentos de grande amplitude ou mesmo em pequenos padrões formados por ticks, que frequentemente assumem a forma de um zigue-zague. No entanto, o padrão de retração não é fixo: sua extensão é incerta e depende das expectativas do mercado. Essa incerteza explica por que os traders utilizam vários níveis de Fibonacci, cada um com determinada probabilidade de influenciar o comportamento dos preços.