Simulação de mercado (Parte 11): Sockets (V)

Introdução

No artigo anterior Simulação de mercado (Parte 10): Sockets (IV), falei e expliquei sobre xlwings, e como ele pode nos ajudar a integrar o Python ao Excel. Muito bem, apesar de tudo aquilo pode parecer muito distante e sem grandes aplicações para nós aqui no replay / simulador. Mas antes que você venha a torcer o nariz para a integração entre o Python e o Excel. Vamos ver como podemos usar o xlwings, a fim de poder controlar de alguma forma o MetaTrader 5. Isto através do Excel. O que irei mostrar aqui será como foco principal a didática. Não ache que podemos fazer apenas o que mostrarei. Podemos fazer muito mais coisas. No entanto, será preciso que você estude como o xlwings consegue fazer com que o Excel funcione via Python. Somente assim você conseguirá ter um total controle do MetaTrader 5 via Excel, ou mesmo sem usar o Excel. Poderá controlar o MetaTrader 5, pelo Python.

Começando com o básico

Para começar, precisamos fazer algo bem, mas bem simples. Porém isto deverá realmente ser funcional. Aqui vou começar usando um exemplo, presente na documentação do xlwings. Só que explicarei de uma maneira um pouco diferente. Isto para que você entenda por que conseguimos executar Python dentro do Excel.

Vamos começar com algo bem fácil. Em qualquer editor, digite e salve o código em Python visto na imagem abaixo:

Note alguns detalhes, na imagem, como onde estou salvando o arquivo. Mas o principal detalhe é o nome do arquivo. Este nome será muito importante depois. Agora observe que este script em Python está fazendo referência a alguma coisa. NO caso estamos fazendo referência a uma planilha do Excel. Mas qual planilha? Calma. Um passo de cada vez. Antes de olharmos qual planilha, veja que na linha cinco, estaremos escrevendo um texto em uma célula especifica.

Mas para que este código funcione, é preciso que a planilha esteja aberta em uma sessão do Excel. Isto por conta da linha quatro. Ela é que faz a ligação a fim de saber em qual planilha escreveremos o texto. Então faça o seguinte: Abra o Excel, e adicione uma nova folha no mesmo, de modo que o Excel ficará como mostrado na imagem abaixo:

Agora atenção. Da forma como está, podemos selecionar uma folha ou outra no Excel. E por que estamos fazendo isto? O motivo é que vamos criar uma macro, que será ativada assim que a folha Sheet1 for ativada. Desta maneira, não precisamos adicionar coisas extras para chamar a macro. Então pressione ALT + F11 para abrir o VBA do Excel. E digite o seguinte código visto na imagem abaixo.

Observe que o código irá pertencer a Sheet1. Então assim que ela for ativada este pequeno script em VBA será executado. Agora observe a terceira linha no código. Para que esta linha seja corretamente interpretada pelo VBA, o xlwings deverá estar sendo referenciado. No artigo anterior expliquei como fazer isto. Uma vez que o xlwings está sendo referenciado, podemos então fazer com que o script em Python seja executado. Mas como?

Observe que estamos importando o arquivo que salvamos na primeira imagem deste tópico. Agora para que o VBA saiba onde está o arquivo, temos que passa o nome do mesmo, junto com o diretório a qual ele pertence. Mas como nossa planilha estará sendo salva no mesmo diretório, não precisamos dizer qual é o diretório.

Agora para que o VBA, ou melhor dizendo, o xlwings, saiba qual parte do script em Python será executado. Informamos isto depois do ponto vírgula. Agora, volte ao Excel e mude as folhas. Quando você fizer isto, o resultado será o que é visto na imagem imediatamente abaixo.

Legal. Você acabou de ver como o Python pode fazer as coisas no Excel. Isto de maneira a substituir grande parte do VBA. Digo grande parte, pois ainda assim você precisará fazer algumas coisas no VBA para que o Python, de fato faça o que foi programado no script.

Mas o que isto tem a ver com o MetaTrader 5? Calma, meu caro leitor. Calma, nós vamos chegar lá. Se você não tem conhecimento sobre Python, deve achar que o que acabamos de fazer é uma grande bobagem. Porém se você já estuda, ou programa em Python, deve ter ficado com os olhos brilhando. Já imaginando o que podemos fazer, ou quais são as possibilidades que este simples Hello World nos abriu.

