Como copiar a negociação do MetaTrader 5 para o MetaTrader 4

Introdução

Não muito tempo atrás, muitos negociantes acreditavam que o MetaTrader 5 era uma plataforma crua, inadequada para negociação real. Mas agora, após um pequeno tempo, a opinião pública está imaginando quando a negociação real estará disponível. Muitos negociantes já apreciaram os benefícios implementados no MetaTrader 5. Além disso, o Campeonato realizado pela MetaQuotes Software Corp. aumentou o interesse dos desenvolvedores pela linguagem do MQL5. E agora, este interesse deseja ser realizado na forma de lucro com negociação. A mesma pergunta "Quando a negociação real será disponibilizada?" é feita ao lugar errado. Sua solução depende de um corretor em particular. São eles que tomam a decisão final sobre o tempo da transição para a nova plataforma.

O que um negociante sozinho pode fazer nessa situação? A resposta é óbvia, você deve usar as oportunidades de negociação real fornecidas pelo MetaTrader 4, como um trânsito para o MetaTrader 5. Ou seja, escreva um copiador. A ligação entre dois MetaTrader 4 não é uma inovação na web. Agora é hora de implementar tal ligação com o MetaTrader 5.

Prólogo

Para implementar as ideias declaradas no tópico, é necessário esclarecer as perguntas: "De onde vem o lucro?" e "Como um negociante controla o crescimento dos lucros?" à primeira vista, as respostas são óbvias. Compre barato, venda caro. Mas, vamos considerar os componentes dos lucros. Lucro é a diferença entre a compra e a venda, multiplicada pela aposta. Ou seja, o lucro tem dois componentes: cotas e o volume de uma posição de negócio.

O que um negociante pode gerenciar? Quais destes dois componentes é um direcionamento na negociação? Claro que é o volume de uma posição de negócio. As cotas são recebidas de um corretor e não podem ser mudadas pelo negociante. Aqui está a primeira conclusão: para fazer uma cópia da negociação, é necessário manter o volume das posições de negócio sincronizadamente.

1. Comparação de duas plataformas

1.1 Diferenças no sistema de contabilidade

As plataformas comparadas possuem sistemas de contabilidade de negócio diferentes e isso pode complicar a questão de cópia. Mas, não devemos esquecer que o mais importante nesta ligação é o MetaTrader 5. Isso significa que no MetaTrader 4 precisamos repetir virtualmente o mesmo sistema de contabilidade.

Uma posição de negócio no MetaTrader 5 resulta de ordens de negócio individuais, o que não contradiz a ordem de contabilidade adotada no MetaTrader 4. O Stop Loss e Take Profit comuns para uma posição podem ser implementados através do posicionamento do mesmo Stop Loss e Take Profit para toda ordem aberta. Diferenças significantes entre as plataformas aparecem apenas na questão de qual ordem fechar no MetaTrader 4. Devido ao MetaTrader 5 não ter uma conta separada de ordens em uma posição de negócio, esta questão pode se tornar uma dificuldade.

1.2 Volumes das posições de negócio

Vamos considerar em detalhes se existe alguma diferença qual ordem fechar. Isso afetará o lucro? Por exemplo, temos duas ordens abertas em diferentes momentos, e fechadas da mesma forma em diferentes momentos, mas tendo coexistido em algum momento. Ou seja, tentamos emular uma posição de negócio em ordem de contabilizar o sistema.

Vamos calcular as diferentes variáveis do que acontecerá ao lucro se mudarmos os níveis do nível de fechamento de ordens:

Tipo	Volume	Abrir nível	Fechar nível
vender	0,1	1,39388	1,38438
vender	0,1	1,38868	1,38149

Vamos escrever um código de uma calculadora:

void OnStart()
  {
   double open1=1.39388,close1=1.38438,
         open2=1.38868,close2=1.38149;
   Print("total  ",n1(profit((open1-close1),0.1)+profit((open2-close2),0.1)));
   Print("order2  pp=",ns(open2-close2),"  profit=",n1(profit((open2-close2),0.1)));
   Print("order1  pp=",ns(open1-close1),"  profit=",n1(profit((open1-close1),0.1)));
  }
