Simulação de mercado (Parte 17): Sockets (XI)

Introdução

Nos dois últimos artigos, expliquei como você pode preparar o Excel, para conseguir se comunicar com o MetaTrader 5. Especificamente no artigo anterior, Simulação de mercado (Parte 16): Sockets (X), expliquei como você deveria codificar as coisas em VBA. Isto para que o Excel conseguisse de fato interagir de maneira adequada com o servidor que está escrito em Python. Apesar de que, você muito provavelmente, imaginar que tal interação não geraria nenhum problema.

Nesta pequena fase, onde me dediquei a explicar um pouco sobre soquetes. Mostrei que se as coisas não forem feitas de uma forma bem pensada, você acabará tendo problemas no uso do Excel. Isto quando o servidor em Python estiver sendo usado. Porém como ficou bastante claro e comprovado, nos dois últimos artigos. Uma correta codificação na parte referente ao VBA, corrige qualquer problema relacionado a interação do Excel com o Python. Permitindo que ambos funcionem em perfeita harmonia. No entanto, existe uma última coisa a ser feita. Isto para que a implementação realmente seja concluída. Tal coisa deve ser feita na parte que envolve o MetaTrader 5. E aqui temos algumas decisões a serem tomadas.

Planejamento antes da implementação

Muito provavelmente a principal decisão a ser tomada é: Qual linguagem a ser usada para implementar a parte que executará no MetaTrader 5? Digo isto, pois podemos fazer as coisas aqui, tanto usando Python, quanto usando o MQL5 puro. Ambas linguagens nos permitirão fazer grande parte, se não, a totalidade, do que queremos. Se bem que se tomarmos a decisão de usar o Python. Ficaremos limitados ao fato de que o Python, por ser um script, deverá ser colocado em um gráfico. Já no caso de tomarmos a decisão de usar o MQL5, podemos fazer uso de alguma técnica, ou modelo que melhor se adéque ao trabalho a ser feito.

Mas, e aqui é que a coisa pende totalmente para o uso do MQL5, se formos usar o MQL5, podemos direcionar a solução para um serviço. Ou seja, diferente do Python, que precisará de um gráfico aberto, se usarmos o MQL5, poderemos usar um serviço para nos comunicar com o Excel. Este tipo de coisa, tem diversas vantagens. Talvez, e posso quase afirmar isto.

A maior vantagem é o fato de que um serviço independerá de qualquer outra coisa. Podendo ou não interagir com o gráfico, ou mesmo controlar quase totalmente o MetaTrader 5. Ou para quem ainda não experimentou. Quando usamos um serviço, podemos abrir e fechar um gráfico. Adicionar coisas neste mesmo gráfico. Mudar o que está sendo executado no gráfico, entre outras coisas. Mas o principal, é que pelo fato do serviço rodar fora de um gráfico. Você pode usá-lo, mesmo que o MetaTrader 5, esteja sendo usado para um outro propósito, que não esteja relacionado diretamente ao mercado.

E sim, podemos usar o MetaTrader 5, para outras coisas além de negociação de ativos. Mas isto talvez eu venha a explicar em um outro momento. Isto se eu por ventura achar que seja algo realmente interessante de ser mostrado. Então ficamos decididos. Vamos usar o MQL5, e fazer com que a parte do código a ser executado no MetaTrader 5, seja feito em forma de um serviço. Desta maneira, vamos a implementação.

Implementação

Implementar a parte que será executada aqui no MetaTrader 5, está longe de ser complicado. Mas existem diversos cuidados e pontos de atenção a serem observados. Isto para que você caro leitor, consiga de fato fazer com que o sistema funcione. Lembre-se de uma coisa: Você não executará um único programa. Você estará na verdade, executando três programas ao mesmo tempo. E é importante que cada um seja implementado e construído de forma que trabalhem e conversem entre si. Isto sem que eles fiquem completamente sem saber o que cada um está querendo ou desejando fazer. Por isto é muito importante que você teste o sistema aos poucos.

