Estratégia de negociação Heads or Tails análise do Código do robô de negociação.

A estratégia de negociação "Cara ou Coroa" pertence à categoria de abordagens de negociação de curto prazo de alto risco, usadas principalmente no mercado de ações e no mercado Forex. Seu nome é devido à aleatoriedade das decisões, semelhante ao lançamento de uma moeda ("cara" - comprar um ativo, "coroa" - vender). Esta estratégia é baseada exclusivamente em decisões intuitivas ou sinais aleatórios e ignora os fatores fundamentais da análise de mercado.

O código-fonte da estratégia de negociação foi adicionado à base de códigos:

MetaTrader 5: https://www.mql5.com/pt/code/11637

#property copyright "Copyright 2025, Trading-Go." // Setting copyright property
#property link      "https://www.mql5.com/en/channels/tradingo-go-en"  // Setting developer resource link
#property version   "26.010" // Program version

O código fornecido é composto por diretivas do compilador para um programa MetaTrader Expert Advisor (EA) ou indicador, escrito na linguagem MQL4/MQL5.

Vamos analisar cada linha separadamente:

Esta linha estabelece a propriedade legal do código-fonte do EA ou indicador. Ela define o proprietário dos direitos autorais e ajuda a identificar a propriedade do produto por uma organização ou pessoa específica ("Trading-Go"). Essa informação é exibida na janela de propriedades do EA/indicador no terminal do cliente MetaTrader.

Esta linha permite definir um link para o recurso da web do desenvolvedor. Quando os traders usam este EA ou indicador, esse link fica disponível nas propriedades da ferramenta. Isso é conveniente para os desenvolvedores, pois permite direcionar os usuários para páginas de suporte, documentação ou comunidade relacionada ao produto.

Aqui é definida a versão do produto de software. Normalmente, os desenvolvedores especificam a versão no formato "XX.XX", onde o primeiro dígito representa o número da versão principal, o segundo o da versão secundária e o terceiro o do patch. A versão ajuda os usuários a rastrear facilmente as atualizações e manter a compatibilidade das ferramentas.

#include 

 // Including Trade.mqh library
CTrade        trade; // Object of class CTrade to manage trades

#include 

 // Including PositionInfo.mqh library
CPositionInfo posit; // Object of class CPositionInfo to process positions

Esse bloco de código inclui bibliotecas e cria objetos de classes para gerenciar operações de negociação e posições na plataforma de negociação MetaTrader.

Vamos analisar cada linha detalhadamente:

Esta é uma diretiva de inclusão de um arquivo de cabeçalho (Trade.mqh), que contém a classe CTrade. Esse arquivo está localizado na pasta /Trade, o que significa que a biblioteca pertence à biblioteca padrão de operações de negociação fornecida pela plataforma MetaTrader. A classe CTrade é usada para interagir convenientemente com a negociação, incluindo a abertura de posições, fechamento de operações, modificação de ordens e obtenção de informações sobre o estado da negociação.

É criado um objeto da classe CTrade com o nome "trade". Esse objeto permitirá gerenciar todos os aspectos da negociação, como a abertura de novas posições, configuração de stop loss e take profit, fechamento de posições existentes e execução de várias outras ações relacionadas ao processo de negociação.

É uma diretiva de inclusão do segundo arquivo de cabeçalho (PositionInfo.mqh) da mesma pasta /Trade. O arquivo contém a definição da classe CPositionInfo, que é usada para processar informações sobre as posições abertas atuais na conta. Através dessa classe, é possível extrair detalhes específicos de cada operação aberta, como o volume da operação, o preço de abertura, o lucro/perda e muito mais.

É criado um objeto da classe CPositionInfo com o nome "posit". Usando esse objeto, você poderá solicitar informações detalhadas sobre todas as posições ativas da sua conta de negociação, o que é útil para analisar o estado atual da carteira e tomar decisões com base nas informações obtidas.