Muito bem, se podemos escrever, também podemos ler. E é neste ponto que a coisa começa a ficar interessante. Lembra que eu disse, que apesar de podermos usar, um servidor RTD ou DDE, para transferir dados ao Excel. Isto na verdade seria uma perda de tempo. Já que a informação seria direcionada apenas para o Excel, e não poderíamos usar algum cálculo feito no Excel para controlar o MetaTrader 5?

Pois bem, já que podemos usar o Python a fim de escrever e ler dados diretamente no Excel. Podemos agora começar a pensar um pouco mais além. Isto nos permite de fato controlar um Expert Advisor via Excel. Precisando apenas criar uma forma de que o Excel se comunique com o MetaTrader 5. Mas se você não desejar usar o Excel, pode usar o Python da mesma forma.

Mas alguns operadores de fato não querem e não olham o gráfico. Eles fazem operações baseando apenas no preço. Ou melhor dizendo, eles se baseiam em fundamentos. E qual é a melhor forma de analisar fundamentos? Isto mesmo: Uma planilha em Excel. Mas não apenas o Excel, é preciso, outras coisas junto. Mas aqui vamos ficar no básico, já que a ideia é mostrar como fazer uma outra coisa que iremos de fato criar em um outro momento.

Planejando a conversa entre o Excel e o MetaTrader 5

Para começar a termos esta conversação entre o Excel e o MetaTrader 5, precisamos de alguma forma que seja eficaz, mas ao mesmo, tempo simples de implementar. Uma das melhores formas de fazer, isto é, via soquetes. O motivo é que um soquete permite que o Excel esteja em uma máquina e o MetaTrader 5 em outra. Mas também permite que ambos estejam no mesmo equipamento. A forma de fazer a seleção será controlada pelo operador. Ou seja, caso a pessoa queira deixar um equipamento dedicado ao MetaTrader 5, e outro dedicado ao Excel. O uso dos soquetes irá de fato permitir que isto ocorra. E mesmo que o operador deseje usar ambos programas em uma mesma máquina, isto será feito sem mudança alguma no protocolo de comunicação. Resumindo: Soquetes são mão na roda.

Muito bem, mas como faremos isto? Aqui é uma questão de decisão pessoal de cada um. Mas como estou mostrando o uso do Python no Excel, já sabendo que scripts em Python podem ser usados no MetaTrader 5. Isto nos abre muitas possibilidades. Mas a principal é criamos um servidor em Python e podemos usá-lo tanto no MetaTrader 5, quanto no Excel. Porém, antes de fazermos isto, vamos pensar um pouco. O Python nos permitirá ler e escrever diretamente valores na planilha. Mas como expliquei, o ideal será fazermos isto via soquetes. Assim precisamos que ou o MetaTrader 5 ou o Excel, venham a ter um cliente sendo executado. Neste momento, fica claro que se formos fazer com que o servidor execute no MetaTrader 5. Iremos precisar programar um cliente no Excel. No entanto, o MQL5 nos permite criar de forma muito simples um cliente, a fim de rodar diretamente em um Expert Advisor.

Agora acredito que você já pegou a ideia básica, do que devemos programar. Então, começar, novamente, com algo bem básico. Nada de coisas complicas e cheias de complicações. Sendo assim surge a ideia de experimentar criar um servidor de eco. Este irá apenas servir para que possamos testar a comunicação entre o Excel e o MetaTrader 5. Já que um servidor de eco é a coisa mais simples de programar, quando o assunto é soquete.

Implementando o servidor de eco

Como este é o código, de servidor, mais simples de todos. Quero que você não espere muito dele. A ideia é apenas testar como o Excel irá de fato trabalhar com um servidor que estará escrito em Python. Então vamos ver o que temos que fazer. Primeiramente vamos criar o código do servidor em Python, este pode ser visto abaixo:

01. import socket
02. import xlwings as xw
03. 
04. def Echo():
05.         wb = xw.Book.caller()
06.         server = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
07.         server.bind(("127.0.0.1", 27015))
08.         wb.sheets[0]['A1'].value = "Waiting connection..."
09.         server.listen(1)
10.         client, addr = server.accept()
11.         client.send("Wellcome to Server in Python\n\r".encode())
12.         wb.sheets[0]['A2'].value = str(f"Client connected by {addr}")
13.         while True:
14.             info = client.recv(512)
15.             if not info:
16.                 break
17.             client.send(b"Echo Server:" + info)
18.         wb.sheets[0]['A3'].value = "Client disconnected"
19.         client.close()