string ns(double v){return(DoubleToString(v,_Digits));}
string n1(double v){return(DoubleToString(v,1));}
double profit(double v,double lot){return(v/_Point*lot);}

Aqui está o cálculo:

order1  pp=0.00950  profit=95.0
order2  pp=0.00719  profit=71.9
total  166.9

Agora, nós trocamos os valores de close1 e close2.

order1  pp=0.01239  profit=123.9
order2  pp=0.00430  profit=43.0
total  166.9

Figura 1. Variáveis do fechamento da ordem

A Figura 1 mostra que as áreas AB e CD têm em ambas versões volumes iguais a 0.1, enquanto BC possui o volume 0.2 e não depende do fato de que o volume de ordens está fechado.

Nos lucros de ordens individuais, temos diferenças, mas o lucro total de posições é igual. Quero chamar sua atenção ao fato de que esse exemplo foi calculado para volumes de ordens iguais. Ou seja, implementamos o fechamento nos mesmos níveis de não uma ordem, mas do mesmo volume. E, se aderirmos estritamente ao princípio de fechamento de volume, não importa qual seja o volume de uma ordem. Se o volume de fechamento for maior que o volume da ordem, haverá um fechamento parcial.

Então, aqui está uma conclusão importante: para a posição total, não importa qual ordem foi fechada, o que importa é que os volumes fechados devem ser iguais a um dado nível.

1.3 Copiando negócios

A partir dos exemplos acima você percebe que para obter o mesmo lucro, não é necessário transmitir sinais produzidos pelo Expert Advisor escrito no MQL5. Você precisa apenas não repetir os volumes das posições de negócio. Embora, devido a alguns motivos que serão discutidos posteriormente, não será um negócio completamente idêntico. Porém, estas razões não podem ser um obstáculo para ganhar o lucro real usando um EA rentável escrito no MQL5.

O primeiro motivo para o declínio do lucro é a diferença nas cotas. Com alguns corretores essa diferença pode exceder o spread. O fato é que as cotas são traduzidas em tempo real. E quando no MetaTrader 5 um EA decide abrir uma posição, o corretor no qual o MetaTrader 4 está conectado pode simplesmente ter um preço diferente. E o preço pode ser melhor ou pior neste caso.

O segundo motivo para o declínio do lucro é o fator de tempo. Uma posição é copiada após já ter aparecido no MetaTrader 5, e, então, o delay é inevitável.

Estes dois motivos ofuscam todas as estratégias de escalpo. Então, até o negócio real estar disponível no MetaTrader 5, tais estratégias não serão aplicáveis. 

O sistema, implicando um lucro (a partir de um negócio), excedendo em muito o spread e insensível às cotas de determinado corretor, pode ser usado para fazer dinheiro real usando o copiador de posição.

2. Definindo o problema

1. Ligação para passar sinais entre o MetaTrader 5 e MetaTrader 4
2. Tradução de posições do MetaTrader 5
3. Recebimento de sinais no MetaTrader 4
4. Repetição de posições de negócio no MetaTrader 4
   

2,1. Ligação para passar sinais entre o MetaTrader 5 e MetaTrader 4

A primeira variável é transmitir sinais através de um arquivo compartilhado. A pergunta é: A gravação frequente no arquivo danifica o hardware? Se você escreve dados novos apenas quando uma posição muda, então os registros não serão muito frequentes. Não mais frequente do que os desenvolvedores Windows fazem mudanças no arquivo de paginação. Isso, por sua vez, é um procedimento comprovado de que não danifica o hardware. Escrever em um arquivo compartilhado é uma implementação aceitável para não muitas solicitações frequentes. Esta é outra limitação para estratégias de escalpo, embora menos significante do que o limite anterior.

