Desenvolvimento de ferramentas para análise de Price Action (Parte 38): VWAP baseada em buffer de ticks e módulo de cálculo de desequilíbrio em janela curta
Sumário
- Introdução
- Visão detalhada das principais funcionalidades da ferramenta
- Implementação em MQL5
- Resultados
- Conclusão
Introdução
A maioria dos traders percebe rapidamente que os gráficos de preços não revelam tudo o que acontece no mercado. Os fatores que realmente impulsionam os movimentos de preços estão em uma camada mais profunda, no livro de ofertas, onde as ordens de compra (bids) e venda (asks) revelam quem está aguardando para comprar, quem está pronto para vender e onde a liquidez está concentrada. Traders profissionais utilizam essas informações diariamente para identificar com precisão as zonas de oferta e demanda, detectar desequilíbrios e avaliar com maior precisão os movimentos de preços no curto prazo.
No entanto, os traders de varejo raramente têm acesso a essas informações. Muitas plataformas sequer oferecem acesso direto ao livro de ofertas, enquanto outras disponibilizam apenas dados atrasados ou incompletos, frequentemente mediante uma assinatura adicional. Em plataformas populares entre os traders de varejo, como o MetaTrader 5, a transparência depende inteiramente da corretora. Por isso, a maioria desses traders precisa operar sem os sinais de microestrutura de mercado que há muito fazem parte da rotina dos profissionais.
O Slippage Tool foi desenvolvido para suprir essa lacuna. Embora não pretenda reproduzir um livro de ofertas completo nem um fluxo bruto de cotações, a ferramenta reconstrói os sinais mais úteis que os traders normalmente extraem da profundidade de mercado, utilizando apenas os dados de ticks disponíveis em qualquer corretora. Ela calcula a VWAP (preço médio ponderado pelo volume) para identificar onde a atividade está concentrada, mede os desequilíbrios de ordens no curto prazo para avaliar a pressão direcional e agrega os volumes de ticks para oferecer uma visão mais clara da atividade recente dos participantes do mercado. Esses indicadores são então analisados em conjunto com o spread e o contexto fornecido pelo ATR, ajudando os traders a identificar quando as condições de mercado favorecem seu viés direcional.
Exibida diretamente no gráfico, com alertas e marcadores de operações, a ferramenta oferece aos traders de varejo uma maneira prática de estimar o fluxo de ordens. Assim, é possível acompanhar mudanças nos pontos de concentração da liquidez, identificar desequilíbrios e escolher com mais precisão os momentos de entrada, mesmo sem acesso a um livro de ofertas profissional.
O esquema abaixo ilustra esse conceito na prática. Observe o movimento de baixa entre os pontos E e F. Não se trata de uma queda contínua: o mercado oscila, forma máximas e mínimas temporárias e, ao mesmo tempo, varre níveis de liquidez. Um trader que abre uma posição vendida no ponto C pode acertar a direção do mercado, mas, se a gestão de risco for inadequada ou o lote utilizado for muito grande, a correção até o ponto D pode forçá-lo a sair da operação. O Slippage Tool apresenta uma abordagem diferente para essa situação: abrir uma posição comprada no ponto C e encerrá-la no ponto D, transformando uma possível perda em uma oportunidade de negociação com risco controlado. Da mesma forma, quando o preço sobe a partir do ponto A, a ferramenta identifica o ponto B como uma zona favorável para venda, ajudando os traders a operar os movimentos de swing, em vez de serem retirados de suas posições por eles.

A negociação nos mercados financeiros sempre envolverá volatilidade, reversões e armadilhas de liquidez. A diferença fundamental está em saber se esses movimentos acabam retirando os traders do mercado ou se oferecem oportunidades para melhorar a gestão de risco e a execução das operações. O Slippage Tool não elimina a incerteza, mas oferece uma visão mais clara da estrutura do mercado diretamente no gráfico, reduzindo a distância entre os recursos disponíveis nas plataformas de varejo e a infraestrutura utilizada pelos traders profissionais.
As próximas seções apresentam em detalhes o funcionamento da ferramenta, o significado de cada indicador principal e como esses recursos podem contribuir para melhorar as decisões de negociação. Seja para um trader discricionário em busca de pontos de entrada mais precisos ou para um desenvolvedor de algoritmos interessado em novas fontes de sinais, o Slippage Tool oferece uma solução leve e prática para uma das limitações mais persistentes do trading de varejo: o acesso restrito a dados confiáveis sobre a profundidade de mercado.
Visão detalhada das principais funcionalidades da ferramenta
O Slippage Tool é um sistema para MetaTrader 5 que funciona diretamente no gráfico e reconstrói sinais de fluxo de ordens a partir de dados de ticks em tempo real, incluindo VWAP, desequilíbrio de ticks/volume, spread e contexto fornecido pelo ATR. A ferramenta sinaliza oportunidades de negociação por meio de alertas e marcadores e, opcionalmente, incorpora o slippage estimado aos cálculos de risco e tamanho do lote. Dessa forma, oferece uma alternativa prática às informações do livro de ofertas quando o livro de ofertas não está disponível.
A seguir, apresentamos os cálculos matemáticos e as explicações detalhadas das principais funcionalidades do sistema.
1. VWAP (preço médio ponderado pelo volume)
No artigo anterior, expliquei detalhadamente a VWAP (Volume Weighted Average Price). Trata-se de um indicador de referência que combina dados de preço e volume para calcular o preço médio ponderado pelo volume durante determinado período. Diferentemente da média aritmética simples, que atribui o mesmo peso a cada preço observado, a VWAP dá maior importância aos níveis de preço em que houve maior volume negociado. Com isso, o indicador representa com precisão os níveis de preço que concentraram a maior parte da atividade de negociação, refletindo o consenso efetivo do mercado durante o período analisado.
Ao incorporar o volume ao cálculo, a VWAP oferece uma estimativa mais representativa do "valor justo" do mercado, pois considera a intensidade das negociações em diferentes níveis de preço. Traders e participantes institucionais utilizam frequentemente a VWAP para avaliar as condições de mercado, identificar possíveis pontos de entrada e saída e determinar a direção predominante dos preços em relação a essa referência. Por acompanhar dinamicamente o mercado, a VWAP também serve como um indicador confiável para avaliar os movimentos intradiários dos preços e as condições de liquidez. Isso a torna uma ferramenta importante tanto para estratégias de execução de ordens quanto para análises mais abrangentes do mercado.

Onde:
𝑃(i) = preço do i-ésimo tick𝑉(i) = volume atribuído ao i-ésimo tick
Quando o preço está acima da VWAP, significa que o mercado está sendo negociado acima de seu preço médio ponderado pelo volume, indicando um sentimento de alta. Por outro lado, quando o preço está abaixo da VWAP, isso indica que ele está sendo negociado com desconto em relação a essa referência, refletindo uma tendência de baixa. Os traders frequentemente utilizam a VWAP como um nível dinâmico de suporte ou resistência, tomando-a como referência para suas decisões de negociação.