Script em Python

Mas é somente isto? Sim. Mas tem um detalhe. Este código está projetado para interagir com o Excel. Informando o que estará sendo feito no servidor. Se você já entende Python, este código não lhe faz se quer cócegas. Mas se você não tem noção do que está acontecendo. Vamos entender o que este script em Python está fazendo.

Na linha um e dois, dizemos ao Python, quais os módulos precisaremos. Já na linha quatro iniciamos a construção de um procedimento. Este será utilizado depois lá no VBA. Mas primeiro vamos entender esta parte em Python. Na linha cinco nos ligamos ao Excel, por assim dizer. Nas linhas oito, doze e dezoito colocamos o status de execução na planilha do Excel. Assim como foi feito no tópico anterior.

Todas as demais linhas fazem parte do servidor de eco. O grande detalhe aqui, é que este servidor, somente permite uma única conexão. Ou seja, uma vez que alguém se conecte a ele, ele irá travar neste cliente. Não aceitando nenhuma outra conexão. Quando este cliente fechar a conexão, o servidor irá se desligar. Talvez isto possa parecer muito pouco versátil. Mas lembre-se que estamos apenas testando as coisas.

Um outro detalhe, e este talvez seja ainda mais importante é o que se encontra na linha sete. Note que ali temos um valor sendo indicado. Este valor que está no estilo IPv4, nos diz que a única conexão que será aceita é a de um cliente que estiver no endereço indicado. No caso em questão se refere ao host local. Ou seja, tanto o cliente quanto o servidor deverão estar na mesma máquina. Seja ela física ou virtual, não importa. O que importa é que ambos estejam em uma mesma máquina.

Você pode modificar o valor indicado por um outro, de onde é esperado que o cliente venha a estar. Pode inclusive ser um site. Mas caso você não saiba, ou melhor dizendo, você queira que o cliente esteja em qualquer endereço, bastará colocar o valor "0.0.0.0". Neste caso o Python, ou melhor o soquete irá compreender que qualquer endereço é valido para que o cliente se conecte. Lembrando mais uma vez: Só é permitido um cliente por vez.

Legal, mas e se você vier a desejar um número muito maior de clientes. Como proceder? Neste caso será preciso adicionar as conexões a um thread, quase da mesma forma que fizemos no código em C++. Porém aqui no Python é ainda mais simples. No entanto, para nosso propósito, isto não será necessário. O fato deste servidor, aceitar uma conexão e fazer eco na mesma, já nos será o suficiente.

Agora que você tem o código do servidor em Python, podemos fazer a mesma coisa que foi feita no tópico anterior. Ou seja, usar a função RunPython para executar o servidor. Certo? Correto. Mas vamos fazer uma pequena adição ao código no VBA do tópico anterior. Assim, o código em VBA ficará conforme mostrado abaixo:

1. Private Sub Worksheet_Activate()
2.     MsgBox "Call Server..."
3.     RunPython "import Server_Echo; Server_Echo.Test()"
4. End Sub

Script em VBA

A simplicidade deste código chega a surpreender. Observe que na linha três, apenas trocamos indicamos os novos pontos. Tanto o nome do arquivo, quanto o nome do procedimento a ser chamado. O detalhe é a linha dois. Esta linha está ai, para que você veja quando o servidor tenta ser chamado novamente. Experimente trocar as folhas para ativar o servidor. Quando for feita uma tentativa de uma segunda criação, o Python disparará um aviso de erro. Mas não que exista um erro de fato. O que acontece é que este código não checa se o servidor está ou não ativo. Algo parecido ocorrerá quando dois clientes tentarem se conectar na mesma sessão. Vou deixar estes experimentos como lição de casa. Assim você compreenderá as limitações deste código didático e poderá providenciar as devidas correções.

Entregar o código já corrigido e completamente funcional, afim, de poder ser utilizado como um servidor de eco. Acredito ser algo sem sentido. Isto por que o melhor é que você, caro leitor, procure entender os problemas. Tente criar ou implementar uma solução. Desta forma, tanto o conhecimento quanto o conceito por detrás de um soquete, será melhor assimilado. Mas resolver tais falhas, não é nada complicado. Eu já até dei as dicas para que elas sejam sanadas. É tudo uma questão de procurar entender o que está acontecendo, e corrigir o problema.