Primeiro crie o código em Python, que será o servidor. Depois crie e teste o código em VBA que será executado no Excel. E somente e tão somente depois, que o Excel estiver de fato se comunicando com o servidor em Python. E conseguindo dar ordens ou comandos ao servidor, é que você deverá passar para esta parte no MetaTrader 5.

Então fica a dica, para quem deseja criar tal sistema ou implementação. E não tendo tanta experiência no uso de diversos programas ao mesmo tempo. Que faça as coisas aos poucos. Não tente implementar tudo de uma única vez. Crie primeiro um plano, e faça aos poucos. Muito bem, dado este recado, vamos ver o código fonte, e este pode ser visto na íntegra logo abaixo:

01. //+------------------------------------------------------------------+
02. #property service
03. #property copyright "Daniel Jose"
04. #property version   "1.00"
05. //+------------------------------------------------------------------+
06. input string   user01 = "127.0.0.1";    //Address Server
07. input int      user02 = 9090;           //Port Server
08. //+------------------------------------------------------------------+
09. #define def_SizeBuff     2048
10. //+------------------------------------------------------------------+
11. void OnStart()
12. {
13.     bool tab;
14.     int sock;
15.     uint len, id, iMem;
16.     char buff[], ArrMem[];
17.     string szMsg, szCmd, szRet;
18.     
19.     sock = INVALID_HANDLE;
20.     ArrayResize(ArrMem, def_SizeBuff);
21.     while (!IsStopped())
22.     {
23.         Print("Trying to connect...");
24.         while (!IsStopped())
25.         {
26.             if (sock != INVALID_HANDLE)
27.                 SocketClose(sock);
28.             if ((sock = SocketCreate()) != INVALID_HANDLE)
29.                 if (SocketConnect(sock, user01, user02, 1000))
30.                     break;
31.                 else
32.                     Sleep(500);
33.         }
34.         if (!IsStopped())
35.         {
36.             szMsg = "<MT5 with Excel>:MT5";
37.             len = StringToCharArray(szMsg, buff) - 1;
38.             SocketSend(sock, buff, len);
39.             Print("Excel is online...");
40.         }
41.         ArrayInitialize(ArrMem, 0);
42.         iMem = 0;
43.         while (!IsStopped() && SocketIsConnected(sock))
44.         {
45.             szCmd = szRet = "";
46.             id = 0;
47.             do
48.             {
49.                 len = SocketIsReadable(sock);
50.                 len = ((iMem + len) < def_SizeBuff ? len : def_SizeBuff - iMem);
51.                 if (SocketRead(sock, buff, len, 500) > 0)
52.                     ArrayInsert(ArrMem, buff, iMem);
53.                 for (int c0 = 0; (ArrMem[c0] != 0) && (c0 < def_SizeBuff); c0++) switch (ArrMem[c0])
54.                 {
55.                     case '[':
56.                         id = 1;
57.                     case ';':
58.                         if ((SymbolExist(szMsg, tab)) && (id < 2))
59.                             szRet += StringFormat("%f%s", iClose(szMsg, PERIOD_D1, 0), (ArrMem[c0] == ';' ? ";" : ""));
60.                         szMsg = "";
61.                         break;
62.                     case ']':
63.                         id = 2;
64.                         iMem = 0;
65.                         break;
66.                     default:
67.                         switch (id)
68.                         {
69.                             case 0:
70.                                 szMsg += StringFormat("%c", ArrMem[c0]);
71.                                 break;
72.                             case 1:
73.                                 szCmd += StringFormat("%c", ArrMem[c0]);
74.                                 break;
75.                             case 2:
76.                                 for (iMem = 0; (ArrMem[c0 + iMem] != 0) && ((c0 + iMem) < def_SizeBuff); iMem++);
77.                                 ArrayCopy(ArrMem, ArrMem, 0, c0, iMem);
78.                                 break;
79.                     }
80.                 }
81.             }while (SocketIsConnected(sock) && (!IsStopped()) && (id != 2));
82.             if (!IsStopped() && SocketIsConnected(sock))
83.             {            
84.                 if (szCmd != "")
85.                 {
86.                     Print(szCmd, "<CMD<");
87.                     szRet = "N/D";
88.                 }
89.                 len = StringToCharArray(szRet, buff) - (szCmd != "" ? 1 : 0);
90.                 SocketSend(sock, buff, len);
91.             }
92.         }
93.     }
94.     if (sock != INVALID_HANDLE)
95.         SocketClose(sock);
96.     ArrayFree(ArrMem);
97.     Print("Shutting down...");
98. }
99. //+------------------------------------------------------------------+