Finalidade geral do bloco:

Esse bloco fornece a base para automatizar o processo de negociação por meio da disponibilização de uma API de alto nível (interface de programação de aplicativos). Com os objetos "trade" e "posit" criados, é possível implementar a tomada automática de decisões de negociação, monitoramento de posições e automação de operações rotineiras.

Assim, essas duas bibliotecas permitem simplificar o desenvolvimento de algoritmos complexos de negociação automática, permitindo concentrar-se diretamente na lógica da estratégia, em vez de lidar com os aspectos de baixo nível da interação com o servidor do corretor.

input double  iLots         = 0.10; // Input parameter for lot size (trade volume)
input int     iTakeProfit   = 450;  // Input parameter for profit fixing level (Take Profit)
input int     iStopLoss     = 390;  // Input parameter for loss limitation level (Stop Loss)
input int     iMagicNumber  = 227; // Input parameter for unique deal number (Magic Number)
input int     iSlippage     = 30; // Input parameter for maximum price slippage

string sy = ""; // Variable to store instrument symbol
double pt = 0; // Variable for point calculation step
int    dt = 0; // Variable for decimal places count

Vamos analisar cada elemento do bloco de código fornecido separadamente, explicando sua finalidade e papel no processo de configuração do Expert Advisor (EA) automático na plataforma de negociação MetaTrader.

Parâmetros de entrada (Input Parameters):

Esse é um parâmetro de entrada do tipo double que define o tamanho do lote (volume da operação). O valor padrão é definido como 0.10. O tamanho do lote regula a quantidade de ativos comprados ou vendidos em uma única operação. Por exemplo, se o instrumento for EURUSD, um lote de tamanho 0.1 corresponde a 10.000 unidades da moeda base (por exemplo, euros).

É um parâmetro do tipo int que define o nível de fixação de lucro (Take Profit). O valor padrão é 450. O Take Profit fecha automaticamente a posição quando o preço de mercado atinge o nível de lucro especificado em relação ao preço de entrada na operação. O nível é especificado em pontos (pips).

É um parâmetro do tipo int que define o nível de limitação de perda (Stop Loss). O valor padrão é 390. O Stop Loss fecha automaticamente a posição quando o mercado se move contra a sua posição e a perda atinge o nível especificado. A perda é fixada em pontos.

É um parâmetro do tipo int que serve como um número de identificação único (Magic Number) para as transações. Cada evento (abertura de posição, fechamento, etc.) recebe um Magic Number único, permitindo filtrar as operações por esse número. O valor padrão é 227.

É um parâmetro do tipo int que limita a desvio máximo do preço de execução da ordem em relação ao preço especificado. O valor definido é de 30 pontos. Se o preço real diferir mais do que o número especificado de pontos, a operação não será executada. Isso é usado para proteger contra desvios excessivos de preço.

Variáveis locais (Local Variables):

É uma variável do tipo string que armazena o símbolo do instrumento financeiro (por exemplo, "EURUSD") usado na negociação. Inicialmente, é uma string vazia ("").

É uma variável do tipo double calculada para armazenar o tamanho do ponto do instrumento específico. É usada para calcular os níveis de Take Profit e Stop Loss com base no número de pontos. Por padrão, é igual a zero (0).

É uma variável do tipo int destinada a contar o número de casas decimais após a vírgula nas cotações do instrumento selecionado. O número de casas decimais é importante para calcular corretamente o lucro e o stop loss, bem como outras métricas. O valor inicial é zero (0).

Esse bloco de código é destinado a definir as configurações iniciais e preparar o ambiente para o Expert Advisor automático no MetaTrader. O bloco de parâmetros de entrada permite configurar flexivelmente o comportamento do EA antes do início da negociação.

   sy = _Symbol; // Getting current trading instrument
   pt = _Point; // Getting minimum unit change size
   dt = _Digits; // Getting number of decimal digits in price

   trade.SetExpertMagicNumber(iMagicNumber); // Setting unique deal number for trade operations

   trade.SetDeviationInPoints(iSlippage); // Setting maximum price deviation points

   trade.SetTypeFillingBySymbol(sy); // Setting order execution type according to instrument settings

   trade.SetMarginMode(); // Setting margin mode