Para a ligação, você pode usar o recurso do MetaTrader 5 de escrita de subdiretórios em qualquer profundidade. Não verifiquei se "qualquer um", mas até 10 subdiretórios são escritos, isso com certeza. E não precisamos de mais. Você pode certamente usar um DLL para fornecer o acesso, mas não use o DLL se o problema puder ser resolvido sem ele, é minha posição de princípio. Para resolver este problema sem DLL, apenas instale o MetaTrader 4 no diretório \Files\ do terminal do MetaTrader 5 (veja Trabalhando com arquivos).

Assim, o caminho para o arquivo compartilhado parecerá com o seguinte:

C:\Program Files\MetaTrader 5\MQL5\Files\MetaTrader 4\experts\files\xxx      
//where xxx is the name of the shared file.

Com este local, o arquivo estará disponível tanto no MetaTrader 4 como no MetaTrader 5, a possibilidade de compartilhamento de arquivo é fornecida pelas funções do MQL5.

2,2. Tradução de posições do MetaTrader 5

Para traduzir posições e uso econômico de recursos, precisamos de uma função que monitorará o aparecimento/modificação/fechamento de uma posição de negócio para todos os instrumentos. Foi descoberto acima que para transferir um negócio precisamos apenas saber o volume de uma posição de negócio. Adicionar o volume do símbolo de instrumento e nível SL e TP.

Para rastrear as mudanças, precisamos saber o estado anterior de uma posição. E, se os estados anterior e presente não forem iguais (e assim, a posição terá mudado), é necessário exibí-lo no arquivo. Também precisamos de uma função para escrever esta informação no arquivo. O arquivo deve ser aberto para que esteja disponível para o uso simultâneo por diversos programas.

Não perder o momento da modificação da posição, o sistema de rastreio deve ser implementado na função OnTimer(), porque precisamos rastrear todos os instrumentos de uma vez, e ticks vêm de diferentes momentos para diferentes símbolos. Também precisamos enviar um sinal sobre a mudança no conteúdo do arquivo.

2,3. Recebimento de sinais no MetaTrader 4

é necessário rastrear o sinal de atualização de arquivo. Isso pode ser organizado através de uma variável na qual o estado seja monitorado para a entrada na zona de mudança de posição. Precisamos de uma função para leitura de um arquivo com o estado das posições. é apenas uma função padrão.

Passando os conteúdos do arquivo em séries para cálculo. Aqui precisamos de um parser. Devido a não apenas números, mas também símbolos serem passados, é conveniente gravar tudo na string quando transferir do MetaTrader 5. Além disso, escrevendo todos os dados para um símbolo em uma string, eliminamos confusão de dados.

2,4. Repetição de posições de negócio no MetaTrader 4

é o maior conjunto de funções. Deve ser dividido em diversas subclasses.

1. Comparação de posições virtuais;
   
2. Função de seleção de ordens;
3. Função de abertura de ordem;
4. Função de fechamento de ordem;
5. Função de modificação de ordem.

2.4.1. Comparação de posições virtuais

A comparação de posições virtuais é necessária para a garantia de que as posições estejam em conformidade. A função deve calcular a posição para cada símbolo separadamente e também ser capaz de filtrar posições para qual o negócio é proibido (se houver).

Na prática, pode haver situações quando um corretor não terá um símbolo, um sinal para o qual é passado do MetaTrader 5. Mas isso não deve bloquear o negócio no geral, embora deva ser providenciado um aviso. O usuário tem o direito de saber sobre a situação.

2.4.2. Função de seleção de ordens

Esta função deve escolher as ordens, dependendo do símbolo, para trabalhar futuramente com elas. Neste caso, já que transmitimos apenas as posições abertas, as ordens devem ser filtradas para não haver ordens pendentes.

2.4.3. Função de abertura de ordem

Ela deve conter o número máximo de cálculos. Assim, é o suficiente passar o volume e o tipo.

2.4.4. Função de fechamento de ordem

Como na anterior, deve calcular tudo antes de dar o comando de fechamento.

2.4.5. Função de modificação de ordem

A função deve conter uma verificação para a proximidade com o mercado. Além disso, é desejável dissolver com o passar do tempo o posicionamento das ordens e níveis de parada, porque o posicionamento de níveis de parada durante a abertura não é permitido com todos os corretores. Além disso, a abertura conjunta de ordens e definição de níveis de parada aumentam a probabilidade de recota.