Código em MQL5

Antes de começar a explicar este código. Quero ressaltar que ele tem apenas fins didáticos. O que estamos fazendo aqui, é apenas arranhando a ponta da ponta do iceberg. Não considere que isto é tudo que podemos fazer. Mas se você, caro leitor, e aspirante a se tornar um programador realmente de qualidade, entender o que está acontecendo. Poderá conseguir fazer muitas coisas bastante legais e interessante. Isto usando estes códigos vistos até aqui, como primeiro passo e uma possível referência.

Muito bem, vamos então começar a entender o que este código está fazendo. Mas antes e para lhe deixar ainda mais empolgado e atento a explicação que tal ver o que acontece quando tudo estiver funcionando? Pois bem, é justamente isto que você pode ver logo abaixo. Primeiro o que está acontecendo no Excel. Lembrando que quando esta animação estava ocorrendo, o serviço já estava sendo executado no MetaTrader 5 conforme você verá na outra animação.

Agora olhando na caixa de mensagens no MetaTrader 5, ao mesmo tempo que as coisas aconteciam no Excel. Você veria as seguintes coisas acontecerem:

Legal, não é mesmo? Lembrando que estas duas aplicações, tanto o Excel, quanto o MetaTrader 5, podem estar em máquinas diferentes. E ainda assim você teria os mesmos resultados. Agora que já passei mel e possivelmente lhe deixei curioso. Vamos ver como este código em MQL5 funciona, já que as demais partes já foram explicadas nos artigos anteriores.

Dessecando o código em MQL5

Na linha dois, estamos indicando que o código será um serviço. Caso esta linha não existisse, este mesmo código seria um script. Já expliquei em artigos anteriores, a diferença entre serviço e scripts. Mas se você tem alguma dúvida, entenda o seguinte: Um serviço não está diretamente ligado ao gráfico. Já um script está ligado a um gráfico. Mas tanto o código de um serviço quanto o código de um script, serão basicamente idênticos. A única diferença entre eles é justamente esta linha dois.

A próxima coisa que é preciso entender é justamente as linhas seis e sete. Estas servem para que o usuário, ao lançar o executável no MetaTrader 5, possa dizer, ou para ficar mais claro. Informar ao executável alguns parâmetros. Tais parâmetros são exatamente os que precisam ser ajustados. Ou seja, o endereço onde o servidor Python está executando, assim como a porta deste mesmo servidor.

Atenção a este detalhe: Você não deverá informar onde o Excel está sendo executado. Mas sim onde o servidor Python está sendo executado. Este tipo de coisa pode parecer um pouco confuso. Mas lembre-se do seguinte: O servidor em Python, não está de forma alguma, embutido no Excel. Podendo estar em uma outra máquina. Porém é preciso que o Excel, saiba como localizar este mesmo servidor. Para entender isto, veja o artigo anterior, onde expliquei a parte do código que existirá no Excel e que é feito em VBA.

Feitas esta parte inicial e básica. Chegamos a linha 11, e é justamente aqui que o código realmente começa a ser executado. Assim, entre as linhas 13 e 17 temos a declaração de algumas variáveis para serem usadas neste código em particular. Agora vem a parte que talvez possa ser um pouco confusa neste primeiro momento. Mas fará todo o sentido depois. Observe, que na linha 19, inicializamos uma das variáveis. O motivo disto é que todo o código está completamente contido em um grande loop. Este loop se inicia na linha 21 e vai até a linha 93. Sendo que a única forma de encerrar este loop é finalizando o serviço manualmente ou fechando o MetaTrader 5.

