Modificando os parâmetros externos dos programas MQL4 sem reiniciá-los

Introdução

Todos que já abriram um EA ou um indicador para execução, encontraram a possibilidade de configuração preliminar dos parâmetros externos que geralmente dão base ao sucesso do programa. Há uma possibilidade de modificar os parâmetros durante a operação do programa. Mas como isso pode ser feito sem a inicialização? Em alguns casos, isso pode afetar o gerenciamento das ordens abertas anteriormente. Nesse artigo, tentaremos resolver esse problema da forma mais flexível possível.

Declaração do problema

Iremos considerar esse problema mais para os Expert Advisors do que para os indicadores. Para indicadores, esse problema não é tão exato, embora os métodos sejam universais e você possa aplicá-los a qualquer programa.

Na escrita clássica do EA, o contexto deve ser criado em cada tick. Podem haver dois tipos de contextos - o contexto de status e o contexto de trading. O contexto de status contém os estados atuais de indicadores e outros elementos que dão base à tomada de decisão na abertura/fechamento/modificação de ordens. O contexto de trading contém a informação sobre ordens abertas, seus status e quantidades. Depois que o contexto de trading foi analisado, os traders tomam as decisões sobre o que fazer com suas ordens. Contextos são divididos por tipos condicionalmente. Essa classificação foi introduzida para conveniência.

Se o contexto puder ser restaurado a cada tick, o problema não aparece. Você pode modificar livremente os parâmetros externos e o seu EA continuará operando de acordo com sua lógica. Primeiro, haverá a inicialização, então o EA irá calcular os valores de indicadores, "tomar" ordens de abertura e realizar um número de operações de acordo com a informação coletada. Tudo é fácil e transparente.

Agora vamos considerar uma situação onde uma tecnologia de modificação de parâmetro mais precisa é necessária e que não resultará na reinicialização completa do programa.

Exemplo 1.
Entre nossas ordens abertas, há algumas processadas de uma forma especial. Ou seja, precisamos encontrá-las entre as outras ordens abertas pelo nosso EA. Para esta finalidade, poderemos usar alguns parâmetros: Ticket, Magic Number (Número Mágico), Currency (Moeda), Comment (Comentário). O Magic Number é usado para separar nossas ordens abertas no sistema por outros EAs ou manualmente. O 'Currency', junto com o 'Magic Number', nos permite usar o mesmo EA para diferentes pares cambiais. Restam apenas dois parâmetros que podem ser únicos para cada ordem. O ‘Comment’ é o mais adequado, ele pode conter qualquer informação textual, mas tem uma desvantagem - pode ser modificado no lado do servidor, por exemplo, em fechamento parcial. O ‘Ticket’ é único para cada ordem, mas o número de ticket sozinho não é suficiente para dividir as ordens por classes, então os tickets de ordens devem ser comparados a alguma outra informação. Como podemos ver, nessa situação, seria mais conveniente usar o parâmetro 'Ticket' e armazenar os tickets de acordo com as classes das ordens. Por consequência, na reinicialização, o arranjo contendo os tickets irá se perder,então não seremos capazes de restaurar a informação sobre as classes virtuais das ordens.

Exemplo 2.
Um mecanismo universal é desenvolvido e nos permite analisar as modificações nos status das ordens. Ou seja, temos dois contextos de status de ordens. A primeira lista está no tick atual, enquanto a segunda está no tick anterior. Ao analisar a informação, podemos tirar algumas conclusões sobre qual ordem foi aberta/modificada/fechada e sobre as razões para tais operações. Esse método é muito confortável tanto para depurar o EA quanto para desenvolver lógica de trading. Entretanto, a sua desvantagem é que é necessário salvar os status da ordem no tick anterior. Correspondentemente, esses dados irão se perder na reinicialização do EA.

Exemplo 3.
Um EA está recebendo dados externos. Não importa de qual forma ou de onde os dados estão chegando. É importante que, se nós precisarmos acumular esses dados para processamento e não pudermos solicitar seu histórico, então teremos que criar um contexto durante todo o trabalho do EA. Modificar os parâmetros externos irá resultar na reinicialização do sistema e termos que acumular dados de uma fonte externa novamente.