Muito bem, esta parte está pronta, agora vamos ver o cliente em MQL5.

Implementando o cliente em MQL5, versão eco

Assim como foi a parte do servidor. Aqui também podemos implementar um código inteiramente em Python. Mas já vamos nos prepara para o que faremos depois. Então esqueçamos o Python por uns instantes, e nos foquemos no MQL5. O código da parte cliente, pode ser visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property service
03. #property copyright "Daniel Jose"
04. #property description "Echo Server Test Service."
05. #property description "Requires that the Python server is running in Excel."
06. #property version   "1.00"
07. //+------------------------------------------------------------------+
08. input string     user00 = "127.0.0.1";   //Address
09. input int        user01 = 27015;         //Port
10. //+------------------------------------------------------------------+
11. void OnStart()
12. {
13.     char buff[], resp[];
14.     int sock = SocketCreate(), ret;
15.     uint len;
16.     string szMsg;
17.     
18.     if (sock == INVALID_HANDLE)
19.     {
20.         Print("Unable to create socket. Error: ", GetLastError());
21.         return;
22.     }
23.     if (!SocketConnect(sock, user00, user01, 1000))
24.     {
25.         Print("Connection with the address [", user00, "] in port ", user01, " failed. Error code: ", GetLastError());
26.         SocketClose(sock);
27.         return;
28.     }
29.     while (!_StopFlag)
30.     {
31.         szMsg = TimeToString(TimeLocal(), TIME_DATE | TIME_SECONDS);
32.         len = StringToCharArray(szMsg, buff) - 1;
33.         Print("To Server: ", szMsg);
34.         if (SocketSend(sock, buff, len) != len)
35.         {
36.             Print("Error code: " , GetLastError());
37.             break;
38.         };
39.         szMsg = "";
40.         do
41.         {
42.             len = SocketIsReadable(sock);
43.             ret = SocketRead(sock, resp, len, 1000);
44.             if (ret > 0)
45.                 szMsg += CharArrayToString(resp, 0, ret);
46.         }while ((ret <= 0) && (!_StopFlag));
47.         Print("From Server: ", szMsg);
48.         Sleep(1000);
49.     }
50.     SocketSend(sock, buff, 0);
51.     SocketClose(sock);
52. }
53. //+------------------------------------------------------------------+

Serviço em MQL5

Antes de falarmos sobre este código, vamos ver um pequeno detalhe que você deverá ajustar para que tudo funcione. Sim, é preciso dizer ao MetaTrader 5, que você estará permitindo que um soquete seja aberto. Mas principalmente, é preciso que você diga o endereço alvo. Isto é feito conforme mostrado na imagem abaixo.

Feito isto, podemos agora ver como o código do cliente MQL5 funciona. A primeira coisa que talvez chame a sua atenção é a linha dois. E sim, podemos usar um serviço para implementar o soquete. O único tipo de aplicação que não poderá implementar o soquete é um indicador. Fora isto você terá total liberdade com as demais aplicações.

Agora, você muito provavelmente deve estar achando, este código bastante parecido com os vistos nos artigos anteriores. De fato, ele se parece bastante. Todo código voltado a trabalhar com soquetes, tem uma grande similaridade entre eles. Então tudo que foi visto antes continua valendo. A única real diferença aqui é a linha 50.

Agora você pode estar pensando. Mas por que esta linha existe? Para entender esta linha é preciso entender o código do servidor em Python. Lá você pode ver que quando na linha 15, o servidor recebe uma informação inválida, ou vazia, ele é fechado. É justamente isto que esta linha 50 executa. Apesar de tudo, isto não é a melhor maneira de fazer com que o servidor e o cliente, digam um para o outro que a conexão será encerrada. No entanto, para fins iniciais e de testes primários, podemos aceitar isto por hora. Assim enquanto o cliente estiver conectado ao servidor, você verá no MetaTrader 5 a seguinte imagem.

Note que estamos fazendo eco, da informação do relógio. Algo banal, porém ajuda a entender como o processo de comunicação está se dando. Se você observar o que estará sendo mostrado no Excel, verá a seguinte imagem.

Coisas a serem entendidas antes da próxima etapa