Assim, a posição será rapidamente repetida. E o posicionamento de níveis de parada é uma coisa menor, embora não menos importante.

3. Implementação

Os códigos são comentados em detalhes, quase que linha por linha. Então, quando explicar os códigos, vou enfatizar apenas nos momentos mais difíceis.

Ligação para passar sinais entre o MetaTrader 5 e MetaTrader 4

A ligação é implementada no MetaTrader 5 pela função:

void WriteFile(string folder="Translator positions") // by default it is the name of the shared file

As marcações de abertura significam:

FILE_WRITE|FILE_SHARE_READ|FILE_ANSI

o arquivo é aberto para escrita | o uso compartilhado por diferentes programas para leitura é permitido | codificação ansi

No MetaTrader 4, a ligação é implementada pela função:

int READS(string files,string &s[],bool resize)

O parâmetro resize proíbe a redistribuição de memória da série dos dados recebidos. No código, a memória desta série é alocada a cada interação, porque um desenvolvedor não pode prever o número de linhas. Ela depende do número de símbolos selecionados no MetaTrader 5. Portanto, pode ser calculado com antecedência no MetaTrader.

Então, a série deve ser aumentada em um a cada etapa. Mas esta operação deve ser bloqueada na segunda chamada da função, porque o comprimento da série já está definido e não mudará. Para este propósito, use a variável bool resize.

Tradução de posições do MetaTrader 5

Para organizar a tradução na função OnTimer com a frequência de 01 seg., os dados sobre todas as posições são recebidos na função:

void get_positions()

Então, comparando o valor anterior das posições com o valor atual da função:

bool compare_positions()

E a saída com return(true) ocorre no caso de ao menos uma célula não combinar. Saída com return(true) significa que as posições não são iguais e o arquivo deve ser reescrito. Ao reescrever o arquivo, o contador cnt_command é aumentado em um.

Recebimento de sinais no MetaTrader 4

Após a leitura do arquivo usando a função READS(), teremos preenchido a série de strings s[].

Para que essas strings se transformem em informações úteis, precisamos de um parser.

A função:

int parser(int Size)

é apenas um wrapper para a chamada da função de identificação de linha:

void parser_string(int x)

A função reconhece todas as células, exceto os símbolos.

O símbolo é reconhecido em um ciclo, apenas no começo de um algorítimo usando a função:

void parser_string_Symbols(int x)

A seguir, não nos referiremos ao código no MQL5, e discutiremos apenas o código no MQL4, a menos que seja especificamente mencionado.

Comparação de posições virtuais

A comparação de posições é divida em duas partes. A comparação do volume e tipo das posições é implementada na função:

bool compare_positions()

Neste shell, a chamada para obter o estado real das posições é implementada na função:

void real_pos_volum()

e a comparação funciona de acordo com o princípio mencionado acima "tudo ou nada". Isso significa, se ao menos uma célula não for igual, todas as posições são consideradas diferentes. Em real_pos_volum() uma série de filtros é implementada, o que é descrito em detalhes no código e será usado repetidamente em outras funções.

Em particular, será usado para soma de volumes de todas as ordens em um símbolo em uma posição virtual. Para que as posições de bloqueio (se houver) sejam processadas corretamente, as ordens Buy (Compra) terão o volume com um menos, e as ordens Sell (Venda) com um mais.

A segunda parte da comparação é comparar os níveis de parada (os níveis de parada são Stop Loss e Take Profit), isso é implementado na função, similar ao anterior:

bool compare_sl_tp_levels()

Como com os volumes, dentro da shell há uma chamada para obter informações sobre os níveis de parada na função:

void real_pos_sl_tp_levels()

Função de seleção de ordens

As ordens devem ser selecionadas apenas para fechar o volume, é por isso que a complicada função de seleção especializada é apenas implementada para fechamento:

void close_market_order(string symbol,double lot)