Para sabermos em que pé estamos, em termos de conexão com o servidor. Imprimiremos algumas mensagens na caixa de mensagem do MetaTrader 5, da mesma forma que você viu nas animações acima. Assim a primeira mensagem a ser impressa é vista na linha 23. Nela simplesmente dizemos que o cliente, aqui no MetaTrader 5, está tentando se conectar. Isto por que na linha 24 entramos em um novo laço infinito. E este laço é infinito justamente pelo fato de que ele somente é encerrado, quando o programa também é encerrado.

Mas espera um pouco. Esta coisa de colocar um laço infinito dentro de outro não faz o mínimo sentido. Por que fazer isto? Calma meu caro leitor, calma. Este laço da linha 24 é infinito, mas ele é encerrado em um momento muito especial. Mas já que a variável que contém o soquete, já pode conter algum valor, precisamos primeiro liberar o soquete antigo. Isto é testado e feito na linha 26 e a liberação ocorre na linha 27. Por isto é importante que a linha 19 exista. Se não configurarmos a variável dizendo que não existe nenhuma conexão, poderíamos ficar na dúvida em fazer esta liberação aqui na linha 27.

Então ficamos acertados. Se existia uma conexão, ela será fechada. Se não existia, não fazemos nada. No entanto, na linha 28 tentamos criar um soquete. Isto muito provavelmente terá êxito. Porém, toda via e, entretanto, o fato de alocarmos um soquete, não nos diz que uma conexão ocorreu. Então se na linha 29 não venhamos a ter sucesso em nos conectar ao servidor, teremos a execução da linha 32. Esta irá produzir uma pequena pausa para que possamos tentar novamente.

Porém, e aqui é que mora a questão do laço infinito da linha 24. Se não tivermos sucesso em nos conectar ao servidor, teremos alocado um soquete. E se isto ocorreu, precisamos devolver ele ao sistema operacional. E voltamos a cair no teste da linha 26. Porém desta vez este teste será bem sucedido, assim teremos a execução da linha 27, que libera o soquete alocado. E ficamos nesta de alocar e desalocar o soquete, até que consigamos nos conectar, ou até que o programa seja finalizado pelo usuário.

Porém, se você olhar a animação acima, verá quem em um dado momento, começamos a transmitir e receber dados. Mas se este laço da linha 24 nunca se encerra, como isto foi acontecer? O motivo é justamente a linha 29. Observe que quando tivermos sucesso, e conseguirmos nos conectar ao servidor, iremos executar a linha 30. E é neste ponto que saímos do laço iniciado na linha 24.

Agora veja só que coisa interessante. Na linha 34, somente teremos sucesso, se e somente se, o programa não foi encerrado pelo usuário. Ou seja, neste caso estamos conectados ao servidor. E com isto, precisamos dizer ao servidor quem somos. Assim temos a mensagem a ser enviada ao servidor sendo criada na linha 36. Preste atenção a esta mensagem. Ela tem que ser reconhecida pelo servidor. Se ela não for reconhecida, o servidor irá desconectar o cliente e voltaremos a laço da linha 24. Muita atenção então, se você for fazer qualquer mudança no sistema no futuro. Mas se tudo ocorreu bem, e o servidor nos reconheceu, como um cliente válido. Precisaremos fazer algumas coisas e tomar alguns cuidados. Por conta disto é que temos na linha 41 a limpeza de um buffer de memória. E logo depois na linha 42, apontamos para a posição zero neste buffer.

Se você é novo no que rege programação de soquetes, com toda a certeza não entende por que deste trabalho nas linhas 41 e 42. Mas se você já é calejado no assunto, sabe que, quando um soquete é escrito, ele pode acumular muito mais informações do que esperamos ver quando o lemos. E para ser mais específico, isto acontece muito em conexões do tipo TCP. E já que não queremos e não desejamos perder nenhum pedido ou requerimento vindo do Excel, por meio do servidor. Precisamos nos precaver e evitar que venhamos a perder alguma informação. Por isto a necessidade de fazer algumas coisas. Mas para entender melhor, como isto de fato é feito e por que de fazer isto, precisamos ver um pouco mais do código.