Ok. Este é o básico do básico. Porém, antes de passamos para a próxima etapa e assim ver como o código completo se encontra. Lembrando mais uma vez que o código terá como objetivo ser didático e não um código totalmente, e completamente finalizado. Gostaria de aproveitar este insider e explicar algumas coisas sobre o que temos até o momento.

Tais coisas para quem já tem experiência não serão nenhuma novidade. No entanto, acredito que você, caro leitor, ainda não tenha tanta experiência, ou prática com uso de soquetes. Para dizer a verdade, a minha real preocupação neste momento é que você, que muito provavelmente esteja iniciando seus estudos, imagine que as coisas são perfeitas. Bastando apenas você seguir alguma receita de bolo, que os soquetes funcionarão perfeitamente bem.

Mas a realidade não é tão bela assim. Se bem, que também não seja algo assim tão assustador. E nem deveria vir, a colocar medo em seu coração, lhe fazendo fugir quando o assunto é soquetes. Soquetes de fato é uma das ferramentas mais práticas e simples de ser utilizada para efetuar comunicação. Seja entre softwares, seja entre plataformas diferentes, entenda isto como sistemas operacionais. Ou seja, entre equipamentos diferentes. Como por exemplo você usar um Raspberry junto com um desktop pessoal. Enfim, os soquetes, torna o trabalho entre estas coisas, que podem ser tão diferentes, em algo muito transparente. Mas se você não tomar alguns cuidados terá sérios problemas, ou no mínimo dificuldades em compreender e resolver os entraves que irão com toda a certeza surgir.

Vamos pensar por um momento nesta nossa pequena implementação, que já se encontra funcionando. Onde temos um eco entre o Excel e o MetaTrader 5. Diferente do que foi feito, nos artigos anteriores, onde fazíamos uso de um único servidor, que seria executado na linha de comando. E que você dificilmente, pelo menos de forma consciente, tentaria colocar dois servidores sendo executados no mesmo ambiente. Ou seja, você teria um prompt com um servidor. Abriria na mesma sessão do sistema operacional um outro prompt e tentaria colocar o mesmo servidor sendo executado, neste novo prompt. Se você não tem ideia do que acontecerá neste caso, experimente fazer isto. Você notará que de alguma forma isto não será possível. Porém, aqui mora uma questão que muitos, mesmo pessoas com muita experiência. Pelo menos em tese, não compreender, sobre soquetes.

Se você pegar o servidor, do Mini Chat, e colocá-lo para ser executado, isto usando um prompt. Não conseguirá em hipótese alguma colocar o mesmo servidor de Mini Chat em um outro prompt de comando na mesma sessão do sistema operacional. Isto é fato.

Agora lembre-se, de que o servidor de mini chat estará fazendo uso da porta 27015. E o servidor de eco, que estará rodando no Excel, também faz uso da porta 27015. Então em tese teremos um conflito de interesses aqui. Você pode pensar que o sistema operacional impediria de um servidor interferir ou tentar ouvir a mesma porta, usando o mesmo protocolo. No caso estamos usando o protocolo TCP. Mas poderíamos estar usando em um servidor o TCP e no outro o UDP. Neste caso não faria diferença os dois estarem usando a mesma porta.

Porém, quando estamos usando, a mesma porta, com o mesmo protocolo e no mesmo host. As coisas começam a ficar um pouco mais complicadas.

Quero enfatizar isto, para que você, caro leitor, e aspirante a ser um intenso usuário de soquetes. De que existem cuidados a serem tomados quando queremos usar soquetes. Mas o principal, é que quero, que antes de você ver como será a implementação da comunicação entre o Excel e o MetaTrader 5. Compreenda o que acontece, quando dois servidores diferentes, fazem uso das mesmas coisas. No caso, o mesmo protocolo, a mesma porta e o mesmo host. Então para entender, abra primeiramente o servidor do mini chat e o deixe esperando que alguma conexão aconteça.

Agora abra o servidor de eco no Excel, e o deixe também esperando que uma conexão aconteça. Ou seja, você terá algo parecido com a imagem abaixo.

Agora vem a minha pergunta. E quero que você antes de testar, diga: Qual dos servidores aceitará a conexão com o cliente. Ou melhor dizendo, qual começará a ouvir e responder ao cliente? Lembrando, que ambos têm um código muito simples. Onde não existe nenhum tipo de teste a fim de autentificar se o cliente é ou não o adequado a que o servidor irá responder. Ou que tipo de requerimento o servidor esperará receber.