Como nem todas as corretoras disponibilizam dados completos do livro de ofertas, a ferramenta calcula a linha da VWAP utilizando exclusivamente os dados de ticks recebidos em tempo real. Essa abordagem oferece aos traders referências comparáveis às fornecidas pelas "zonas de valor justo" identificadas no livro de ofertas. Assim, a VWAP funciona como um indicador importante do equilíbrio do mercado e contribui para decisões de negociação mais fundamentadas.
2. Desequilíbrio
O indicador de desequilíbrio (Imbalance) mostra qual lado predomina na atividade de negociação: compradores agressivos ou vendedores agressivos. Em um livro de ofertas tradicional, esse desequilíbrio costuma ser avaliado pela comparação entre os volumes das ordens de compra e venda disponíveis. Entretanto, quando não há acesso direto aos dados do livro de ofertas, a ferramenta estima indiretamente o desequilíbrio do mercado a partir do comportamento dos ticks, oferecendo uma alternativa para medir a pressão direcional e avaliar o sentimento do mercado.

Onde:
BuyVolume = soma dos volumes de ticks associados a movimentos de alta do preço
SellVolume = soma dos volumes de ticks associados a movimentos de baixa do preço
Um desequilíbrio positivo indica pressão compradora, ou seja, predominância de compradores mais agressivos. Já um desequilíbrio negativo indica pressão vendedora, refletindo a predominância de vendedores mais agressivos.

A ferramenta acompanha as variações de preço a cada tick. Cada movimento de alta é classificado como atividade compradora, enquanto cada movimento de baixa é classificado como atividade vendedora. Esse cálculo contínuo, realizado em tempo real, permite identificar qual lado exerce maior influência sobre o mercado em determinado momento, oferecendo informações importantes sobre a dinâmica direcional do mercado no curto prazo.
3. Spread
O spread é uma das características mais fundamentais e importantes da microestrutura de mercado. Ele representa o custo da execução imediata de uma ordem e indica quanto o trader precisa "pagar" para executar uma ordem a mercado sem demora. Esse indicador fornece informações importantes sobre as condições de liquidez e a eficiência geral do mercado, pois reflete os custos de transação associados à execução rápida das operações.
![]()
Um spread reduzido geralmente indica condições de mercado com boa liquidez e eficiência, favorecendo negociações mais fluidas e com custos menores. Por outro lado, um spread elevado indica menor liquidez, custos de transação mais altos e, em alguns casos, pode sinalizar condições de estresse ou incerteza no mercado.

A ferramenta monitora continuamente o spread em tempo real. Os sinais podem ser filtrados de acordo com limites de spread predefinidos, ajudando os traders a evitar entradas em períodos nos quais os custos de transação estão excepcionalmente altos. Essa abordagem reproduz o comportamento dos traders que acompanham o livro de ofertas e evitam negociar quando a profundidade de mercado é insuficiente, favorecendo condições de execução mais vantajosas.
4. Fluxo
O indicador de fluxo (Flow) funciona como um indicador de sentimento de curto prazo, mostrando se os ticks de alta ou de baixa predominam em uma determinada janela móvel. Ele reflete a pressão atual do fluxo de ordens e oferece aos traders uma visão imediata do momentum predominante no mercado.

- Onde:

Um valor de fluxo positivo indica que a maioria dos ticks contabilizados corresponde a movimentos de alta dos preços, refletindo pressão compradora. Por outro lado, um valor de fluxo negativo indica que a maioria dos ticks contabilizados corresponde a movimentos de baixa dos preços, refletindo pressão vendedora.
Ao contabilizar ticks de alta e de baixa em tempo real, a ferramenta apresenta uma visão dinâmica da pressão exercida pelo fluxo de ordens no curto prazo. Essa abordagem reproduz de maneira aproximada a interpretação que um trader faria das mudanças nos desequilíbrios do livro de ofertas, oferecendo informações valiosas sobre o sentimento atual do mercado e seu viés direcional.