Então entramos em um novo laço e desta vez é o laço principal, ou seja, é justamente aquele que fica responsável pela troca de mensagens entre o Excel e o MetaTrader 5. Este laço se inicia na linha 43. Agora repare na declaração deste laço. Note que estamos testando o encerramento do programa, assim como se o soquete ainda está conectado. Mas vamos considerar que está tudo nos conformes e que podemos entrar e permanecer dentro deste laço por um longo tempo.

Desta maneira, as primeiras coisas a serem feitas são inicializar algumas variáveis. Isto é feito nas linhas 45 e 46. E logo depois entramos em um outro laço que vai da linha 47 até a linha 81. Agora preste bastante atenção ao que irá acontecer dentro deste novo laço. Isto por que é justamente nele que as coisas deverão ser modificadas ou melhoradas. Caso você deseje ou precise fazer algumas outras coisas, além das que estou mostrando e comentando. Muito provavelmente isto irá ocorrer, quando você vier a existir uma maior necessidade de passar mais informações o Excel. Ou mesmo entender os comandos que estarão chegando ao Excel.

Logo de cara, na linha 48 observamos qual a quantidade de informações que existem no soquete. Assim que isto é visto, tentamos ler estas mesmas informações na linha 51. Mas existe um pequeno detalhe, e que você pode querer mudar. Observe que na linha 49, verificamos se a quantidade de informação a ser colocada no buffer de memória, excede o tamanho do buffer alocado. No caso estou simplesmente mudando a quantidade de dados a serem lidos, de forma a não exceder o tamanho já alocado. Mas se você desejar, pode mudar o tamanho da área alocada. Mas de uma forma ou de outra, no final, o resultado será muito parecido.

Então, dada esta explicação sobre o motivo da linha 50, podemos passar para a linha 51. Note que se for feita a leitura de qualquer dado, teremos na linha 52 a inserção destes dados na memória alocada. Neste ponto da explicação esta linha 52 não faz o menor sentido. Sendo quase uma coisa sem motivo de existir. Mas continuemos a ver como o código funciona, assim esta linha passará a fazer sentido. Porém, é preciso que você entenda, que os dados lidos do soquete, serão colocados a partir de uma dada posição. Esta posição é indicada pela variável iMem. Não se esqueça deste detalhe, pois na primeira leitura feita, esta variável iMem, contém o valor zero. Mas pode ser que nas próximas leituras ela venha a ter um valor diferente.

Assim, chegamos a linha 53. Aqui iniciamos um laço que é o cerne deste código. Já que ele irá de fato fazer muito do trabalho que será feito aqui neste código. Veja que nele verificamos algumas condições, se elas forem satisfeitas, iremos executar uma série de pequenos passos. Tais passos representam o protocolo de comunicação entre o MetaTrader 5 e o Excel. Então qualquer mudança feita aqui, deverá ser pensada também em ser feita no código em VBA. Isto considerando que o VBA tratará das respostas feitas pelo MetaTrader 5. Se o tratamento for feito no código do servidor. Você precisará fazer as devidas mudanças no código em Python.

Muito bem, este laço da linha 53, varrerá a mensagem postada, carácter por carácter a fim de entender o que está acontecendo. Mas principalmente para saber como proceder. Mas aqui preciso fazer uma pequena ressalva, que é o fato de que este código tem como finalidade ser didático. Porém, se você conseguir entender como as coisas aqui funcionam, conseguirá tornar este mesmo código, um código adequado as suas necessidades particulares.

Muito provavelmente imaginará diversas outras formas de fazer a mesma coisa, que está sendo feita aqui. Uma delas seria usando a função StringSplit. E você não estaria errado em fazer isto, apenas seria algo um pouco mais complicado de ser feito. Isto dependendo, é caro, do protocolo de mensagens que você usará. Aqui no caso o protocolo é bastante simples. Antes do colchete, temos o ativo a ser observado. Já dentro do colchete temos o comando a ser executado. Simples assim. Mas como aqui, a parte sobre os comandos, que representam compra e venda a mercado. Você não terá esta funcionalidade. Mas não se preocupe com isto.