Tenha os parâmetros de símbolo e volume, que devem ser fechados. Para interromper as ordens o mínimo possível, no primeiro ciclo da função, ela busca pela ordem na qual o volume seja igual ao da ordem de fechamento passada no parâmetro sendo procurado a autorização, que é igual ao volume com o volume fechando passado no parâmetro.

Se não existir tal ordem (o que é possível saber a partir do estado true da marcação de fechamento FlagLot), então o volume especificado é fechado na ordem que é a primeira no ciclo (a verificação do excesso do volume de ordem é implementada na função de fechamento Closes()).

A seleção das ordens para a modificação dos níveis de parada é implementada na função:

void modification_sl_tp_levels()

As ordens são filtradas apenas pelo símbolo, porque todos os níveis de parada dentro de um símbolo são iguais.

Função de abertura de ordem

é implementada na seguinte função:

int open_market_order(string symbol,int cmd,double volume,
                     int stoploss=0,int takeprofit=0,int magic=0)

Ela contém todas as verificações necessárias para uma abertura confortável de uma ordem usando os dados especificados.

Função de fechamento de ordem

é implementada na seguinte função:

bool Closes(string symbol,int ticket,double lot)

O código contém uma verificação no caso do parâmetro lot exceder o volume real da ordem selecionada anteriormente.

Função de modificação de ordem

é implementada na seguinte função:

bool OrderTradeModif(int ticket,string symbol,int cmd,double price,
                    double stoploss=0,double takeprofit=0,int magic=0)

O código possui verificações, no caso dos níveis de parada não corresponderem ao tipo de ordem, os valores não serão trocados. Ela também verifica se os níveis já têm o valor solicitado.

4. Funções de lógica

O plano traçado anteriormente acabou, mas o código ainda tem funções inexplicadas. Elas são funções de lógica, podemos dizer que elas são funções básicas, direcionando o processo.

void processing_signals()
void processing_sl_tp_levels()

Ambos os recursos são ciclos sem fim com saída com a condicional break. Aqui devemos observar que o script em si é implementado como um loop infinito. Para possibilitar que o usuário remova de forma confortável o programa, a principal condição do ciclo tem a função IsStopped() inserida.

O código é transferido de um Expert Advisor para o script com loop da seguinte forma:

 // Init()
 while(!IsStopped())
    {
     // Start()
     Sleep(1000);
    }
 // Deinit()

A lógica do script inteira é descrita no mesmo loop infinito na função padrão start().

O código do ciclo localizado em start() parecerá com isso:

     If the trade flow is not busy
          Read the file and save data in an array (not changing the array size);
          if there have been changes in the file
               write new comments;
               remember the time when cycles of compliance check start (located below);
               if the positions whose volumes are being compared are not equal
                    process the positions by volumes;
               if the positions whose stops are being compared are not equal
                    process the positions by stops;
               calculate the end time of checks;
          If time is not exceeded
               make a pause for the remaining time;

As construções mais lógicas estão localizadas nas funções processing_signals() e processing_sl_tp_levels().

Começamos descrevendo as funções no princípio "de simples a complexo". Embora a chamada no código seja o oposto.

//+------------------------------------------------------------------+
//| processing stop levels                                           |
//+------------------------------------------------------------------+
void processing_sl_tp_levels()
  {
//--- remember the time of entering the cycle   
   int start=GetTickCount();
   while(!IsStopped())
     {
      //--- if the trade flow is not busy
      if(Busy_and_Connected())
        {
         //--- select the order and modify stop levels           
         modification_sl_tp_levels();
        }
      //--- if the delay time is over, update information from the file  
      if(GetTickCount()-start>delay_time)READS("Translator positions",s,false);
      //--- if the update counter has changed in the file, exit the cycle      
      if(cnt_command!=StrToInteger(s[0]))break;
      //--- micro-pause      
      Sleep(50);
      //--- if real stop levels and those in the file are equal, exit the cycle     
      if(!compare_sl_tp_levels())break;
     }
   return;
  }

Como mencionado anteriormente, a função é um loop infinito com a saída em duas condições:

A primeira condição de saída do loop ocorre no caso do valor de cnt_command não ser igual ao mesmo valor no arquivo. Antes de termos recebido as últimas informações sobre o arquivo, desde que o tempo de operação do loop exceda o delay definido na variável global delay_time.

O tempo pode ser excedido porque todas as modificações são protegidas pelo filtro Busy_and_Connected(). Ou seja, entre apenas se o fluxo de negócio estiver livre.

Deve ser explicado aqui que no MetaTrader 4 (em contraste ao MetaTrader 5) é impossível enviar uma série de comandos para o servidor sem ter uma nova cotação. O servidor pode apenas aceitar a primeira solicitação, o resto será perdido. Porém, antes de dar o comando ao servidor, precisamos verificar se o fluxo de negócio está livre.

A segunda verificação para sair do ciclo é a função descrita acima de comparação de posição por níveis de parada compare_sl_tp_levels(): se as posições forem iguais, então saia do ciclo.

Agora vamos para o difícil: a função processing_signals () é organizada de forma similar, mas a parte lógica é muito diferente em sua funcionalidade.

Vamos analisar detalhadamente esta parte:

//--- convert the direction of the position stored in the file to the form -1,+1            
int TF=SymPosType[i]*2-1;
//--- convert the direction of the real position to the form -1,+1
int TR=realSymPosType[i]*2-1;
//--- save the volume of the position stored in the file                     
double VF=SymPosVol[i];
//--- save the volume of the real position 
double VR=realSymPosVol[i];
double lot;
//--- if the positions for the current symbol are nor equal
if(NormalizeDouble(VF*TF,8)!=NormalizeDouble(VR*TR,8))
  {
//--- if the real volume is not equal to zero and the directions are not equal or
//--- if the directions are equal and the real volume is larger than that in the file                              
   if((VR!=0 && TF!=TR) || (TF==TR && VF<VR))
     {
      //--- if the directions are equal and the real volume is larger than that in the file 
      if(TF==TR && VF<VR)lot=realSymPosVol[i]-SymPosVol[i];
      //--- if the real volume is not equal to zero and the directions are not equal
      else lot=realSymPosVol[i];
      //--- close the calculated volume and exit the cycle                  
      close_market_order(Symbols[i],lot);
      break;
     }
   else
     {
      //--- if the directions are equal and the real volume is less than that in the file 
      if(TF==TR && VF>VR)lot=SymPosVol[i]-realSymPosVol[i];
      //--- if the directions are not the same and the volume is equal to zero                  
      else lot=SymPosVol[i];
      //--- open the calculated volume and exit the cycle 
      open_market_order(Symbols[i],SymPosType[i],lot);
      break;
     }
  }

As variáveis TF e TR armazenam o valor do tipo da posição na forma de buy=-1,sell=1. Consequentemente, TF é o valor armazenado no arquivo, e TR é o valor real da posição virtual. O mesmo ocorre com os volumes VF,VR.

Assim, a diferença:

if(VF*TF!=VR*TR)

será true no caso dos tipos de posições e volumes não forem iguais.

E então vem o conector lógico:

if((VR!=0 && TF!=TR) || (TF==TR && VF<VR))

que significa que se o volume real não for igual a zero, e os tipos não forem iguais, então você deve fechar a posição inteira.

Isso inclui as opções quando o volume no arquivo for zero e a opção quando a posição for reversa na direção. Na variável, quando a posição está na direção reversa, primeiro você deve preparar a posição para abertura, ou seja, fechar o volume anterior. Então, com a próxima interação, a lógica vai para outro ramo, para abertura.

A segunda condição complexa do conector lógico significa que se o tipo for correto, mas o volume real for maior que o armazenado no arquivo, você deve reduzir o volume real. Para este propósito, primeiro calculamos o tamanho do lote pelo qual é necessário reduzir o volume.