Em conjunto, esses quatro recursos (VWAP, desequilíbrio, spread e fluxo) reproduzem os principais sinais extraídos do livro de ofertas. Para isso, extraem informações essenciais sobre a dinâmica do mercado exclusivamente de dados brutos de ticks, fornecendo informações valiosas sobre a microestrutura de mercado mesmo em corretoras que não oferecem suporte completo ao livro de ofertas.
Implementação em MQL5
Nesta seção, mostrarei passo a passo como desenvolver a ferramenta Slippage Tool em MQL5.
Cabeçalho do arquivo, diretivas include e declarações antecipadas.
No início do arquivo, o código define os metadados (#property), inclui o arquivo Trade.mqh e declara antecipadamente as assinaturas das funções de cálculo da VWAP e do fluxo, permitindo utilizá-las antes de suas respectivas definições. O cabeçalho cumpre três funções práticas: registra a autoria e a versão para facilitar a manutenção futura, ativa o modo estrito de compilação, que aplica regras mais rigorosas e seguras da linguagem MQL5 moderna, e declara as dependências necessárias para que o EA possa executar rotinas de negociação caso seja adicionada, posteriormente, uma lógica de entradas automáticas. As declarações antecipadas são um recurso simples que oferece maior flexibilidade na estruturação do código: permitem posicionar funções de alto nível em qualquer parte do arquivo, independentemente da ordem em que suas definições aparecem. Do ponto de vista da manutenção, esse bloco inicial oferece uma visão geral da estrutura do arquivo. Ele identifica os recursos externos disponíveis, como handles de indicadores e funções auxiliares de negociação, além de apresentar as principais métricas que serão implementadas nas seções seguintes.
// File metadata and includes #property copyright "Copyright 2025, MetaQuotes Ltd." #property link "https://www.mql5.com/ru/users/lynnchris" #property version "1.0" #property strict #include <Trade\Trade.mqh> // CTrade utility for possible auto-trade usage
Enumerações e parâmetros de entrada (opções de configuração).
As definições de enumerações (enum) e a extensa lista de variáveis de entrada compõem a API pública da ferramenta. São esses parâmetros que permitem ao trader ajustar seu funcionamento sem modificar o código. As enumerações fornecem nomes claros para as opções da interface (posicionamento do painel nos cantos do gráfico e modos de alerta). Os parâmetros de entrada incluem as configurações essenciais para a geração de sinais: a janela de cálculo da VWAP em minutos, a janela de desequilíbrio em segundos, a relação entre spread e ATR para identificar spreads de baixo custo, o limiar do indicador de fluxo e a histerese dos alertas, o percentual de risco e o multiplicador do ATR utilizado nos stops, além de diversas opções de interface e aparência. Disponibilizar esses valores como parâmetros de entrada é uma decisão importante de projeto, pois torna o EA adaptável a diferentes instrumentos financeiros e estilos de negociação.
Em um artigo com esse nível de detalhamento, é importante explicar os intervalos recomendados para cada parâmetro de entrada e as vantagens e limitações de cada configuração. Por exemplo, janelas mais longas de cálculo da VWAP proporcionam maior estabilidade, mas reduzem a capacidade de resposta às variações de curto prazo. Da mesma forma, aumentar o valor de InpImbWindowSec suaviza as oscilações do indicador de fluxo, mas reduz sua sensibilidade aos sinais de microestrutura de mercado. Também é importante destacar que a ferramenta já possui valores padrão adequados, embora seja recomendável ajustá-los conforme a frequência de chegada dos ticks e as características da microestrutura de cada instrumento.
// Enums (UI choices) and user-exposed inputs (tuning knobs) enum eCorner { COR_LT=0, COR_LB=1, COR_RT=2, COR_RB=3 }; enum eAlertMode { AM_SINGLE=0, AM_ROLLING_CLEAR=1, AM_POOL_REUSE=2 }; input int InpVWAPminutes = 1440; // VWAP window in minutes (rolling) input int InpImbWindowSec = 30; // Imbalance/flow window in seconds input double InpCheapSpreadFrac = 0.50; // Spread < ATR * this fraction => "cheap" input double InpFlowTh = 0.30; // flow threshold for alerts input double InpFlowHystFactor = 0.80; // hysteresis factor for flow reset input double InpRiskPct = 1.0; // risk per trade as % of balance input double InpStopATRmult = 1.2; // stop = ATR * this multiplier input uint InpRingSize = 20000; // tick ring buffer size input uint InpTimerSec = 2; // UI refresh / aggregation cadence
Variáveis globais e convenções de nomenclatura.
As variáveis globais inicializam o estado operacional do sistema, incluindo as configurações do símbolo, os parâmetros de mercado (g_point, g_tickVal), o handle do indicador ATR, o objeto CTrade e os arrays que implementam o buffer circular de ticks. O código utiliza o prefixo g_ para identificar os objetos criados no gráfico. Essa convenção de nomenclatura é fundamental para garantir a remoção segura dos objetos, pois permite que o EA manipule apenas seus próprios elementos gráficos, sem excluir acidentalmente objetos pertencentes a outros indicadores.
Os arrays do buffer circular (g_time, g_bid, g_ask, g_last, g_vol), juntamente com os índices g_head, g_used e g_size, constituem a base de todos os cálculos agregados. O armazenamento local dos ticks evita chamadas repetidas à API da plataforma, favorece a reprodutibilidade dos cálculos e permite agregar os dados por janelas temporais. As variáveis globais também armazenam valores anteriores para detectar alterações e evitar atualizações visuais desnecessárias da interface. É importante ressaltar que, em MQL5, o estado global exige uma gestão cuidadosa, pois o terminal opera em uma única thread, e vazamentos de memória associados a handles de indicadores ou objetos gráficos não removidos são problemas comuns que podem passar despercebidos.
// Globals: symbol settings, ring-buffer arrays and indices string g_sym=""; double g_point=0.0, g_tickVal=0.0, g_tickSize=0.0; double g_volMin=0, g_volMax=0, g_volStep=0; int g_atrHandle = INVALID_HANDLE; MqlTick g_latestTick; datetime g_time[]; // ring buffer timestamps double g_bid[], g_ask[], g_last[], g_vol[]; // ring buffer data int g_head = -1; // index of most recent slot int g_used = 0; // number of filled slots int g_size = 0; // capacity (InpRingSize)
Pequenas funções auxiliares (SafeDiv, ARGB, RR).
Algumas funções auxiliares simples ajudam a melhorar a confiabilidade e a legibilidade do código. SafeDiv é uma função de proteção que evita erros de divisão por zero, uma prática importante no processamento de dados em tempo real, no qual podem ocorrer valores iguais a zero ou não inicializados. ARGB gera uma representação inteira de cor com mesclagem alfa para o fundo do painel. Ao concentrar essa lógica em uma função específica, os cálculos de cor ficam centralizados e o código da interface se torna mais conciso. RR calcula a relação risco/retorno em uma única expressão, também protegendo o cálculo contra denominadores iguais a zero. Embora sejam pequenas, essas funções auxiliares desempenham um papel importante: permitem que a lógica principal se concentre nas decisões de negociação, evitando a repetição de operações auxiliares e prevenindo erros em tempo de execução que podem ser difíceis de diagnosticar durante a negociação em condições reais.// Defensive helpers used across the codebase double SafeDiv(double a, double b) { return (b == 0.0 ? 0.0 : a/b); } uint ARGB(color c, int a) // produce ARGB color integer { if(a<0) a=0; if(a>255) a=255; return ((uint)a<<24) | (c & 0x00FFFFFF); } double RR(double entry,double stop,double tp) // simple R/R guard { return (entry - stop != 0.0 ? (tp - entry) / (entry - stop) : 0.0); }
Inicialização do buffer circular e adição de ticks (BufInit / BufAdd).
A estrutura de buffer circular foi escolhida deliberadamente. BufInit garante uma capacidade mínima e redimensiona os arrays, enquanto BufAdd armazena o tick mais recente na próxima posição do buffer, fazendo o índice retornar ao início do buffer por meio de uma operação de módulo, quando necessário. Isso permite inserir dados em tempo constante O(1), mantendo o consumo de memória limitado e previsível. Na prática, essa abordagem substitui o crescimento ilimitado dos arrays, como ocorreria ao chamar ArrayResize a cada tick, evitando sobrecarga desnecessária de memória em instrumentos com alta frequência de atualizações. BufAdd também normaliza o volume, utilizando volume_real quando disponível e, caso contrário, recorrendo a volume ou ao valor 1.0. Isso é necessário porque muitos fluxos de dados reais não fornecem informações representativas de volume ou as apresentam em formatos diferentes. Um valor maior de InpRingSize permite armazenar um histórico mais extenso para janelas longas de cálculo da VWAP, mas exige mais memória. Esse equilíbrio entre capacidade de armazenamento e consumo de recursos afeta tanto a capacidade de resposta do sistema quanto o uso de memória RAM.// Initialize ring buffer with minimum capacity void BufInit(int n) { if(n < 128) n = 128; g_size = n; ArrayResize(g_time, n); ArrayResize(g_bid, n); ArrayResize(g_ask, n); ArrayResize(g_last, n); ArrayResize(g_vol, n); g_head = -1; g_used = 0; } // Append a tick into the circular buffer (O(1) insertion) void BufAdd(const MqlTick &q) { if(g_size <= 0) return; g_head = (g_head + 1) % g_size; g_time[g_head] = q.time; g_bid[g_head] = q.bid; g_ask[g_head] = q.ask; g_last[g_head] = q.last; double vol = (q.volume_real > 0 ? q.volume_real : q.volume); g_vol[g_head] = (vol > 0 ? vol : 1.0); // safe fallback if(g_used < g_size) g_used++; }
Função de acesso ao preço (Mid).
A função Mid retorna o melhor preço disponível para cada tick armazenado. Quando o preço da última negociação está disponível, utiliza esse valor (last trade). Caso contrário, calcula o ponto médio entre bid e ask. Essa estratégia de seleção por prioridade é prática: os preços das negociações fornecem a referência mais direta do preço efetivo de execução, mas algumas atualizações de ticks contêm apenas cotações. Nesses casos, o ponto médio entre bid e ask oferece uma estimativa aproximada do valor justo. O retorno de 0 para posições sem dados válidos indica que esses registros devem ser ignorados. É importante compreender que a escolha entre o último preço negociado e o ponto médio afeta a sensibilidade dos indicadores. Quando utilizam o último preço negociado, a VWAP e o indicador de fluxo reagem apenas à ocorrência de negociações. Já o uso do ponto médio aumenta a densidade das observações de preço, mas também pode introduzir ruído.// Prefer last trade price; fallback to midpoint if last absent double Mid(int idx) { if(idx < 0 || idx >= g_size) return 0.0; if(g_last[idx] > 0.0) return g_last[idx]; if(g_bid[idx] > 0.0 && g_ask[idx] > 0.0) return 0.5 * (g_bid[idx] + g_ask[idx]); return 0.0; }
Funções de acesso ao spread e ao ATR.
SpreadPips e ATR representam duas características independentes do mercado: o custo imediato de execução de uma operação e a volatilidade. SpreadPips chama SymbolInfoTick e divide a diferença entre ask e bid por g_point para expressar o spread em pontos da cotação, que não necessariamente correspondem a pips, facilitando sua comparação com o ATR. A função ATR() obtém o valor mais recente do indicador por meio de CopyBuffer, utilizando o handle de iATR, enquanto ATR_Avg calcula uma média móvel de curto prazo. Essa separação é importante porque o ATR funciona como uma referência de volatilidade, utilizada tanto no cálculo dos níveis de stop quanto na verificação de "spread reduzido" (spread < ATR * coeficiente). É importante considerar os custos computacionais: CopyBuffer realiza operações de entrada e saída, por isso deve ser utilizada com moderação; além disso, é necessário esclarecer que o ATR é calculado no timeframe definido por InpTF, de modo que a escolha de InpTF afeta o ATR e, consequentemente, os níveis de stop e a avaliação de quando o spread é considerado de baixo custo.// Spread in pips (points normalized by g_point) double SpreadPips() { MqlTick t; if(!SymbolInfoTick(g_sym, t) || g_point == 0.0) return 0.0; return (t.ask - t.bid) / g_point; } // Latest ATR (indicator handle must be created beforehand) double ATR() { if(g_atrHandle == INVALID_HANDLE) return 0.0; double buf[]; if(CopyBuffer(g_atrHandle, 0, 0, 1, buf) == 1) return buf[0]; return 0.0; } // Average ATR across 'bars' (caps at 200 to limit work) double ATR_Avg(int bars) { if(g_atrHandle == INVALID_HANDLE || bars <= 0) return 0.0; int cap = MathMin(bars, 200); double buf[]; int copied = CopyBuffer(g_atrHandle, 0, 0, cap, buf); if(copied <= 0) return 0.0; double s = 0.0; for(int i=0; i<copied; i++) s += buf[i]; return s / copied; }
Agregador (Acc): principal componente de coleta de dados.
Acc é a função central de agregação de dados, utilizada tanto pela VWAP quanto pelo indicador Flow. Ao receber a marca de tempo since, a função percorre o buffer circular de trás para frente, começando pelo tick mais recente, e acumula os produtos preço * volume (numerador da VWAP), o volume total (denominador da VWAP) e, opcionalmente, quando flowNeeded é true, a quantidade de ticks de alta e de baixa. O laço é interrompido assim que encontra um tick anterior a since, limitando os cálculos à janela temporal definida. Alguns detalhes da implementação merecem atenção: prev é inicializado com DBL_MAX para ignorar a primeira comparação; ticks com preços inválidos são descartados; e o índice retorna ao final do buffer quando atinge seu início.
A função contabiliza intencionalmente up e dn como eventos (quantidade de ticks), em vez de somar volumes com sinal positivo ou negativo. Essa decisão de projeto prioriza a simplicidade e a robustez no processamento de fluxos de dados cujas informações de volume não são confiáveis. É importante destacar que Acc fornece os dados necessários tanto para calcular a VWAP ponderada pelo volume quanto para medir o fluxo com base na contagem de ticks. No entanto, a métrica de fluxo adotada nesta implementação contabiliza eventos, e não volumes, uma distinção que afeta diretamente o comportamento dos sinais.
// Accumulate price*volume and volume; optionally compute up/dn tick counts void Acc(datetime since, double &pxVol, double &vol, int &up, int &dn, bool flowNeeded) { pxVol = 0.0; vol = 0.0; up = 0; dn = 0; if(g_used == 0) return; int idx = g_head; double prev = DBL_MAX; for(int i = 0; i < g_used; ++i) { if(g_time[idx] < since) break; double p = Mid(idx); if(p <= 0.0) { idx--; if(idx < 0) idx = g_size - 1; continue; } double w = (g_vol[idx] > 0.0 ? g_vol[idx] : 1.0); pxVol += p * w; // VWAP numerator vol += w; // VWAP denominator if(flowNeeded && prev != DBL_MAX) { if(p > prev) up++; else if(p < prev) dn++; } prev = p; idx--; if(idx < 0) idx = g_size - 1; } }
Implementação da VWAP (função VWAP).
A função VWAP utiliza os resultados da função genérica Acc para aplicar a fórmula de cálculo do indicador. Primeiro, calcula since subtraindo de TimeCurrent() o intervalo configurado em minutos. Em seguida, passa esse valor para Acc, obtendo px e v, e retorna o resultado de px / v. Caso não haja volume disponível, a função retorna zero para evitar a geração de NaN. Conceitualmente, a VWAP implementada nesta ferramenta é calculada sobre uma janela temporal móvel, e não sobre uma sessão de negociação inteira, como ocorre na VWAP de sessão convencional. Portanto, sua capacidade de resposta às variações recentes de preço pode ser ajustada por meio de InpVWAPminutes. Em geral, a VWAP pode ser utilizada de duas maneiras: janelas longas servem como referência de valor justo, enquanto janelas curtas ajudam a analisar a microestrutura intradiária. Também é útil demonstrar como modificar since para calcular uma VWAP de sessão, caso necessário.// Rolling VWAP over last 'minutes' minutes double VWAP(int minutes) { if(minutes <= 0) return 0.0; datetime since = TimeCurrent() - (datetime)minutes * 60; double px = 0.0, v = 0.0; int u, d; Acc(since, px, v, u, d, false); return (v > 0.0 ? px / v : 0.0); }
Implementação do fluxo (função Flow).
A função Flow utiliza Acc com o parâmetro flowNeeded=true para obter as quantidades de ticks de alta e de baixa. Em seguida, retorna (up - dn) / (up + dn), que representa o desequilíbrio normalizado da contagem de ticks, com valores no intervalo [-1,1]. Essa relação simples permite avaliar imediatamente a atividade direcional do mercado. Valores próximos de +1 indicam que quase todos os ticks da janela corresponderam a movimentos de alta, sinalizando predominância da pressão compradora no fluxo de ticks. Já valores próximos de -1 indicam predominância da pressão vendedora.
A escolha explícita de contabilizar ticks, em vez de calcular um fluxo ponderado pelo volume com sinal positivo ou negativo, merece atenção especial. A contagem de ticks atribui o mesmo peso a todos os movimentos de preço e é menos sensível à influência de negociações individuais excepcionalmente grandes. Por outro lado, o fluxo ponderado pelo volume considera a quantidade negociada associada a cada movimento e pode oferecer informações mais relevantes quando os volumes reais das negociações são confiáveis. Ambas as abordagens são válidas. O exemplo a seguir apresenta a implementação adotada em nossa ferramenta.
// Tick-count based flow (implemented in base tool) double Flow(int sec) { if(sec <= 0) return 0.0; datetime since = TimeCurrent() - sec; double px = 0.0, v = 0.0; int up = 0, dn = 0; Acc(since, px, v, up, dn, true); int tot = up + dn; return (tot ? double(up - dn) / tot : 0.0); // normalized [-1,1] } // Alternative: volume-weighted flow (replace Acc's tick-count mode) // *Requires modifying Acc to accumulate signedVol and totalVol* double VolumeWeightedFlow(int sec) { if(sec <= 0) return 0.0; datetime since = TimeCurrent() - sec; int idx = g_head; double signedVol = 0.0, totalVol = 0.0; double prev = DBL_MAX; for(int i = 0; i < g_used; ++i) { if(g_time[idx] < since) break; double p = Mid(idx); if(p <= 0.0) { idx--; if(idx < 0) idx = g_size - 1; continue; } double w = (g_vol[idx] > 0.0 ? g_vol[idx] : 1.0); if(prev != DBL_MAX) { if(p > prev) signedVol += w; else if(p < prev) signedVol -= w; } totalVol += w; prev = p; idx--; if(idx < 0) idx = g_size - 1; } return (totalVol ? signedVol / totalVol : 0.0); // normalized to [-1,1] }
Funções auxiliares para objetos gráficos, painel e rótulos (EnsureObj, SetLabelIfChanged, SetRectIfChanged).
As funções auxiliares da interface reduzem a repetição de código na criação de objetos e na atualização de suas propriedades, além de evitar chamadas desnecessárias às funções ObjectSet* ao comparar os valores atuais antes de modificá-los. Isso reduz a cintilação dos elementos gráficos e o consumo de CPU, já que as chamadas à API do terminal para criar objetos e alterar suas propriedades têm um custo computacional. EnsureObj centraliza a lógica de criação dos objetos, enquanto SetLabelIfChanged e SetRectIfChanged padronizam a atualização das propriedades dos rótulos e dos retângulos de fundo. Do ponto de vista da engenharia de software, essa é uma boa prática, pois permite isolar as particularidades da plataforma e manter a lógica principal mais concisa. Também é importante destacar na documentação que essas funções auxiliares configuram sistematicamente os objetos como não selecionáveis, evitando manipulações acidentais no gráfico e fazendo com que o painel funcione como um dashboard, em vez de um conjunto de objetos gráficos interativos.// Create object if missing void EnsureObj(string name, ENUM_OBJECT type) { if(ObjectFind(0, name) == -1) ObjectCreate(0, name, type, 0, 0, 0); } // Update label text & position only if changed (reduces redraws) void SetLabelIfChanged(string name, int corner, int xdist, int ydist, string text, int fontsize, color col, string font) { EnsureObj(name, OBJ_LABEL); if(ObjectGetInteger(0,name,OBJPROP_CORNER) != corner) ObjectSetInteger(0,name,OBJPROP_CORNER,corner); if(ObjectGetInteger(0,name,OBJPROP_XDISTANCE) != xdist) ObjectSetInteger(0,name,OBJPROP_XDISTANCE,xdist); if(ObjectGetInteger(0,name,OBJPROP_YDISTANCE) != ydist) ObjectSetInteger(0,name,OBJPROP_YDISTANCE,ydist); if(ObjectGetString(0,name,OBJPROP_TEXT) != text) ObjectSetString(0,name,OBJPROP_TEXT,text); if(ObjectGetInteger(0,name,OBJPROP_FONTSIZE) != fontsize) ObjectSetInteger(0,name,OBJPROP_FONTSIZE,fontsize); if(ObjectGetInteger(0,name,OBJPROP_COLOR) != (int)col) ObjectSetInteger(0,name,OBJPROP_COLOR,col); if(ObjectGetString(0,name,OBJPROP_FONT) != font) ObjectSetString(0,name,OBJPROP_FONT,font); ObjectSetInteger(0, name, OBJPROP_SELECTABLE, false); } // Update rectangle only when a property changed void SetRectIfChanged(string name,int corner,int xdist,int ydist,int xsize,int ysize,uint bgARGB) { EnsureObj(name, OBJ_RECTANGLE_LABEL); if(ObjectGetInteger(0,name,OBJPROP_CORNER) != corner) ObjectSetInteger(0,name,OBJPROP_CORNER,corner); if(ObjectGetInteger(0,name,OBJPROP_XDISTANCE) != xdist) ObjectSetInteger(0,name,OBJPROP_XDISTANCE,xdist); if(ObjectGetInteger(0,name,OBJPROP_YDISTANCE) != ydist) ObjectSetInteger(0,name,OBJPROP_YDISTANCE,ydist); if(ObjectGetInteger(0,name,OBJPROP_XSIZE) != xsize) ObjectSetInteger(0,name,OBJPROP_XSIZE,xsize); if(ObjectGetInteger(0,name,OBJPROP_YSIZE) != ysize) ObjectSetInteger(0,name,OBJPROP_YSIZE,ysize); if((uint)ObjectGetInteger(0,name,OBJPROP_BGCOLOR) != bgARGB) ObjectSetInteger(0,name,OBJPROP_BGCOLOR,bgARGB); if((uint)ObjectGetInteger(0,name,OBJPROP_COLOR) != bgARGB) ObjectSetInteger(0,name,OBJPROP_COLOR,bgARGB); ObjectSetInteger(0,name,OBJPROP_SELECTABLE,false); }
Criação do painel e disposição dos elementos (CreatePanelObjects e UpdatePanelObjects).
CreatePanelObjects cria o conjunto de rótulos e retângulos que compõem o painel de informações, enquanto UpdatePanelObjects gerencia a disposição dos elementos: calcula a largura dos textos, as dimensões das barras e suas posições e, em seguida, atualiza as propriedades dos objetos para representar visualmente os indicadores mais recentes. A função utiliza uma constante de largura de caractere para estimar o espaço ocupado pelos rótulos, calcula a área disponível para as barras e desenha, em primeiro plano, barras proporcionais aos valores do spread, ATR e fluxo.
O código adota uma apresentação visual compacta, composta por um título, linhas de resumo, três barras horizontais e uma marca de tempo na parte inferior, permitindo que o trader identifique os principais sinais rapidamente. A estrutura do painel estabelece uma correspondência direta entre cada elemento da interface e sua variável de origem (spPips para a barra de spread, flow para a barra de fluxo). Essa implementação também envolve algumas escolhas de projeto: o cálculo antecipado de larguras aproximadas dos textos evita chamadas complexas para obter métricas das fontes, embora possa provocar pequenos desalinhamentos com fontes menos comuns. Já a mesclagem alfa escolhida mantém a legibilidade da interface sem sobrecarregar visualmente o gráfico.
// Minimal set of dashboard objects used by UpdatePanelObjects void CreatePanelObjects() { EnsureObj("ESGP_bg", OBJ_RECTANGLE_LABEL); EnsureObj("ESGP_hdr", OBJ_LABEL); EnsureObj("ESGP_lbl", OBJ_LABEL); EnsureObj("ESGP_vwap", OBJ_LABEL); EnsureObj("ESGP_spbar", OBJ_RECTANGLE_LABEL); EnsureObj("ESGP_spbar_fg", OBJ_RECTANGLE_LABEL); EnsureObj("ESGP_flow_lbl", OBJ_LABEL); // Make them non-selectable by default string objs[] = {"ESGP_bg","ESGP_hdr","ESGP_lbl","ESGP_vwap","ESGP_spbar","ESGP_spbar_fg","ESGP_flow_lbl"}; for(int i=0;i<ArraySize(objs);i++) ObjectSetInteger(0,objs[i],OBJPROP_SELECTABLE,false); }
Gerenciamento de alertas e marcadores visuais.
O subsistema de alertas oferece três modos: substituição de um único marcador, limpeza por janela deslizante de marcadores com nomes exclusivos baseados em marcas de tempo e um pool circular de marcadores. Quando habilitada, a exibição dos alertas ocorre somente se a condição de spread de baixo custo for atendida e o indicador de fluxo cruzar os limites configurados. A histerese é utilizada para evitar a cintilação dos alertas. O código armazena uma marca de tempo na propriedade OBJPROP_TOOLTIP de cada marcador, enquanto AutoClearOldAlerts remove os marcadores cuja idade ultrapassa InpAlertMaxAgeSec. Essa abordagem permite manter um histórico de eventos diretamente no gráfico, com o mínimo de dependências. Não é necessário utilizar armazenamento externo, e o trader continua tendo acesso a um registro visual dos sinais, que pode ser consultado e verificado posteriormente. Essas decisões de projeto tornam a ferramenta mais útil na prática: os marcadores persistentes facilitam a análise e os testes com dados históricos por meio de comparações visuais, enquanto a histerese reduz o ruído e a ocorrência de acionamentos repetidos indevidos.// Draw a simple buy/sell alert label in the panel corner void DrawAlertMarker(bool isBuy) { string nm = (isBuy ? "ESGP_alert_buy" : "ESGP_alert_sell"); if(ObjectFind(0, nm) != -1) ObjectDelete(0, nm); ObjectCreate(0, nm, OBJ_LABEL, 0, 0, 0); ObjectSetInteger(0, nm, OBJPROP_CORNER, COR_LT); ObjectSetInteger(0, nm, OBJPROP_XDISTANCE, 8); ObjectSetInteger(0, nm, OBJPROP_YDISTANCE, isBuy ? 60 : 80); ObjectSetString(0, nm, OBJPROP_TEXT, isBuy ? "▲ BUY" : "▼ SELL"); ObjectSetInteger(0, nm, OBJPROP_FONTSIZE, 12); ObjectSetInteger(0, nm, OBJPROP_COLOR, isBuy ? clrLime : clrRed); ObjectSetInteger(0, nm, OBJPROP_SELECTABLE, false); ObjectSetString(0, nm, OBJPROP_TOOLTIP, IntegerToString((int)TimeCurrent())); // store timestamp }
OnInit e OnDeinit: gerenciamento do ciclo de vida.
OnInit executa todas as tarefas necessárias durante a inicialização: seleciona o símbolo, altera o timeframe do gráfico quando necessário, obtém os parâmetros do símbolo (SYMBOL_POINT, SYMBOL_VOLUME_STEP etc.), cria o indicador ATR por meio de iATR, inicializa o buffer circular, cria os objetos do painel e configura o temporizador com EventSetTimer. Cada etapa inclui verificações de erro, como a validação do handle do ATR. Se alguma operação essencial de inicialização falhar, a função retorna INIT_FAILED. Esse mecanismo é uma prática importante para garantir a segurança e a confiabilidade do sistema.int OnInit() { g_sym = (_Symbol); if(!SymbolSelect(g_sym, true)) return INIT_FAILED; g_point = SymbolInfoDouble(g_sym, SYMBOL_POINT); g_tickVal = SymbolInfoDouble(g_sym, SYMBOL_TRADE_TICK_VALUE); g_tickSize= SymbolInfoDouble(g_sym, SYMBOL_TRADE_TICK_SIZE); g_volMin = SymbolInfoDouble(g_sym, SYMBOL_VOLUME_MIN); g_volMax = SymbolInfoDouble(g_sym, SYMBOL_VOLUME_MAX); g_volStep = SymbolInfoDouble(g_sym, SYMBOL_VOLUME_STEP); // create ATR handle for InpTF and InpATRperiod (example uses default TF & period) g_atrHandle = iATR(g_sym, PERIOD_M1, 14); if(g_atrHandle == INVALID_HANDLE) return INIT_FAILED; BufInit((int)InpRingSize); CreatePanelObjects(); EventSetTimer((int)InpTimerSec); return INIT_SUCCEEDED; }
OnDeinit executa as rotinas de limpeza: interrompe o temporizador, remove os objetos do painel e dos alertas e libera os handles dos indicadores. Deixar de liberar esses handles ou de desativar os temporizadores pode provocar vazamentos de memória e de handles que podem passar despercebidos, além de causar comportamentos inesperados quando o EA é novamente anexado ao gráfico.
void OnDeinit(const int reason) { EventKillTimer(); // remove panel objects (prefix "ESGP_") int total = ObjectsTotal(0); for(int i=total-1; i>=0; --i) { string nm = ObjectName(0, i); if(StringFind(nm, "ESGP_", 0) == 0) ObjectDelete(0, nm); } if(g_atrHandle != INVALID_HANDLE) { IndicatorRelease(g_atrHandle); g_atrHandle = INVALID_HANDLE; } }
Estratégia de recebimento de ticks em OnTick.
OnTick foi intencionalmente projetado para executar apenas operações leves: obtém o tick mais recente por meio de SymbolInfoTick e o adiciona ao buffer circular utilizando BufAdd. O processamento mais pesado fica a cargo de OnTimer. Essa separação é uma decisão arquitetural importante, pois alguns instrumentos podem gerar centenas ou milhares de ticks por segundo. Executar atualizações dispendiosas da interface ou leituras frequentes de indicadores dentro de OnTick pode sobrecarregar a thread principal e comprometer o desempenho do terminal. Ao separar a coleta de dados do processamento, o EA mantém sua capacidade de resposta e o determinismo dos cálculos. Essa arquitetura também facilita os testes: como OnTimer é executado em uma frequência controlada, torna-se mais fácil reproduzir o comportamento observado.void OnTick() { MqlTick q; if(SymbolInfoTick(g_sym, q)) { g_latestTick = q; // store latest tick BufAdd(q); // append into ring buffer (fast) } }
Laço principal de OnTimer: cálculos, tomada de decisões, interface e alertas.
OnTimer coordena as principais operações do sistema: mantém o buffer atualizado, respeita o intervalo de atualização configurado, calcula o spread e o ATR em pontos da cotação (denominados pips na implementação), verifica se o spread atende ao critério de baixo custo, chama as funções VWAP e Flow, calcula o tamanho da posição e os parâmetros de risco, determina se o painel precisa ser atualizado com base nos limites de variação e avalia as condições de acionamento dos alertas. A rotina de dimensionamento da posição com base no risco calcula a distância do stop utilizando o ATR e InpStopATRmult. Em seguida, converte essa distância em ticks e determina o risco monetário por lote. Com essas informações, calcula um tamanho de lote que mantém o risco da conta dentro do percentual definido por InpRiskPct. O volume resultante é ajustado ao incremento permitido por g_volStep e limitado aos volumes mínimo e máximo admitidos para o instrumento. Para que um alerta seja acionado, duas condições precisam ser atendidas simultaneamente: o spread deve ser considerado de baixo custo e o indicador de fluxo deve ultrapassar o limiar configurado. A histerese, controlada por InpFlowHystFactor, evita mudanças rápidas e repetidas no estado do alerta. Essa sequência pode ser apresentada como o funcionamento do "mecanismo de tomada de decisões" da ferramenta. Ela demonstra como a filtragem dos custos de execução (comparação entre spread e ATR), a confirmação da direção do mercado (indicador de fluxo) e a gestão de capital (cálculo do risco e dimensionamento do lote) se combinam para produzir um sinal prático de negociação.
É importante esclarecer que, na implementação atual, o indicador Flow utiliza a contagem de ticks: ele mede a frequência de ticks de alta e de baixa, e não o volume total negociado associado a esses movimentos. Essa escolha torna a métrica mais robusta quando os dados de volume de cada tick não são confiáveis. Por outro lado, diversos pequenos movimentos registrados em ticks podem exercer uma influência desproporcional sobre o indicador quando comparados a uma única negociação de grande volume. A VWAP também merece uma distinção importante: nesta ferramenta, ela é calculada sobre uma janela temporal móvel definida em minutos, e não a partir do início da sessão de negociação. Essa diferença afeta sua interpretação. A VWAP móvel responde mais rapidamente às mudanças recentes do mercado, enquanto a VWAP de sessão oferece uma referência de preço para o período intradiário.
O spread é normalizado utilizando g_point, enquanto o ATR é obtido em pontos e posteriormente convertido em pips, permitindo uma comparação consistente entre os dois valores. Nesse contexto, vale examinar tanto as fórmulas implementadas quanto as alternativas disponíveis. Também é possível adotar um indicador de fluxo ponderado pelo volume. Para isso, basta modificar Acc para acumular os volumes com sinal positivo ou negativo e dividir o resultado pelo volume total.
void OnTimer() { // 1) ensure buffer has latest tick (sometimes needed) MqlTick t; if(SymbolInfoTick(g_sym, t)) { if(g_used == 0 || g_time[g_head] != t.time) BufAdd(t); } // 2) compute metrics double spPips = SpreadPips(); double atrPts = ATR(); // ATR in price units (points) double atrPips = (atrPts > 0 && g_point > 0) ? atrPts / g_point : 0.0; bool cheap = (atrPts > 0 && spPips < atrPips * InpCheapSpreadFrac); double vwap = VWAP(InpVWAPminutes); double flow = Flow(InpImbWindowSec); // tick-count flow // 3) Example risk sizing (conservative) double bal = AccountInfoDouble(ACCOUNT_BALANCE); double bid = SymbolInfoDouble(g_sym, SYMBOL_BID); double stop = bid - InpStopATRmult * atrPts; double riskPx = bid - stop; double ticks = (g_tickSize > 0 ? riskPx / g_tickSize : 0.0); double cashPerLot = ticks * g_tickVal; double maxLoss = bal * InpRiskPct / 100.0; double rawLot = (cashPerLot > 0.0 ? maxLoss / cashPerLot : 0.0); double lot = (g_volStep > 0.0 ? MathFloor(rawLot / g_volStep) * g_volStep : 0.0); // 4) Alerting with hysteresis double resetThresh = InpFlowTh * InpFlowHystFactor; static bool buyF=false, sellF=false; if(cheap) { if(flow >= InpFlowTh && !buyF) { Alert("BUY edge: cheap spread + buy flow"); buyF = true; sellF = false; DrawAlertMarker(true); } else if(flow < resetThresh) buyF = false; if(flow <= -InpFlowTh && !sellF) { Alert("SELL edge: cheap spread + sell flow"); sellF = true; buyF = false; DrawAlertMarker(false); } else if(flow > -resetThresh) sellF = false; } }
Por fim, é importante considerar os testes de estresse. A granularidade dos ticks no testador de estratégias pode não reproduzir fielmente o comportamento de um fluxo de dados em tempo real. Por isso, a validação da lógica baseada em ticks exige a utilização de um modo de reprodução de ticks ou de dados históricos de ticks. O registro de logs também deve ser moderado: em instrumentos com alta atividade, chamadas excessivas à função Print podem sobrecarregar o diário do terminal. Quando InpTimerSec está configurado com um intervalo curto, também é recomendável realizar o perfilamento da carga da CPU. Como ponto de partida, são recomendados os seguintes valores: InpVWAPminutes entre 60 e 240 para operações intradiárias; InpImbWindowSec entre 10 e 60 para identificar sinais de microestrutura de mercado; e InpCheapSpreadFrac entre 0,3 e 0,7, dependendo do instrumento. Recomenda-se ajustar os parâmetros gradualmente, começando com limites conservadores. Primeiro, valide os sinais por meio dos marcadores visuais e habilite a negociação automática somente após realizar testes rigorosos com dados reais. Entre as possíveis melhorias futuras estão a inclusão de um modo de VWAP de sessão, a implementação de um indicador de fluxo ponderado pelo volume, a aplicação de suavização por média móvel exponencial (EMA) ao indicador de fluxo para reduzir a ocorrência de picos espúrios no indicador de fluxo e a possibilidade de registrar o histórico de ticks para permitir análises offline reproduzíveis.
Resultados
Após o desenvolvimento do EA, a etapa seguinte foi colocá-lo em funcionamento para testes, que podem ser realizados tanto em uma conta de demonstração quanto no testador de estratégias com dados históricos. A seguir, apresento uma série de imagens capturadas durante os testes no terminal MetaTrader 5, mostrando o funcionamento do sistema e seu comportamento em diferentes condições.
Na imagem abaixo, o painel exibe um alerta BUY emitido anteriormente, identificado pelo cabeçalho verde e pelo marcador BUY. Entretanto, o fluxo atual, calculado em uma janela curta, está ligeiramente negativo: o desequilíbrio é de aproximadamente -10,3%, enquanto o indicador de fluxo apresenta um valor de -0,10.
O spread de 71,0 pips é relativamente baixo em comparação com a volatilidade atual. Por isso, o sistema o classifica como um spread de baixo custo, considerando essa condição atendida. Como o ATR está bastante elevado, em 469,4 pips, as distâncias do stop e do alvo de lucro calculadas com base nesse indicador também aumentam: aproximadamente 563,3 pips para o stop e 1126,6 pips para o TP2R, resultando em uma relação risco/retorno de 2,00.
De modo geral, o filtro de custos de execução do EA é acionado: a condição de spread de baixo custo foi atendida. No entanto, nesse momento, a confirmação direcional fornecida pelo indicador de fluxo apresenta um viés ligeiramente de baixa. Assim, o sistema não gera um novo sinal de compra, apesar de o marcador BUY de um sinal anterior ainda permanecer no gráfico.
Após o sinal inicial de compra, o mercado acabou se movimentando na direção da operação. Esse movimento favorável pode ser observado na imagem a seguir. Nesse momento, o sistema já apresenta um novo sinal de venda, refletindo a mudança nas condições de mercado.
Posteriormente, o mercado reverteu para baixo, confirmando a validade do sinal. Esse movimento é apresentado na imagem abaixo.
Cada sinal é acompanhado por um alerta e registrado na aba "Experts" do MetaTrader 5, facilitando o acompanhamento e a análise dos eventos.
Conclusão
O Slippage Tool foi desenvolvido para solucionar um problema comum e relevante para os traders de varejo: o acesso a dados confiáveis do livro de ofertas costuma ser limitado, embora os sinais de fluxo de ordens continuem sendo importantes para identificar pontos de entrada com maior probabilidade de sucesso. Em vez de tentar substituir uma escada completa de profundidade de mercado (DOM ladder), a ferramenta extrai os sinais de microestrutura mais úteis do fluxo de ticks disponível. Para isso, utiliza uma VWAP móvel como referência de valor justo, métricas de desequilíbrio e fluxo calculadas em janelas curtas para identificar a pressão direcional, além da combinação entre spread e ATR para que os sinais sejam operacionalmente viáveis e façam sentido do ponto de vista do risco. Com a visualização diretamente no gráfico, os alertas e o dimensionamento automático das posições, a ferramenta transforma dados brutos de ticks em informações que permitem tomar decisões de negociação em tempo real.
O principal diferencial do Slippage Tool é sua abordagem prática, voltada à confiabilidade e à facilidade de uso. Decisões de projeto como a utilização de um buffer circular e o processamento leve de dados em OnTick ajudam a preservar o desempenho do terminal em instrumentos com alta frequência de ticks. As funções auxiliares de proteção e a detecção de alterações evitam atualizações gráficas desnecessárias, enquanto os alertas utilizam histerese e modos configuráveis de marcadores para reduzir o ruído e a ocorrência de sinais falsos. A lógica integrada de dimensionamento de posições conecta a geração de sinais à gestão efetiva de capital: cada operação potencial é avaliada considerando os níveis de stop baseados no ATR e o risco permitido para a conta, favorecendo um dimensionamento disciplinado das posições, em vez do aumento imprudente do volume negociado.
Ainda assim, é fundamental compreender as limitações da ferramenta. O Slippage Tool oferece apenas uma estimativa das informações normalmente obtidas do livro de ofertas, sem acesso direto ao fluxo de dados da profundidade de mercado. O indicador de fluxo é calculado com base na contagem de ticks ou, opcionalmente, pode considerar os volumes associados a eles, enquanto a VWAP é reconstruída a partir dos preços das negociações registradas e dos pontos médios entre bid e ask. Por isso, os sinais devem ser validados considerando o contexto do gráfico, diferentes timeframes e a reprodução de dados históricos de ticks. Parâmetros como a janela de cálculo da VWAP, a janela de desequilíbrio, a relação entre spread e ATR e os limites do indicador de fluxo precisam ser ajustados conforme a frequência de chegada dos ticks e a volatilidade de cada instrumento. Não existe uma configuração universal adequada a todas as condições de mercado.
Para implementar o sistema com confiança, recomenda-se uma abordagem gradual: (1) validar visualmente os sinais por meio do painel e dos marcadores, utilizando o modo de reprodução de ticks ou uma conta de demonstração; (2) configurar limites conservadores e verificar o funcionamento da ferramenta em testes com dados reais; (3) somente depois considerar a automatização das entradas, com regras robustas para o gerenciamento de stops e de timeouts, além de um sistema completo de registro de logs. Entre as melhorias futuras estão a possibilidade de selecionar o modo de VWAP de sessão, o cálculo opcional do fluxo ponderado pelo volume, a suavização por média móvel exponencial (EMA) para reduzir a ocorrência de picos espúrios no indicador e a implementação de um registro de eventos exportável para permitir análises reproduzíveis.
Leia meus outros artigos aqui.
Traduzido do Inglês pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/en/articles/19290
Aviso: Todos os direitos sobre esses materiais pertencem à MetaQuotes Ltd. É proibida a reimpressão total ou parcial.
Esse artigo foi escrito por um usuário do site e reflete seu ponto de vista pessoal. A MetaQuotes Ltd. não se responsabiliza pela precisão das informações apresentadas nem pelas possíveis consequências decorrentes do uso das soluções, estratégias ou recomendações descritas.
por que não há painel?
Senhor,
por que não há painel?