No final deste artigo, irei lhe dar as referências necessárias para fazer isto. Visto que tal coisa já foi implementada aqui no sistema de replay/simulação. Mas para quem não esteja acompanhando esta sequência, não saberá como fazer tal coisa. Porém não é algo difícil de ser feito. Apenas precisará que você crie o protocolo para isto. Mas para criar tal protocolo, você precisará saber como fazer para conseguir executar os comandos dados. Assim sendo, não se esqueça de conferir, caso não tenha ideia de como fazer isto, os artigos que deixarei como referência.

Então voltando ao código, temos logo de cara uma coisa que pode confundir muita gente, principalmente que esteja iniciando. Observe a linha 55. Neste ponto temos um abre colchete. Este representa o fim do nome de um ativo, e o início de um comando dado pelo Excel. Para diferenciar as coisas, na linha 56, trocamos o valor da variável id, que era de zero para um. Não se esqueça deste detalhe. Quando o laço se iniciou o valor da variável id era de zero, devido a linha 46. Isto na primeira vez que o laço da linha 43 começou a ser executado. Muita atenção a estes detalhes.

Como um abre colchete, indica que o nome do ativo, já deva ter sido capturado, precisamos fazer com que os dados deste ativo sejam obtidos. No caso aqui, iremos apenas pegar o preço de fechamento da barra. Somente isto, mas você pode capturar qualquer informação que desejar ou precisar. Para isto bastará criar as regras que indicarão qual o valor a ser obtido. Mas voltemos a questão principal. Observe que esta case da linha 55, invade a case da linha 57. Isto sem que haver um comando break entre elas. Mas pode isto? Sim podemos fazer isto. Porém antes de explicar a case da linha 57, note que ela é um outro carácter. Por que?

Agora vem a parte que realmente faz muita diferença. Este carácter indicado na case da linha 57, está na verdade dizendo que existe uma forma de separar diversos ativos. Ou seja, caso o Excel, queira buscar informações de diversos ativos, ele pode fazer isto, separando cada um dos ativos por meio deste carácter. Mas se você observar o código presente no VBA, que é visto no artigo anterior, notará que ele não está lidando com tal funcionalidade. Ele simplesmente imprime o retorno em uma única célula. De fato, fica como um objetivo, a você caro leitor, separar isto e transferir a informação para uma célula adequada. Como não sei a forma de cada um fazer a planilha, a forma de fazer esta separação mudará de caso a caso. Mas não é algo nada complicado de ser feito. Apenas dependerá de como você criará a sua planilha específica.

Então tudo bem, de qualquer forma, na linha 58, testaremos se o ativo buscado existe. Se sim, na linha 59 criaremos uma string de retorno. Porém atenção a isto. Apesar de estarmos criando uma string de retorno, ela de fato não será a que iremos retorna para o servidor e possivelmente para o Excel. Mas para frente você entenderá o motivo disto. Agora, como acabamos de observar um ativo, na linha 60, limpamos a string para tentar capturar o próximo e na linha 61, temos o comando break para não invadimos o próximo case.

Neste próximo case, que está na linha 62, temos um fecha colchete. Quando isto acontece, indica que o comando dado pelo Excel foi capturado, e entraremos no que rege o nome do próximo ativo. Mas mesmo que exista, mais informações lidas no soquete, estas não serão usadas agora. Isto por que no teste da linha 58, irá perceber que a linha 63 indica para não usar os dados. Muito bem, esta foi a parte onde separamos os ativos, do comando. Mas precisamos saber o que cada coisa de fato é. Então caso nenhuma case seja executada, teremos a execução da região default, que se encontra na linha 66.

Note o seguinte: O tipo de informação e o tratamento que será dada a esta informação, dependerá do valor da variável id. Assim enquanto ela for zero, teremos a captura do nome do ativo. Isto é feito na linha 70. Quando a id for um, teremos a captura do comando dado pelo Excel. Isto é feito na linha 73. Agora, se o valor for dois, iremos mover os dados da atual posição, para o início da região de memória.