Esse bloco de código demonstra a inicialização dos principais parâmetros e a configuração das operações de negociação no Expert Advisor automático no MetaTrader. Cada operador desempenha um papel importante na preparação das condições para o funcionamento bem-sucedido do EA.

Vamos analisar cada expressão com mais detalhes.

Variáveis de ambiente:

Atribui à variável global "sy" o nome do instrumento de negociação atual com o qual o EA está trabalhando. _Symbol é uma constante integrada que retorna o nome do ativo selecionado no terminal. Dessa forma, obtemos acesso ao nome do instrumento necessário para os cálculos subsequentes e o trabalho com ele.

Define a variável "pt", que recebe a mudança mínima no preço do instrumento em pontos (_Point). Essa é a unidade básica de medição da mudança no preço, necessária para interpretar corretamente os sinais do sistema e ajustar os pedidos.

Define a variável "dt", que representa o número de casas decimais no preço do instrumento atual. Como diferentes instrumentos têm diferentes quantidades de casas decimais (por exemplo, USDJPY tem duas casas, EURUSD tem quatro), essa variável é importante para arredondar corretamente os números e realizar cálculos.

Configuração do objeto de negociação:

Define um número mágico único (Magic Number) para todas as operações iniciadas por este EA. O número mágico é usado para identificar as operações realizadas por um EA específico e simplifica o filtro de posições com base nesse critério. A unicidade do número garante que não haja confusão entre diferentes estratégias automatizadas.

Definindo um limite máximo de desvio do preço de execução da ordem em relação ao preço esperado (slippage), é possível proteger contra grandes flutuações do mercado. Definir o valor em pontos impede a execução de operações se o preço mudar muito. Quanto menor o valor, mais precisa será a execução de suas solicitações.

Configura o tipo de execução de ordens com base nas características do próprio instrumento (_Symbol). Alguns instrumentos exigem execução instantânea ("Market Execution"), enquanto outros podem permitir execução adiada ("Instant Execution"). Esse comando seleciona automaticamente o modo correto de acordo com as especificações do símbolo.

Configura o modo de margem do EA. Os métodos de gerenciamento de margem variam dependendo do instrumento e do modo de negociação. A configuração correta da margem afeta a quantidade de fundos disponíveis necessários para manter a posição e minimiza o risco de fechamento forçado da posição devido à falta de capital.

   double stepvol = SymbolInfoDouble(sy, SYMBOL_VOLUME_STEP); // Get the lot size change step for the selected symbol
   if(stepvol > 0.0) // If the lot size step is positive, apply calculation of adjusted lot size
      lt = stepvol * (MathFloor(iLots / stepvol) - 1); // Round down the lot size to the nearest step value and decrease by one step
//---
   double minvol = SymbolInfoDouble(sy, SYMBOL_VOLUME_MIN); // Get minimum allowed lot size for the specified symbol
   if(lt < minvol) // If the adjusted lot size is less than the minimum possible value, reset it to zero
      lt = 0.0;

   ::MathSrand(GetTickCount()); // Generating initial number for random generator

O bloco de código apresentado realiza um ajuste dinâmico do volume das operações (lotes) dentro de um instrumento específico (moeda, ação, contrato, etc.). A tarefa principal é ajustar o tamanho do lote dentro dos valores permitidos pela bolsa, evitando erros na abertura de posições e mantendo a segurança das operações.

Vamos analisar cada etapa com mais detalhes:

1. Definição do passo de mudança do volume:

A função SymbolInfoDouble() obtém o passo de mudança do volume (lote) para o símbolo selecionado (SYMBOL_VOLUME_STEP). O passo define o intervalo mínimo no qual o tamanho do lote pode ser alterado. Por exemplo, para alguns instrumentos financeiros, o passo é de 0.01, o que significa que a negociação só pode ocorrer em múltiplos de cem partes do lote.

2. Verificação da positividade do passo:

Verifica se realmente existe um passo de mudança de lote positivo. Se o passo for zero ou negativo, os cálculos subsequentes não fazem sentido.

3. Arredondamento e diminuição do lote em uma etapa:

O algoritmo diminui o volume da operação especificado pelo trader (iLots) em uma unidade do passo mínimo.

Aqui está o que acontece dentro da expressão:

4. Obtenção do lote mínimo possível:

As ordens obtêm o volume mínimo permitido do lote para o símbolo especificado (SYMBOL_VOLUME_MIN). A bolsa pode limitar os volumes mínimos, abaixo dos quais não é possível realizar operações.

5. Verificação do limite mínimo:

Se o volume ajustado após a diminuição for menor que o mínimo estabelecido pela bolsa, o valor é definido como zero. Isso evita situações em que o robô tenta enviar um pedido com um volume inferior ao mínimo permitido.

6. Geração do valor inicial do gerador de números aleatórios:

É gerado um valor inicial para o uso subsequente de funções de números aleatórios. O comando pega o valor atual do contador de ticks (GetTickCount()) e o usa como semente para as sequências pseudoaleatórias subsequentes. Isso é feito para aumentar a imprevisibilidade dos resultados dos processos aleatórios.

   int total = ::PositionsTotal(), b = 0, s = 0; // Total open positions and purchase/sale counters

   double Bid = ::SymbolInfoDouble(sy, SYMBOL_BID); // Current bid price (selling price)
   double Ask = ::SymbolInfoDouble(sy, SYMBOL_ASK); // Current ask price (buying price)

   double new_sl = 0, new_tp = 0, old_sl = 0, old_tp = 0; // New and old stop loss and take profit levels

   if(Bid <= 0 || Ask <= 0) // If prices are incorrect
      return; // Exit function

O bloco de código apresentado realiza uma série de operações preparatórias importantes antes de executar a lógica adicional de negociação no Expert Advisor automático na plataforma de negociação MetaTrader. Vamos analisar cada etapa com detalhes.

Inicialização de variáveis:

1. Obtenção do total de posições abertas:

A função PositionsTotal() retorna o total de posições abertas na conta, independentemente da direção e do instrumento. Esses dados são importantes para análises posteriores e possível otimização das posições.

2. Inicialização dos contadores de compras e vendas:

As variáveis "b" e "s" são usadas para contar a quantidade de posições abertas longas (buy) e curtas (sell), respectivamente. Elas são inicializadas em zero e posteriormente incrementadas durante a análise das posições.

Obtenção dos preços atuais do mercado:

3. Solicitação do preço BID (preço de venda):

A função SymbolInfoDouble() retorna o último preço de compra conhecido (BID) para o instrumento atual (sy). O preço BID reflete o melhor preço de mercado no qual o trader pode vender o instrumento imediatamente.

4. Solicitação do preço ASK (preço de compra):

Da mesma forma que no ponto anterior, é solicitado o último preço de venda conhecido (ASK) para o instrumento. O preço ASK mostra o melhor preço no qual é possível comprar o instrumento imediatamente.

Preparação dos níveis de stop loss e take profit:

5. Declaração dos níveis novos e antigos de Stop Loss e Take Profit:

Inicialização prévia das variáveis para cálculos futuros e comparação dos níveis de stop loss e take profit. Os valores zero indicam que ainda não há níveis estabelecidos até que a lógica correspondente seja executada posteriormente no programa.

Segurança e verificação da correção dos preços:

6. Verificação da correção dos preços obtidos:

É realizada uma verificação simples para detectar preços incorretos. Se o preço BID ou ASK for zero ou negativo, o programa sai da rotina atual (return) para evitar operações incorretas. Essa condição protege o sistema contra consequências indesejadas devido a dados incorretos.

 for(int i = 0; i < total; i++) // Loop through open positions
      if(posit.SelectByIndex(i)) // Select position by index
         if(posit.Symbol() == sy) // Check instrument of position
            if(posit.Magic() == iMagicNumber) // Check unique number of position
              {

               old_sl = ::NormalizeDouble(posit.StopLoss(),   dt); // Converting old stop loss to required decimal places
               old_tp = ::NormalizeDouble(posit.TakeProfit(), dt); // Converting old take profit to required decimal places

               if(posit.PositionType() == POSITION_TYPE_BUY) // If position is BUY (purchase)
                 {
                  new_sl = ::NormalizeDouble(Ask - iStopLoss   * pt, dt); // New stop loss below current ask price
                  new_tp = ::NormalizeDouble(Ask + iTakeProfit * pt, dt); // New take profit above current ask price
                  b++;                                                  // Increment purchases counter
                 }

               if(posit.PositionType() == POSITION_TYPE_SELL) // If position is SELL (sale)
                 {
                  new_sl = ::NormalizeDouble(Bid + iStopLoss   * pt, dt); // New stop loss above current bid price
                  new_tp = ::NormalizeDouble(Bid - iTakeProfit * pt, dt); // New take profit below current bid price
                  s++; // Increment sales counter
                 }

               if(old_sl == 0 || old_tp == 0) // If new levels differ from old ones
                  trade.PositionModify(posit.Ticket(), new_sl, new_tp);// Modify position with new SL and TP levels
              }

O bloco de código considerado implementa um ciclo de iteração pelas posições abertas na conta e a atualização dos níveis de stop loss (SL) e take profit (TP) para as posições correspondentes. Vamos analisar cada operação sequencialmente:

Iteração pelas posições abertas:

Aqui é realizada uma iteração pela lista de posições abertas. A variável "total" foi previamente definida com o número de posições abertas na conta (PositionsTotal()). Cada posição aberta é processada individualmente.

Seleção da posição pelo índice:

É usado o método SelectByIndex() para selecionar uma posição com base em seu número de índice na lista. Após a seleção, a posição está disponível para processamento posterior.

Verificação da correspondência do símbolo e do número mágico:

Primeiro, é verificado se o instrumento da posição selecionada corresponde ao símbolo especificado na configuração (sy). Em seguida, é comparado o número mágico único da posição (Magic Number) com o definido nos parâmetros do EA (iMagicNumber). Ambas as condições são necessárias para selecionar a posição correta.

Salvando os níveis antigos de SL e TP:

Para a posição selecionada, os níveis atuais de stop loss e take profit são salvos. É importante normalizar os valores obtidos, levando em consideração o número de casas decimais do instrumento (dt), para garantir o processamento correto dos valores de ponto flutuante.

Processamento da posição longa (BUY):

Se a posição selecionada estiver aberta para compra (POSITION_TYPE_BUY), o seguinte bloco é executado:

Cálculo do novo nível de Stop Loss: a nova linha de stop loss é posicionada abaixo do preço de mercado atual (Ask), diminuído pelo nível de stop loss pré-estabelecido (iStopLoss), expresso em pontos (pt).

Cálculo do novo nível de Take Profit: o novo nível de fixação de lucro é posicionado acima do preço de mercado atual (Ask), aumentado pelo nível de lucro pré-estabelecido (iTakeProfit), expresso em pontos.

Contabilidade: o contador de compras abertas (b++) é incrementado.

Processamento da posição curta (SELL):

Se a posição for curta (POSITION_TYPE_SELL), as seguintes ações são executadas:

Novo Stop Loss: acima do preço atual (Bid), aumentado pelo nível de stop loss.

Novo Take Profit: abaixo do preço atual (Bid), diminuído pelo nível de lucro.

Contabilidade: o contador de vendas (s++) é incrementado.

Alteração dos níveis de SL e TP:

Se o valor antigo de SL ou TP não existir (igual a zero), a posição é modificada com os novos níveis. O método PositionModify() é usado para aplicar as alterações nos níveis de proteção e fixação de lucro.

   if((b + s) == 0) // If there are no active positions
      if(::MathRand() % 2 == 0) // Randomly choosing direction of opening position
        {
         if(trade.Buy(lt)) // Opening long position (BUY)
            if(trade.Buy(lt)) // Opening long position (BUY)
               return; // End function execution
        }
      else
         if(trade.Sell(lt)) // Opening short position (SELL)
            if(trade.Sell(lt)) // Opening short position (SELL)
               return; // End function execution

O bloco de código acima descreve o algoritmo de abertura aleatória de uma posição longa (BUY) ou curta (SELL) se, no momento, não houver posições abertas na conta. Vamos analisar o processo com detalhes:

Análise da existência de posições abertas:

A soma dos contadores de posições abertas em compra (b) e venda (s) é verificada. Se a soma for zero, significa que não há posições abertas na conta. Somente nesse caso, o procedimento de abertura de uma nova posição é iniciado.

Seleção aleatória da direção da posição:

A direção da posição futura é escolhida aleatoriamente. É usado um gerador de números aleatórios (MathRand()). O operador % 2 retorna o resto da divisão do resultado do número aleatório por 2, o que dá uma probabilidade de 50% de obter zero (número aleatório par) e 50% de obter um valor diferente de zero (número aleatório ímpar).

Se o resto for zero, a compra (ORDER_TYPE_BUY) é selecionada.

Caso contrário, a posição curta (ORDER_TYPE_SELL) é aberta.

Abertura de uma posição longa (BUY):

Antes de comprar, é verificada a suficiência de fundos para realizar a operação necessária por meio do método CheckVolume(). Os argumentos são:

• Instrumento (sy),
• Volume do lote (lt),
• Preço atual de compra (Ask),
• Tipo de ordem (ORDER_TYPE_BUY).

O método verifica o saldo e a disponibilidade de fundos para abrir a posição com o volume especificado.

Se os fundos forem suficientes, uma posição longa é aberta por meio do comando Buy(), passando o volume do lote (lt). Se a operação for bem-sucedida, a execução do bloco é interrompida (return).

Abertura de uma posição curta (SELL):

Se o caso anterior não for atendido (a venda é selecionada), a disponibilidade de fundos para a posição curta é verificada:

• Instrumento (sy),
• Volume do lote (lt),
• Preço atual de venda (Bid),
• Tipo de ordem (ORDER_TYPE_SELL).

Se tudo estiver correto, uma posição curta é criada por meio do comando Sell(), e a execução é interrompida (return).

void OnDeinit(const int reason) // Deinitialization function
  {

  }

O bloco OnDeinit é deixado em branco se não houver ações especiais de limpeza necessárias. No entanto, mesmo um bloco vazio é útil, pois lembra o desenvolvedor da possibilidade de implementar a limpeza de recursos, se necessário no futuro.

Por exemplo, se seu EA trabalhou com gráficos, criou janelas de saída ou executou solicitações de rede, fechar a janela do gráfico, liberar a memória ou encerrar a conexão seria uma ação razoável.

Conclusão:

O código implementa uma estratégia simples de abertura aleatória de posições em situações em que não há posições abertas na conta. A atenção principal é dada à verificação da disponibilidade de fundos e à possibilidade de realizar o comércio no preço de mercado. Esse enfoque pode ser usado para fins de teste ou em sistemas em que a direção específica das operações não é necessária, priorizando a frequência das operações ou outros fatores.