Se nenhuma condição de fechamento for adequada para esta situação, e as posições (como descobrimos no primeiro filtro) não forem iguais, um novo pedido deve ser aberto. Aqui também há duas variações: abrir um pedido para o tamanho inteiro da posição no arquivo ou adicionar a pedidos existentes. Aqui eu gostaria de observar que a verificação para o excesso do volume limite está disponível na função de abertura, então o volume faltante (se não for possível com a verificação) será aberto na próxima iteração do algoritmo. Devido ao fato que primeiro a situação de fechamento é manipulada, e apenas então a abertura, a situação de Lock é quase impossível.

Gostaria de mencionar um local de código sutil. A situação de reabertura do pedido, que acabou de ser fechado no MetaTrader 4 por paradas. Mencionei anteriormente que a discrepância das cotações frequentemente está dentro dos 2-3 pontos dos 5 dígitos. Com o spread igual a 15, a diferença é insignificante. Mas com esta diferença, se o stop loss ou o take profit for disparado no MetaTrader 4 antes que no MetaTrader 5, uma situação apareceu quando o algoritmo estava tentando recriar a posição recém fechada, com sua remoção subsequente com as paradas disparadas no MetaTrader 5.

Ele não traz grandes perdas, mas um spread foi desperdiçado. Portanto, o algoritmo foi redesenhado para que após a remoção de uma posição, o MetaTrader 4 não a restaure, mas aguarde até que o estado do arquivo mude. E apenas aí voltará a agir. Nesta situação, o comerciante pode remover a posição manualmente, se ele achar que está errada. E ela não ser restaurada até que o MetaTrader 5 realize alterações no arquivo.

O único ponto fraco é a rara situação onde as paradas do MetaTrader 4 removerão a posição, e no MetaTrader 5 a posição não será fechada. Neste caso, posso aconselhar a reiniciar o script Copyist positions. E a última cláusula - o código não verifica o trabalho nos fins de semana. Nada sério, apenas o log estará cheio de recotações sem valor.

5. Verificando a implementação na prática

Instale o MetaTrader 4 no diretório C:\Program Files\MetaTrader 5\MQL5\Files\

Execute o Expert Advisor compilado Translator positions em qualquer gráfico no MetaTrader 5 (o trabalho do Expert Advisor não depende do gráfico no qual está sendo executado).

 

Figura 2. Posições do tradutor no MetaTrader 5

Vemos um comentário de múltiplas linhas com o estado do contador na primeira linha e o log de todas as posições linha a linha.

Execute o script compilado Copyist positions em qualquer gráfico no MetaTrader 4 (o trabalho do script em loop não depende do gráfico no qual está sendo executado).

Figura 3. Posições do copiador no MetaTrader 4

Então podemos executar qualquer Expert Advisor no MetaTrader 5. Os resultados de sua operação serão rapidamente copiados para o MetaTrader 4.

Figura 4. Posições e pedidos no MetaTrader 4 (topo) e MetaTrader 5 (abaixo)

Aliás, o gerenciamento de contas no MetaTrader 5 pode ser realizado manualmente, ou pode-se efetuar o login da conta usando a senha de investidor.

Então, por exemplo, você pode iniciar o copiador em qualquer conta Championship.

Conclusão

Este artigo tem o propósito de acelerar a transição de comerciantes para a nova plataforma, e para encorajar o estudo do MQL5.

Em conclusão, gostaria de dizer que este código não pode substituir completamente a negociação direta em uma conta real no MetaTrader 5. Ele está escrito como um código universal para qualquer sistema de comércio sem levar em consideração a lógica, portanto, como tudo que é universal, não é ideal. Mas baseado nele, você pode escrever um tradutor de sinais para uma estratégia específica. Para muitos comerciantes que estão longe de programar, ele pode servir como um estágio de transição na antecipação do lançamento.

Para aqueles que estão familiarizados com programação, recomendo modificar o código para fazê-lo reconhecer pedidos por seu número mágico e implementar a transferência e classificação de pedidos pendentes. A classificação de pedidos pendentes não afetará o lucro, uma vez que há uma conexão estável com o servidor. Se essa perda de conexão acontecer frequentemente, todo o caminho do servidor, incluindo pedidos pendentes, deve ser copiado.

Aprenda a nova linguagem e use-a para desenvolver um sistema robusto. Boa sorte em sua negociação.