Exemplo 4.
Um programa MQL4 é distribuído como um arquivo compilado. Assim, os usuários não podem modificar seu código ou ver seus algoritmos. É uma grande proteção da sua propriedade intelectual. Entretanto, o programa deve ter variáveis externas e não é muito confortável modificá-las toda vez, em vez de fazer isso uma vez e compilar com os novos valores. Embora esse exemplo não interesse diretamente para o problema do armazenamento de contexto, é muito comum que o problema seja resolvido aqui.

Ao criar EAs, você deve construir sua lógica de tal forma que evite o armazenamento do contexto durante as operações. Tal desenvolvimento pode ser muito mais complicado, nesse caso, mas o sistema estará o mais estável possível. Se, entretanto, não pudermos evitar o armazenamento do contexto, o método sob consideração irá nos ajudar a gerenciar de forma flexível as configurações do EA sem perder os dados ao modificar os parâmetros.

Aplicação

Para resolver os problemas nos exemplos acima, vamos desenvolver um complexo que iria gerenciar os parâmetros externos dos programas MQL4. O que pode ser feito usando tal sistema?

Por definição, podemos modificar os parâmetros externos de todos os tipos:

• Integer
• Bool
• Double
• String
• Datetime

Entretanto, não deveríamos ficar satisfeitos com o que já foi alcançado. Para dar conta de todo o potencial dessa abordagem, deveríamos considerar os princípios do sistema em um exemplo mais simples.

O complexo funciona da seguinte forma: No estágio inicialização, o programa MQL4 salva todos os valores que podem ser modificados pelo usuário no arquivo correspondente. O programa externo abre esse arquivo, lê os dados, os coloca na tela e então, o usuário começa a trabalhar. Assim que o usuário modifica um dos parâmetros no programa externo, o arquivo é modificado. Ou seja, o novo valor configurado pelo usuário será escrito no lugar do antigo. Então o programa MQL4, na função solicitar 'start' ('início') irá verificar o arquivo de dados para valores modificados e, se qualquer modificação tiver sido encontrada, solicitar as funções correspondentes. As funções processando as modificações em valores externos executam alguns algoritmos pré-configurados. Na maioria dos casos, será suficiente apenas para designar os novos valores para as variáveis. É dessa forma que um ciclo do complexo de modificações dos parâmetros externos funcionam aproximadamente.

A partir do exemplo acima, podemos ver que a criação de diálogo estável entre o programa MQL4 e um programa externo é mais importante para o complexo funcionar de forma bem sucedida. Agora temos que escolher os meios e métodos para organizar o diálogo. Entretanto, até mesmo para a mais simples abordagem sem usar DLLs, podemos nos permitir mais do que somente modificar parâmetros externos.

Vamos considerar alguns exemplos que revelam características adicionais dessa abordagem. Uma vez que temos um diálogo bilateral, o programa MQL4 pode responder ao pedido a partir do programa externo.

Por exemplo, um usuário modifica o valor de uma variável. O programa externo escreve o arquivo com o valor novo da variável e modifica o status dessa variável para "aguardando por uma ação do programa MQL4". Ao processar o arquivo, o programa MQL4 considera somente variáveis que tem esse status, as outras não foram modificadas. Ao processar as variáveis encontradas, modificamos o status para "changes accepted" ("modificações aceitas".) Assim, em um programa externo, podemos ver quando a modificação foi realizada diretamente no programa MQL4. É uma função útil para monitoramento.

Vamos tentar realizar a função de "action" ("ação"). Precisamos entender que modificar uma variável em um programa externo não resulta em modificar a variável correspondente em um programa MQL4, mas em executar uma certa ação apenas uma vez. Isto pode ser feito como se segue: A variável é modificada em um programa externo. A variável pode tomar o valor de 0 e 1. Se o valor for 1, o programa MQL4 executa uma certa ação e designa o valor de 0 para a variável. Agora essa ação pode ser realizada novamente a partir de um programa externo. Isso é mais do que apenas modificar variáveis. Usando as ações, podemos realizar muitas funções úteis. As ações são quase as mesmas do que os scripts do MQL4, mas tem uma diferença significante. Um script pode ser executado em qualquer momento da operação do terminal do cliente do MetaTrader4, enquanto uma ação só pode ser realizada assim que a função 'start' ('início') é solicitada, ou seja, no momento da modificação de preço atual.