Não sei se você conseguiu de fato compreender o que estou tentando lhe explicar. O fato é que, apesar de ambos servidores serem distintos entre si. Ambos estão fazendo uso dos mesmos tipos de recursos. Ou seja, a mesma porta, o mesmo protocolo que no caso é o TCP e o mesmo equipamento, ou host. Este tipo de coisa é que torna o trabalho tão complicado, quando o assunto é soquetes. Pois se você tiver um servidor que deverá responder a determinadas questões, ou requerimentos. E sem perceber, venha a adicionar um outro, que fará uso dos mesmos recursos. Você poderá impedir que os clientes venham a receber corretamente o resultado de seus requerimentos.

Por isto é bom você, entender, que os códigos que estou mostrando aqui, NÃO SÃO códigos finalizados. Eles são apenas para uso pessoal e com intuito de serem didáticos. Um código real de um servidor real, é bem diferente no que rege as regras de uso.

Em muitos casos, muitos podem simplesmente dizer. É simples resolver está questão. Tudo que você precisa fazer é mudar ou o protocolo ou mesmo a porta. Isto resolveria a questão de conflito entre os servidores. É verdade. Mesmo uma solução tão simples, como o simples fato de você colocar um servidor em um equipamento e outro servidor em um outro equipamento. Também resolve o problema. Mesmo que ambos façam uso da mesma porta e do mesmo protocolo.

Mas a questão ainda permanece. Na imagem mostrada acima. Qual dos dois irá responder a solicitação do cliente, em se conectar? Para saber qual, é só você observar quem foi o último a ser colocado em funcionamento. Ou seja, se nenhum cliente ainda havia se conectado. Assim que o primeiro vier a tentar uma conexão. Irá de fato se conectar ao último servidor que foi colocado em execução. Assim que este servidor for desligado. O servidor imediatamente anterior, começará a ouvir os requerimentos de novos clientes.

Um detalhe: Se um cliente estiver conectado em um servidor e ele for desativado. A conexão cairá e o cliente não irá automaticamente se conectar ao outro servidor. Não é assim que as coisas acontecem. Será preciso que o cliente faça um novo requerimento de conexão. Somente assim ele poderá realmente se conectar ao servidor que estiver ouvindo aquela porta, com aquele protocolo. Isto se a porta, o protocolo e o host forem o mesmo do servidor que foi desativado.

Considerações finais

Apesar de não mostrar neste artigo, a real implementação, que permite a troca de mensagens entre o Excel e o MetaTrader 5. Foi preciso aproveitar este insider, para explicar algo que considero importante. Isto por que, não quero que você, caro leitor e com pouca ou nenhuma experiência em soquetes. Venha a imaginar que o uso de soquetes é a oitava maravilha do mundo. Ou que venha a se decepcionar, ao ver que o uso de soquetes, não está resolvendo o seu problema.

Soquetes são uma das ferramentas mais complicadas, e ao mesmo tempo simples, que existe. Isto se tratando do mundo da computação. Se você os entender, eles poderão lhe ajudar imensamente. Mas se você imaginar que eles são algo que simplesmente funciona. E que você pode os usar de qualquer maneira. Fazendo muitas vezes uso dos mesmos sem nenhum tipo de critério ou entendimento. Irá ter seria dores de cabeça ao usar tal ferramenta.

Quando esta sequência sobre o serviço de replay/simulador se iniciou. Foi cogitado fazer uso dos soquetes, a fim de criar todo o sistema de simulação ou replay. De certa forma isto seria consideravelmente mais simples, em termos gerais de ser construído. Dado o fato, de tudo que seria preciso fazer, seria enviar dos dados dos ticks diretamente para a porta que o MetaTrader 5 ouve do servidor de negociação real. Mas ao pensar com mais calma, e sem afobação. Esta ideia foi abandonada. Por que? Bem. O motivo, é que seria preciso fazer uso de técnicas que não quero explicar como de fato as utilizar. Mas quero que você pense um pouco a este respeito. No demais, nos vemos no próximo artigo. Onde de fato, vamos ver como o Excel pode enviar dados para o MetaTrader 5 e o MetaTrader 5 pode responder ao Excel.

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)