Agora repare no que faz o laço iniciado na linha 47, finalizar na linha 81. Umas das causas será justamente o fato de termos capturando o fim do bloco de comando. E com isto entramos no final de todo o trabalho. Mas antes precisamos fazer um outro teste que é feito na linha 82. Se tivermos sucesso, termos mais um novo teste. Este visa verificar se existe algum comando sendo dado. Se houver então um comando este terá prioridade sobre qualquer outra coisa. E é neste ponto na linha 86 que você deverá fazer o que foi visto em outros artigos aqui, nesta mesma sequência. Isto para que consiga executar um requerimento de compra ou venda, vindas do Excel.

Para fazer isto de forma adequada, estude o material de apoio que estarei indicando na área de referências. E como resposta a pedido de execução de um comando, o valor de retorno ou resposta do MetaTrader 5, é modificado. Deixando de ser os dados capturados nos ativos, e passando a ser uma string específica. No final temos nas linhas 89 e 90, o envio da resposta do MetaTrader 5. Note que esta resposta dependerá do fato de estarmos executando um comando ou capturando dados de algum ativo.

Considerações finais

Apesar de que, não ter colocado neste código mostrado, a implementação de como fazer para executar um comando dado pelo Excel. Você poderá notar que a comunicação entre o Excel e o MetaTrader 5, se dará de uma maneira bastante suave e sem muitos percalços. Se bem, que você muito provavelmente sentirá necessidade de fazer algumas pequenas melhorias e ajustes em parte desta implementação. Porém, se isto ocorrer, significará que de fato consegui atingir o meu objetivo durante esta fase em que expliquei sobre como fazer uso de soquetes. Já que muitos, acredito eu, não faziam a mínima ideia de que é sim possível, operar em um mercado, sem necessariamente estar olhando o gráfico no MetaTrader 5. Isto fazendo uso de algum tipo de estudo fundamentalista ou algo semelhante.

Apesar de que para de fato implementar a parte responsável por envio de ordens, precisar de que você implemente algumas outras questões neste sistema. Não vejo, problema em não mostrar como fazer isto aqui. Quero de fato que você tenha o correto entendimento do que estará fazendo. Por conta disto é que não mostrarei a implementação final. Mas se você estudar os artigos de referência, com toda a certeza conseguirá implementar tal funcionalidade. Então no próximo artigo, iremos abordar um outro tema, que igual a este sobre soquetes, é de grande necessidade ser explorado. Isto antes que venhamos a voltar a nossa atenção novamente ao sistema de replay / simulador.

Referências:

Desenvolvendo um sistema de Replay (Parte 74): Um novo Chart Trade (I)

Desenvolvendo um sistema de Replay (Parte 75): Um novo Chart Trade (II)

Desenvolvendo um sistema de Replay (Parte 76): Um novo Chart Trade (III)

Desenvolvendo um sistema de Replay (Parte 77): Um novo Chart Trade (IV)

Desenvolvendo um sistema de Replay (Parte 78): Um novo Chart Trade (V)

Arquivo	Descrição
Experts\Expert Advisor.mq5	Demonstra a interação entre o Chart Trade e o Expert Advisor (É necessário o Mouse Study para interação)
Indicators\Chart Trade.mq5	Cria a janela para configuração da ordem a ser enviada (É necessário o Mouse Study para interação)
Indicators\Market Replay.mq5	Cria os controles para interação com o serviço de replay/simulador (É necessário o Mouse Study para interação)
Indicators\Mouse Study.mq5	Permite interação entre os controles gráficos e o usuário (Necessário tanto para operar o replay simulador, quanto no mercado real)
Services\Market Replay.mq5	Cria e mantém o serviço de replay e simulação de mercado (Arquivo principal de todo o sistema)
Code VS C++\Servidor.cpp	Cria e mantém um soquete servidor criado em C++ (Versão Mini Chat)
Code in Python\Server.py	Cria e mantém um soquete em python para comunicação entre o MetaTrader 5 e o Excel
Scripts\CheckSocket.mq5	Permite efetuar um teste de conexão com um soquete externo
Indicators\Mini Chat.mq5	Permite implementar um mini chat via indicador (Necessário uso de um servidor para funcionar)
Experts\Mini Chat.mq5	Permite implementar um mini chat via Expert Advisor (Necessário uso de um servidor para funcionar)