No final, podemos considerar um exemplo de como usar o método para transferência de dados a partir de uma fonte externa em um programa MQL4. Suponha que não precisemos modificar nenhuma variável externa, mas um programa MQL4, ou até mesmo um EA, deve ser gerenciado a partir de uma fonte externa. A fonte externa processa os dados, faz cálculos, e com base nos resultados obtidos, toma uma decisão a respeito de abertura/fechamento de ordens. Para abrir uma ordem, é necessário passar os parâmetros principais e o comando de abertura para o programa. Os parâmetros da ordem tem o status de "waiting" (aguardando"), uma vez que suas modificações não deveriam forçar o programa a executar as ações. Nesse exemplo, a variável da ação é o evento para leitura dos parâmetros de abertura de ordem.

Consideramos três aspectos ao usar o complexo. O primeiro é transmitir parâmetros com os status em uma direção a partir do programa externo em um programa MQL4. Nesse caso, o diálogo é realizado através da modificação do valor do status. O segundo é o pedido para realizar certas ações. No diálogo, ambos os valores da variável e o valor do status são modificados. O terceiro e mais simples aspecto é extrair a informação do evento armazenada no arquivo. Nenhum diálogo é usado.

Desenvolvendo o complexo

Para desenvolver o complexo, deveríamos resolver alguns problemas. Em primeiro lugar, deveríamos desenvolver a estrutura do documento para transferência de informação entre programas. Então, deveríamos selecionar um protocolo para transferir esse documento. Finalmente, deveríamos escrever bibliotecas para trabalhar com os sistemas usando o MQL4 ou qualquer outra linguagem de programação adequada para um programa externo específico.

Desenvolvendo a estrutura do documento
Desenvolver a estrutura do documento é uma das tarefas mais importantes para o complexo. O documento deve refletir todos os aspectos descritos acima.

Para o armazenamento de informação, usar a tecnologia XML seria a abordagem mais universal. Entretanto, isso gera muitos problemas. Em primeiro lugar, o MQL4 não tem nenhum meio embutido para trabalhar com XML. Em segundo lugar, se trabalharmos com XML através de DLLs, então o sistema inteiro se tornará muitas vezes mais complicado. Então, vamos usar um arquivo de teto padrão e nossa própria estrutura de representação de dados.

O objetivo principal do documento é uma variável ou um valor. O valor tem uma estrutura muito bem definida consistindo nos seguintes elementos:

• Title
• Type
• Status
• Value

Vamos considerá-los um por um:

Title – o nome da variável. É usado por programas para identificar o objeto.

Type – o tipo da variável. De acordo com o tipo da variável, a lógica de processamento irá mudar. Os tipos são especificados por valores numéricos.

Tipo	Descrição	Análogo em MQL	Valor
0	Booleano ou lógico	bool	0 – false, 1 - true
1	String	string	Um conjunto de características.
2	Característica inteira	int	Valores limite correspondem às regras do MQL4.
3	Característica real	duplo	Valores limite correspondem às regras do MQL4. Delimitador é o ponto.
4	Data	datetime	O formato de gravação corresponde às regras do MQL4.
5	Ação	nenhum equivalente	0 – nenhuma execução é exigida, 1 - execução exigida

Status – um variável de status. É especificado por um valor numérico Vamos considerar uma tabela de variações possíveis:

Valor	Descrição
0	Aguardando. Nenhum processamento é exigido.
1	Solicitação para modificação. O programa MQL4 deve responder a esse valor de status.
2	Nenhum processamento é exigido. É um valor para variáveis que deve ser processado para um evento ao invés de modificação direta da variável.

Value – o valor da variável. As regras para gravar o valor dependem do tipo da variável.
Interação de parâmetros.

Programa externo. Modificando o valor

Se Status=0, então para modificar o valor de 'Value' o valor de Status=1.
Se Status=1, então para modificar o valor de 'Value' o valor de Status não muda.
Se Status=2, então para modificar o valor de 'Value' o valor de Status não muda.

Programa externo. Cancelando a modificação de valor.

Há situações em que um valor é modificado pelo erro ou substituído por um valor errado, ou o usuário mudou de ideia em relação a modificar o valor depois de ter confirmado as mudanças. Vamos considerar a possibilidade de cancelar esse procedimento. Entretanto, deve ser levado em consideração que, se o programa MQL4 já processou os arquivos contendo as modificações, nada pode ser ocultado

Se Status=1, então 'Value' é modificado para o anterior e Status=0.
Se Status=2,então o 'Value' é modificado para o anterior, mas o valor do 'Status' não muda.

Programa MQL4. Processando modificações.

O programa MQL4 considera modificações somente se a variável 'Status' for igual a 1. Por definição, não importa qual tipo de variável foi modificada, uma vez que estamos solicitando a função de processamento para cada mudança. A diferença está somente em onde o 'Value' terá um valor ou não, ou seja, se a modificação de variável é uma modificação ou uma solicitação para execução de um ação. Vamos considerar isso em detalhes.

Se Status=1 e 'Type' variam de 0 a 4, então use 'Value' e modifique o 'Status' para 0.
Se Status=1 e Type=5, então execute um ação e modifique o 'Status' para 0 e modifique o 'Valor' para 0.
Se, no curso da execução da ação, usamos os valores com Status=2, então o valor do 'Status' não modifica depois do uso.

Vamos levar em consideração alguns exemplos.

Exemplo 1. Modificando uma variável.
Vamos acompanhar a variável Var1 do tipo Inteira com o valor de 10. A variável está no status "waiting" ("aguardando").

Title=Var1
Type=2
Status=0
Value=10

No programa externo, modifique o valor de Var1 para 30. Agora temos:
Title=Var1
Type=2
Status=1
Value=30

O valor de 'Value' mudou, assim como o valor do 'Status' mudou para "request for changes processing" ("pedido para processamento de modificações").

O programa MQL4 detecta as modificações, solicita a função necessária e modifica o documento:
Title=Var1
Type=2
Status=0
Value=30

O valor de 'Value' foi aceito, assim como o valor do 'Status' mudou para "waiting" ("aguardando").

Exemplo 2. Executando uma ação.
Vamos acompanhar a variável Var2 do tipo Ação. A variável está no status "waiting" ("aguardando").

Title=Var2
Type=5
Status=0
Value=0

No programa externo, modifique o valor de Var2 para 1. Olhando mais adiante, podemos dizer que, para evitar erros ao designar um valor errado para a ação da variável no programa externo, usamos um botão, não um campo de entrada. Agora temos:
Title=Var2
Type=5
Status=1
Value=1

O valor de 'Value' mudou, assim como o valor do 'Status' mudou para "request for changes processing" ("pedido para processamento de modificações").

O programa MQL4 detecta as modificações, solicita a função necessária e modifica o documento:
Title=Var2
Type=5
Status=0
Value=0

O valor de 'Value' foi aceito, enquanto o valor do 'Status' mudou para "waiting" ("aguardando").
Podemos ver que, ao executar um ação, o valor de 'Status' e o valor de 'Value' irá mudar. Se a variável for modificada, somente o valor do 'Status' irá mudar, também, enquanto o valor da variável permanece o mesmo.

Escolhendo um protocolo de transferência
Entre muitos meios de transferência de dados entre um programa MQL4 e um programa externo, escolhemos o arquivo. Usar o arquivo não exige o desenvolvimento de bibliotecas adicionais para o MT4. O método é mais universal, ocupa menos espaço e é simples de ser realizado. Ele possui várias desvantagens que podem ser facilmente eliminadas e não tem nenhuma limitação.

O programa MQL4 pode responder às modificações no arquivo de variáveis somente após um certo evento, a saber: após modificação do preço atual no par cambial atual.

Podemos iniciar a verificação do arquivo de variáveis a partir de um programa externo a qualquer momento. Deveríamos selecionar intervalos de tempo ótimos para a verificação para não sobrecarregar os recursos de nosso PC e não ocupar o arquivo por um período longo, uma vez que pode ser simultaneamente usado pelo programa MQL4. As mudanças no programa externo são principalmente feitas pelo homem, ou seja, não tão rapidamente quanto um computador, então seria suficiente verificar o aquivo não mais frequentemente do que uma vez a cada meio segundo para acompanhar a situação. Esse parâmetro, claro, deve ser ajustável e você deveria escolher empiricamente o intervalo de tempo você mesmo.

Durante a tentativa de abrir o arquivo com o programa MQL4, ele pode ser aberto com o programa externo para escrita. Portanto, deveríamos prever tal situação e realizar várias tentativas de solicitar o arquivo dentro de um processamento, para não desperdiçar nosso tempo aguardando por uma modificação de preço novo. O mesmo refere-se ao programa externo: Se o arquivo é usado pelo programa MQL4, você deveria fazer várias tentativas de solicitar o arquivo a certos intervalos de tempo.

Adaptação ao MQL4

Variáveis

int    ExVH_VarCnt;
string ExVH_FileName;
string ExVH_Project;
 
string ExVH_Title[];
string ExVH_Type[];
string ExVH_Status[];
string ExVH_Value[];

Funções para o usuário

bool ExVH_Open(string FileName)
{
   bool Result=true;
   ExVH_FileName=FileName;
   if (!ExVH_i_Load())
      Result=false;
   if (Result)
      if (!ExVH_i_GetVarCnt())
         Result=false;
   if (Result)
      ExVH_i_Disassemble();
   return(Result);
}
 
int ExVH_Close()
{
   ExVH_i_Assemble();
   ExVH_i_Save();
 
}
 
int ExVH_GetStatus(int Id)
{
   if ((Id<1)||(Id>ExVH_VarCnt))
      return(-1);
   else
      return(StrToInteger(ExVH_Status[Id-1]));
}
 
int ExVH_SetStatus(int Id, int Status)
{
   int Result;
   if ((Id<1)||(Id>ExVH_VarCnt))
      Result=-1;
   else
   {
      Result=1;
      ExVH_Status[Id-1]=Status;
   }
   return(Result);
}
 
string ExVH_GetValue(int Id)
{
   if ((Id<1)||(Id>ExVH_VarCnt))
      return("N/A");
   else
      return(ExVH_Value[Id-1]);
}

Função para uso interno

bool ExVH_i_Load()
{
   bool Result=true;
   ExVH_Project="";
   int i=0;
   int FS=0;
   int handle;
   int Buf[];
   handle=FileOpen(ExVH_FileName,FILE_BIN|FILE_READ);
   if(handle>0)
   {
      FS=FileSize(handle);
      ArrayResize(Buf,FS);
      while(!FileIsEnding(handle)) 
      {
         Buf[i] = FileReadInteger(handle, CHAR_VALUE);
         i++;
      }
      
      FileClose(handle);
      string Str="";
      for (i=0;i<FS;i++)
         Str=Str+CharToStr(Buf[i]);  
      ExVH_Project=Str;
   } else 
      Result=false;
   return(Result);
}
 
bool ExVH_i_Save()
{
   bool Result=true;
   int handle=FileOpen(ExVH_FileName,FILE_BIN|FILE_WRITE);
   if(handle>0)
   {
      FileWriteString(handle,ExVH_Project,StringLen(ExVH_Project));
      FileClose(handle);
   } else
      Result=false;
   return(Result);
}
 
bool ExVH_i_GetVarCnt()
{
   bool Result=true;
   string Value=ExVH_i_GetVarValue("Var_Cnt");
   if (Value=="N/A")
      Result=false;
   else
      ExVH_VarCnt=StrToInteger(Value);
   return(Result);
}
 
void ExVH_i_Disassemble()
{
   int i;
   ArrayResize(ExVH_Title, ExVH_VarCnt);
   ArrayResize(ExVH_Type, ExVH_VarCnt);
   ArrayResize(ExVH_Status, ExVH_VarCnt);
   ArrayResize(ExVH_Value, ExVH_VarCnt);
   
   for (i=0;i<ExVH_VarCnt;i++)
   {
      ExVH_Title[i]=ExVH_i_GetVarValue("Var"+(i+1)+"_Title");
      ExVH_Type[i]=ExVH_i_GetVarValue("Var"+(i+1)+"_Type");
      ExVH_Status[i]=ExVH_i_GetVarValue("Var"+(i+1)+"_Status");
      ExVH_Value[i]=ExVH_i_GetVarValue("Var"+(i+1)+"_Value");
   } 
}
 
void ExVH_i_Assemble()
{
   ExVH_Project="[ExVH 1.0]\r\n\r\n";
   ExVH_Project=ExVH_Project+"Var_Cnt="+ExVH_VarCnt+"\r\n\r\n";
 
   int i;
   for (i=0;i<ExVH_VarCnt;i++)
   {
      ExVH_Project=ExVH_Project+"Var"+(i+1)+"_Title="+ExVH_Title[i]+"\r\n";
      ExVH_Project=ExVH_Project+"Var"+(i+1)+"_Type="+ExVH_Type[i]+"\r\n";
      ExVH_Project=ExVH_Project+"Var"+(i+1)+"_Status="+ExVH_Status[i]+"\r\n";
      ExVH_Project=ExVH_Project+"Var"+(i+1)+"_Value="+ExVH_Value[i]+"\r\n\r\n";
   } 
}
 
string ExVH_i_GetVarValue(string VarName)
{
   string Result="N/A";
   int Start,Stop;
   VarName=VarName+"=";
   Start=StringFind(ExVH_Project,VarName,0);
   if (Start!=-1)
   {
      Start=Start+StringLen(VarName);
      Stop=StringFind(ExVH_Project,CharToStr('\n'),Start);
      if (Stop!=-1)
      {
         Stop=Stop-1;
         Result=StringSubstr(ExVH_Project,Start,Stop-Start);
      }
   }
   return(Result);
}

Adaptação para C++

O projeto foi escrito no C++ Builder 2007. O arquivo de códigos fonte nomeado ExVH_CPP.zip está anexado ao artigo.

Testando

Vamos realizar um pequeno exemplo demonstrativo que irá mostrar mais possibilidades.
Assim, vamos criar um documento de teste:


[ExVH 1.0]

Var_Cnt=5

Var1_Title=Boolean test
Var1_Type=0
Var1_Status=2
Var1_Value=0

Var2_Title=String test
Var2_Type=1
Var2_Status=2
Var2_Value=Hello world!

Var3_Title=Integer test
Var3_Type=2
Var3_Status=0
Var3_Value=12345

Var4_Title=Double test
Var4_Type=3
Var4_Status=0
Var4_Value=123.45

Var5_Title=Action test
Var5_Type=5
Var5_Status=0
Var5_Value=0

vamos salvar o documento como ExVH.evh na pasta [MetaTrader]/experts/files/.

A assinatura [ExVH 1.0] nos permite reconhecer o documento ao abrir o arquivo e informa sobre a versão da estrutura do documento usada. Se a estrutura do documento muda, a assinatura deve ser modificada também. Isso irá nos permitir evitar misturas, considerando que a extensão do arquivo do documento permanecerá a mesma.

Var_Cnt=5. Esse registro nos informa que o documento contém 5 variáveis.

Então, os registros do mesmo tipo que seguem, contêm a informação de cada variável. Os registros são feitos de acordo com as especificações acima.

VarX_Title=
VarX_Type=
VarX_Status=
VarX_Value=

Assim, temos duas variáveis (Var1 and Var2) que devem ser lidas assim que uma ação aparece (Var5) e duas variáveis (Var3 and Var4), as mudanças delas devem ser consideradas independentemente.
O programa MQL4 deve exibir a mensagem correspondente na tela assim que as modificações forem feitas nas variáveis.

Código MQL4 de teste

int init()
{
   return(0);
}
 
int deinit()
{
   return(0);
}
 
int start()
{
   if (!ExVH_Open("ExVH.evh"))
      return(0);
   
   // Checking for action status
   if (ExVH_GetStatus(5)==1)
   {
      Alert("Actioned!");
      string VarValue;
      if (ExVH_GetValue(1)=="1")
         VarValue="true";
      else 
         VarValue="false";
      
      // Boolean variable value
      Alert("Boolean test variable="+VarValue);
      
      // String variable value
      Alert("String test variable="+ExVH_GetValue(2));
      
      ExVH_SetStatus(5,0);
   }
   
   // Integer variable value
   if (ExVH_GetStatus(3)==1)
   {
      Alert("Integer test variable has been changed. New value="+ExVH_GetValue(3));
      ExVH_SetStatus(3,0);
   }
   
   // Double variable value
   if (ExVH_GetStatus(4)==1)
   {
      Alert("Double test variable has been changed. New value="+ExVH_GetValue(4));
      ExVH_SetStatus(4,0);
   }
   
   ExVH_Close();
   return(0);
}

Abrindo e testando
Não importa qual parte do complexo é aberta primeiro. Que seja o MetaTarder4, nesse caso. Copie anteriormente o arquivo ExVH_Demo.mq4 na pasta [MetaTrader]/experts/ e então inicie o Terminal. O documento ExVH.evh já foi escrito no código do programa. Abra o EA. Nada deve acontecer, uma vez que o EA estará aguardado por modificações no arquivo.

Abra o ExVH.exe previamente instalado no PC.

Visão geral do programa

Abra o "Project" ("Projeto") e selecione o item "Open" ("Abrir")...

Abrindo o documento

O programa carrega variáveis e agora podemos modificá-las.

Na coluna 'Status', dois valores são refletidos: idle (aguardando) e Changed by ExVH (modificações foram feitas em um programa externo). A tela ficará assim depois que tivermos ativado o "Action" ("Ação").

Visão geral do programa com "Action" ("Ação") ativado

Modificações para tipos diferentes de variáveis são feitas de diferentes formas.

Para uma variável boolean, o programa mostra uma das duas mensagens:

Para a ativação do "Action" ("Ação"), ele mostra:

Para todos os outros tipos de variáveis, um formulário separado unificado.

Formulário para modificar os valores de variáveis

Depois de um número de modificações, a janela de 'Alert' ('Alerta') no terminal pode aparecer como segue:

Exemplo de caixa de mensagem durante a operação do programa.

Desvantagens

Qualquer boa ideia pode ter suas vantagens e desvantagens.

• Esse método não pode ser ativamente usado para simulação.
• Mudar os parâmetros pode contradizer a lógica do seu EA. Você deve processar as modificações nas variáveis muito cuidadosamente. É mais uma característica do que uma desvantagem.
• A execução de comandos somente é possível após a chegada de um novo tick.

O que mais pode ser feito

A funcionalidade do sistema pode ser intensificada em várias direções. O campo de ação é praticamente sem limites.

• Modificando parâmetros de acordo com diferentes cenários.. Por exemplo, para senhas, você pode ter um possibilidade de esconder a informação inserida.
• Armazenamento do arquivo cifrada para permitir esconder senhas.
• Você pode modificar o protocolo de transferência de dados tornando-os mais confiável e seguro.

Conclusão

Consideramos as formas de modificação dos valores de variáveis internas nos programas MQL. Agora temos uma oportunidade de gerenciar variáveis externas e outras sem reiniciar o programa.

Arquivos anexados ao artigo

Arquivo	Descrição
ExVH_Demo.mq4	EA de teste
ExVH_Project.zip	Arquivo de projeto preparado
ExVH_CPP.zip	Códigos fonte do programa externo
ExVH_Install.zip	Instalador de programa externo

Observação. ExVH_Install foi feito usando a versão demo do programa Advanced Installer.