Simulação de mercado (Parte 16): Sockets (X)

Introdução

No artigo anterior Simulação de mercado (Parte 15): Sockets (IX), expliquei e mostrei a parte do código referente ao servidor a ser feito em Python. Porém apenas e somente aquele código, não é o suficiente para que possamos fazer uso de um sistema de comunicação entre o MetaTrader 5 e o Excel. Precisamos de mais coisas além do que foi visto naquele artigo. No entanto, muitos poderiam e não estariam errados, em implementar toda a solução diretamente naquele código em Python. O fato de fazer isto, apenas nos engessaria em um sistema inteiramente fechado. Ou melhor dizendo, não poderíamos nos adaptar em algumas questões a fim de poder fazer certas coisas, ou cobrir certos cenários mais ou menos específicos. Porém, dividindo o sistema em partes, podemos fazer as coisas de uma maneira um pouco mais solta. Assim poderemos fazer uso do que cada linguagem, ou programa nos fornece de melhor.

Muito provavelmente você pode estar achando, que isto é pura bobagem. Mas considere o fato de que aqui estou apenas explicando que sim, é possível trabalhar com o MetaTrader 5 de uma maneira completamente inexplorada até o momento. Da mesma forma que estou mostrando como usar o Excel, poderíamos usar qualquer outro programa em seu lugar. E mais do que isto. Poderíamos criar nosso próprio método, usando programas que criaríamos exclusivamente para isto, a fim de ter uma análise e modelo operacional especifico para um determinado tipo de operação. De forma que o MetaTrader 5, apenas faria a transferência dos pedidos entre o que nos criaríamos e o mercado. Dispensando todo o trabalho para conseguir, desenvolver uma plataforma de negociação.

Então considere tudo que está sendo explicado, como sendo algo muito, mais muito maior do que estou mostrando aqui. Fazer tais coisas, envolve muito conhecimento e estudo. Mas se você realmente desejar fazer com que algo assim venha a surgir. Considere estes artigos daqui, como uma pequena amostra do que podemos realmente fazer. Mas nada disto terá realmente sentido, sem que venhamos a ver o que falta ser implementado a fim de que o servidor em Python, seja realmente útil. Então neste artigo, vamos ver a parte referente ao que deverá ser implementado em VBA que está incluso no Excel.

Primeiros passos no Excel

O código que deverá ser implementado em VBA, não é nem de longe algo complicado. Na verdade, muito do que será mostrado, já faz parte do que muitos que criam scripts em VBA, já fazem. Mas existe, um ou outro detalhe que pode ser mais ou menos complicado isto para alguns. Porém quero enfatizar que aqui, as coisas foram feitas para serem o mais simples e didático possível. Porém, o código que foi visto no artigo anterior, não sofrerá nenhuma nova mudança. Tudo que você precisa de fato fazer, é criar as coisas aqui em VBA, de forma a suprir as necessidades ou mudanças pertinentes ao que se espera fazer ou obter.

Vamos começar vendo a nossa interface no Excel. Esta pode ser vista na imagem abaixo:

Se você, sabe fazer as coisas no Excel, deve ter notado que os botões vistos na imagem acima, são shapes. Estes permitem que você crie uma interface com cantos arredondados. Mas o seu funcionamento, não difere muito de controles normais. Sendo possível que você os vincule a alguma macro. Assim quando você clica em um destes shapes, o Excel interpretará isto como se você estivesse interagindo com um botão convencional. E irá fazer a chamada a fim de executar a macro que esteja vinculada ao evento de clique no shape, ou botão.

Mas a questão aqui, que realmente nos interessa. Isto olhando apenas para a interface, vista na imagem, é o conteúdo das células. Observe que na célula B2 temos uma informação. Esta diz que o servidor está offline. Assim como na célula B5 temos outra informação. Está no caso indica qual é o nome do ativo, no qual queremos alguma informação do MetaTrader 5. É neste ponto que a coisa começa a tomar corpo. Apesar de que irá ficar faltando a parte referente ao que será programado em MQL5. Já podemos começar a ter uma ideia do que precisamos e podemos fazer.

Lembra que na explicação do código do servidor, eu informei que o servidor capturará a informação de uma célula e enviar para o MetaTrader 5, a fim de conseguir alguma informação? Pois bem, é justamente nesta célula onde temos o valor WDON23 que deveremos atuar. Porém quando formos modificar a informação aqui de maneira manual. Devemos primeiro parar o servidor, modificar esta informação da célula B5, e logo depois inicializar novamente o servidor. Assim o MetaTrader 5, receberá os novos parâmetros a serem analisados.

Tais mudanças, é algo bastante simples de ser feito. Podendo ser feito a qualquer momento, sem que o servidor realmente venha a ter ciência do que esteja acontecendo. Pois tudo irá se passar entre o MetaTrader 5 e o Excel. Mas conforme já informei, e torno a repetir, a ideia aqui é ser didático. Porém, nada impede de você criar um protocolo próprio a fim de conseguir mais informações ou acessar mais dados de outros ativos. Tudo que você precisa fazer é colocar os dados nesta célula especifica do Excel. Mas você pode estar se perguntando: Por que esta célula especificamente? Por que não usar outra. O detalhe é que no código do servidor temos o uso de um índex. E com base neste índex, a célula a ser usada é justamente está B5. Porém, no decorrer deste artigo irei mostrar como você pode usar outra célula. E isto sem precisar mexer no código do servidor, visto no artigo anterior.

Acreditando que você tenha entendido esta parte inicial, podemos passar para a próxima etapa. Então vamos ver como a coisa será feita no VBA.

Iniciando o código em VBA

Para que possamos, realmente ter algo útil sendo feito, e de forma que o usuário, não venha perceber o que está acontecendo por debaixo dos panos. Precisamos fazer algumas coisas, e isto deverá ser feito em VBA. Então a primeira coisa que precisamos fazer será criar um módulo. Este tem como objetivo, comportar todo o código que precisará ser feito, e que não se encaixaria em outro ponto. Assim sendo a primeira coisa a ser codificada pode ser visto logo abaixo:

01. Private Const szMSG_START_SERVER As String = "Start Server"
02. Private Const szMSG_STOP_SERVER As String = "Stop Server"
03. Private Const szSERVER_SHUTDOWN As String = """/Force Server ShutDown"""
04. Private Const szMSG_MT5_OFFLINE As String = "MetaTrader 5 is offline."
05. Private Const szMSG_MT5_ONLINE As String = "MetaTrader 5 is online."
06. Private Const szMSG_MT5_BUY As String = """Buy in Market >"""
07. Private Const szMSG_MT5_SELL As String = """Sell in Market >"""
08. Private Const iPort As Integer = 9090
09. Private gl_ServerInExec As Boolean
10. Public Const CELL_MT5 As String = "$B$4"
11. 
12. Public Sub SwapStatusMT5()
13.     Dim c1, c2, c3 As Long
14.     
15.     If Sheets("System").Range(CELL_MT5).Value = szMSG_MT5_ONLINE Then
16.         c1 = RGB(217, 238, 16)
17.         c2 = RGB(51, 153, 102)
18.         c3 = RGB(255, 80, 80)
19.     Else
20.         c1 = RGB(132, 130, 122)
21.         c2 = c1
22.         c3 = c1
23.     End If
24.     With Sheets("System")
25.         .Shapes("Btn_MT5").Fill.ForeColor.RGB = c1
26.         .Shapes("Btn_BUY").Fill.ForeColor.RGB = c2
27.         .Shapes("Btn_SELL").Fill.ForeColor.RGB = c3
28.     End With
29. End Sub
30. 
31. Private Sub SwapMsgBtnServer(text As String)
32.     Dim c As Long
33.     If text = szMSG_START_SERVER Then
34.         c = RGB(213, 87, 99)
35.         gl_ServerInExec = False
36.     Else
37.         c = RGB(84, 130, 53)
38.         gl_ServerInExec = True
39.         SwapStatusMT5
40.     End If
41.     With Sheets("System").Shapes("Btn_Server")
42.         .TextFrame2.TextRange.text = text
43.         .Fill.ForeColor.RGB = c
44.     End With
45. End Sub
46. 
47. Public Sub BtnServer_Click()
48.     If gl_ServerInExec Then
49.         StopServer
50.     Else
51.         InitServer
52.     End If
53. End Sub
54. 
55. Public Sub InitServer()
56.     Dim szScript, szCmd As String
57.     
58.     szScript = Chr$(34) & Application.ActiveWorkbook.Path & "\Server.py" & Chr$(34)
59.     szCmd = " ""127.0.0.1""" & Str(iPort) & " ""System"" ""B$2"""
60.     VBA.CreateObject("WScript.shell").Run """Python""" & szScript & szCmd, vbHide
61.     SwapMsgBtnServer szMSG_STOP_SERVER
62. End Sub
63. 
64. Public Sub StopServer()
65.     szPath = Chr$(34) + Application.ActiveWorkbook.Path + "\MsgFromExcel.py" + Chr$(34)
66.     VBA.CreateObject("WScript.shell").Run """Python""" & szPath & " " & Str(iPort) & " " & szSERVER_SHUTDOWN, vbHide, True
67.     SwapMsgBtnServer szMSG_START_SERVER
68. End Sub
69. 
70. Public Sub MT5_BuyInMarket()
71.     szPath = Chr$(34) + Application.ActiveWorkbook.Path + "\MsgFromExcel.py" + Chr$(34)
72.     VBA.CreateObject("WScript.shell").Run """Python""" & szPath & " " & Str(iPort) & " " & szMSG_MT5_BUY, vbHide, True
73. End Sub
74. 
75. Public Sub MT5_SellInMarket()
76.     szPath = Chr$(34) + Application.ActiveWorkbook.Path + "\MsgFromExcel.py" + Chr$(34)
77.     VBA.CreateObject("WScript.shell").Run """Python""" & szPath & " " & Str(iPort) & " " & szMSG_MT5_SELL, vbHide, True
78. End Sub

Código fonte em VBA

Este módulo contém absolutamente tudo que precisaremos depois. Observe que temos diversas constantes e alguns procedimentos sendo declarados aqui. As constantes servem para nos ajudar a ajustar mais de forma mais rápida o código. Já os procedimentos tem cada um o seu próprio motivo de existir. Sendo que cada um deles de fato tem a sua importância no código geral. Então atenção aos detalhes que irei explicar, para entender como modificar adequadamente este modulo em VBA.

Para começar, vamos para a linha 55. Isto mesmo não vamos seguir a coisa da forma convencional. Vamos ver as funções e procedimentos conforme a sua importância para que o Excel consiga controlar o servidor em Python. Nesta linha 55, temos o procedimento que inicializará o servidor. Preste bastante atenção ao seguinte fato. O script em Python, deverá estar na mesma pasta ou diretório do arquivo Excel. Isto por que na linha 58, estamos capturando, via VBA, qual é o diretório onde o arquivo de Excel se encontra. Assim montamos o caminho com o nome do script em Python.

Ok, agora na linha 59 declaramos os parâmetros a serem passados para o script. Para entender esta linha 59, volte ao artigo anterior, para saber a ordem correta dos parâmetros a serem recebidos pelo script. Já na linha 60 é onde parte da mágica acontece. Isto por que, esta linha irá chamar e começar a executar o script em Python. Mas, a agora que mora a grande questão. Esta linha não irá esperar que o código retorne, ou seja, o VBA irá chamar o script do servidor e o tornará algo como se fosse uma thread. Observe que isto não é uma afirmação. Mas sim uma observação, se você olhar no gerenciador de tarefas, irá notar que o script em Python estará no mesmo bloco da aplicação do Excel. Isto pode ser visto na imagem abaixo.

Este tipo de coisa indica que, ao finalizar o Excel, o script em Python também será encerrado junto. Caso a imagem no gerenciador de tarefas indicasse que o script estaria fora do bloco da aplicação do Excel. Ao encerrar o Excel, o script iria permanecer executando, precisando ser fechado manualmente. No final do procedimento, isto na linha 61, chamamos o procedimento da linha 31. Neste procedimento fazemos as mudanças no shape que representa o botão que inicializa e finaliza o servidor. Como tal procedimento é bastante simples, e está diretamente ligado ao shape não existe muita coisa a se comentar a respeito dele.

Porém você deve notar o seguinte: Tanto este procedimento da linha 31 quando o da linha 55 não estão de fato ligados ao shape que inicializa ou finaliza o servidor. Tal tarefa é de fato feita por outro procedimento. Este se encontra na linha 47. Então o shape que representa o botão de start e stop do servidor, de fato estará executando este procedimento BtnServer_Click. Assim temos o controle simples e eficaz do que será apresentado no Excel. Entretanto, explicar esta parte foi apenas o começo, ainda existem outros quatro procedimentos ainda para serem entendidos apenas neste módulo.

Assim, vamos continuar entendendo o que está ligado ao shape do botão de controle do servidor. Note que na rotina BtnServer_Click, temos além da chamada para iniciar o servidor, a chamada para finalizar ele. Esta se encontra na linha 49, e faz referência a linha 64. Neste procedimento StopServer, estamos fazendo as coisas de uma maneira um pouco diferente. E por que estou dizendo isto? O motivo, é que se você estudar a interação entre o Excel e o Python, irá ver que existem formas de você ler, executar, ou escrever, usando Python, procedimentos ou variáveis declaradas no VBA. Então poderíamos simplesmente escrever em uma variável aqui no VBA, dizendo que o servidor deveria ser finalizado. Então quando o script em Python, viesse a acessar esta variável, ele saberia que o servidor deverá ser finalizado.

Porém, da mesma forma que podemos colocar o servidor no mesmo host do Excel, também podemos fazer isto colocando eles em máquinas distintas. E a comunicação iria se dar via soquetes. Por conta disto é que estamos usando um procedimento levemente diferente. Assim na linha 65, dizemos onde está o script em Python que enviará uma mensagem ao servidor. Tal mensagem é na verdade, um comando. Na linha 66, temos a informação do comando a ser passado ao servidor. No momento não se preocupe com este script em Python, depois iremos ver ele, mas para o final deste mesmo artigo.

O próximo procedimento que temos em mãos, é visto na linha 70. Este tem como objetivo enviar um pedido para o MetaTrader 5. Assim como o procedimento da linha 75. Ambos procedimentos deverão ser ligados aos seus devidos shapes, ou botões. Isto para que o usuário possa interagir diretamente com eles usado o Excel. Mas se você observar, tanto o procedimento StopServer, quanto os procedimentos MT5_BuyInMarket e MT5_SellInMarket fazem uso do mesmo script em Python. No entanto, diferente do StopServer, que já é um procedimento totalmente funcional. Os procedimentos MT5_BuyInMarket e MT5_SellInMarket, não estão de fato concluídos. O motivo é que tais procedimentos tem como objetivo serem apenas didáticos. Ou seja, eles não fazem absolutamente nada. Apenas imprimirão uma mensagem no terminal do MetaTrader 5. Mas isto será visto no próximo artigo.

Para que estes dois procedimentos sejam realmente funcionais. Você, terá que implementar um protocolo de comunicação. A fim de dizer ao MetaTrader 5, qual é o ativo e definir coisas como Stop Loss e Take Profit da posição. Acredito que para grande parte dos entusiastas isto será uma tarefa bastante agradável e até mesmo desafiadora. Mas não é algo complicado de ser feito. Apenas precisará que você diga ao VBA como montar uma mensagem que poderá ser entendida pelo MetaTrader 5. Isto para que as operações possam ser feitas diretamente pelo MetaTrader 5. Mas no próximo artigo irei explicar isto melhor. Por hora, não se preocupe com estes detalhes.

E para finalizar este módulo, temos um outro procedimento. Este é visto na linha 12. O objetivo deste procedimento é garantir que os shapes ou botões de interação e controle presentes no Excel, venham a corresponder ao atual status do MetaTrader 5. Ou melhor dizendo, quando o MetaTrader 5 estiver offline, os shapes de interação ficarão em cinza. Quando o MetaTrader 5 estiver online eles ficarão coloridos. Isto facilitará muito para o usuário final, saber quando pode ou não enviar comandos ao MetaTrader 5.

Muito bem, agora terminamos a parte referente ao módulo em VBA. Mas isto não indica que terminamos de programar o básico aqui no Excel. Precisamos fazer algumas outras coisas a fim de melhorar o suporte e a interação. Assim sendo, a próxima coisa a ser feita, é vista na imagem abaixo:

E para não ficar com dúvidas sobre o código a ser usado. Logo abaixo você tem acesso ao mesmo código visto na imagem.

1. Private Sub Worksheet_Change(ByVal Target As Range)
2.     If Target.Address = CELL_MT5 Then
3.         SwapStatusMT5
4.     End If
5. End Sub

Código fonte em VBA

Mas o que este código está fazendo? Bem, se você desconhece completamente programação em VBA, mas principalmente não cria códigos para Excel. Pode estar meio confuso. Mas este código simplesmente ajusta o status dos shapes, ou botões de envio de comandos ao MetaTrader 5. Para fazer isto, ficamos verificando o que está sendo colocado em uma determinada célula, pelo servidor. Quando o valor nesta célula muda, por qualquer motivo, a linha três será chamada. Isto fará com que automaticamente as cores dos shapes, ou botões mude de acordo com o status do MetaTrader 5, junto ao servidor.

Desta forma, você, ou o usuário final, não precisará ficar lendo o conteúdo de uma célula especifica. Bastará olhar a cor nos shapes ou botões para saber se o MetaTrader 5, está online ou offline. Um detalhe, importante, isto para quem não sabe como fazer as coisas no Excel. Observe na imagem acima, em qual folha, ou sheet em que o código deverá ser colocado. Isto para que ele realmente cumpra a sua tarefa. Se você colocar este mesmo código na folha errada, não terá o resultado esperado. Então fique atento a este detalhe.

Da mesma forma como foi feito neste ponto, temos outra coisa também a ser feita. E assim como também foi preciso observar onde colocar o código, aqui também o código deverá ficar em um local específico. Assim sendo, o próximo código deverá ser colocado conforme mostrado na imagem abaixo:

E se você ficar na dúvida sobre o que deverá ser colocado ali, veja abaixo o mesmo código visto na imagem acima.

1. Private Sub Workbook_BeforeClose(Cancel As Boolean)
2.     ThisWorkbook.Save
3.     StopServer
4. End Sub
5. 
6. Private Sub Workbook_Open()
7.     InitServer
8. End Sub

Código fonte em VBA

Este talvez é ainda mais simples do que o anterior. Visto que aqui temos dois tratadores de eventos bastantes simples. O primeiro que é Workbook_BeforeClose, será chamado assim que o usuário pedir para finalizar a planilha no Excel. Quando isto ocorrer, teremos duas coisas sendo feitas. A primeira, é vista na linha dois, que diz ao Excel para salvar a planilha. Então mesmo que ela tenha sido modificada, não espere que o Excel lhe peça confirmação para salvar a mesma. Isto por que ela será salva automaticamente, no encerramento do programa. A segunda coisa é a linha três, nela chamamos o procedimento visto lá no módulo. Este tem como objetivo finalizar o servidor.

Muito bem, já na linha seis, temos algo ainda mais simples ainda. Nesta linha onde temos o tratador de eventos Workbook_Open, simplesmente fazemos na linha sete a chamada ao procedimento, visto no módulo, que inicializa o servidor. Esta chamada Workbook_Open, será feita, assim que a planilha for aberta no Excel. Então quando você, ou o usuário final, pedir para abrir a planilha, ela automaticamente irá inicializar o servidor, esperando assim começar a receber dados do MetaTrader 5.

Tudo isto funciona perfeitamente bem. Você pode criar o servidor em Python. Com exatamente o mesmo código que foi visto no artigo anterior. Criar uma planilha simples qualquer, colocar alguns botões ou shapes para interação. Tomando é claro o cuidado de colocar o mesmo nome nos shapes que serão usados no código em VBA e colocar o sistema para testes. Você verá que poderá inicializar o servidor sem problemas. Mas ainda falta uma coisa que é justamente o código de interação do Excel com o servidor em Python.

Se você prestou atenção a toda a explicação, deve ter visto que precisamos de um outro código em Python. Este deverá ter o nome de MsgFromExcel.py. Então para que possamos finalizar esta parte aqui no Excel e no VBA, temos que ver este último script. Antes que você, caro leitor, comece a ficar desesperado e tendo um sentimento de que não está entendendo nada de nada. Vamos parar e pensar um pouco.

Quando o Excel é inicializado, ele irá chamar a rotina Workbook_Open. Ao fazer isto, ele chamará o procedimento InitServer, que está presente no módulo em VBA. Este procedimento irá procurar na mesma pasta, ou diretório onde a planilha se encontra, por um arquivo chamado Server.py. Este é o script em Python do servidor, e pode ser visto no artigo anterior. Uma vez que esta parte tenha sido completada, o Excel passará a responder aos comandos e interações com o usuário. Isto da forma como você já deve estar acostumado.

Se ao tentar fazer com que o sistema comece a funcionar, você não tenha a inicialização do servidor. Volte, e refaça os passos que acabei de explicar. Isto por que o servidor deverá ser inicializado automaticamente. Se isto não ocorrer, procure a falha no seu código. Isto antes de passar para a próxima etapa.

A próxima etapa acontece quando vamos finalizar o servidor. Isto é quando pedimos para a aplicação do Excel ser encerrada ou quando fazemos uma interação que fará a chamada ao procedimento StopServer. Muito bem, quando qualquer uma destas coisas acontece. Teremos a execução da linha 65 do módulo. E até o momento, você ainda não viu o código que é executado neste ponto. Então para sanar esta curiosidade e separar as coisas, vamos ver isto em um outro tópico.

Um cliente para o Excel

Sim, é isto mesmo que você acabou de ler como nome do novo tópico. O tal script MsgFromExcel.py é na verdade, um cliente. Este irá se comunicar com o servidor que também foi aberto e permanecerá aberto na seção do Excel. Para facilitar entender as coisas. Veja o código deste arquivo MsgFromExcel.py logo abaixo:

01. import socket as sock
02. import sys
03. 
04. if sys.argv[2]:
05.     conn = sock.socket(sock.AF_INET, sock.SOCK_STREAM)
06.     try:
07.         msg = '<mt5 with excel>:' + sys.argv[2]
08.         conn.connect(('localhost', int(sys.argv[1])))
09.         conn.send(msg.encode())
10.         conn.close()
11.     except:
12.         sys.exit(1)

Código fonte em Python

Ao ver este código, você que tem alguma experiência em Python, já deve ter notado uma coisa. E muito provavelmente esteja pensando o seguinte: Mas isto é um cliente que abre envia algo e logo depois fecha a conexão. Qual o sentido disto? De fato, este código acima é um cliente TCP feito em Python. E ele de fato, faz justamente isto. Ele abre, envia algo para o servidor e logo depois encerra a conexão. Ficando pronto para ser chamado novamente.

O motivo de fazer isto, e desta forma, se deve ao fato de que, este cliente, não precisa ficar o tempo todo ligado ao servidor. Diferente do cliente em MQL5, que rodará no MetaTrader 5. Este daqui, tem como finalidade apenas enviar algum tipo de comando para o servidor. Seja para que o servidor execute algo, seja para que o servidor envie algo. Por isto, você pode ver este mesmo código sendo chamado tanto pelo procedimento StopServer, quanto pelos MT5_BuyInMarket e MT5_SellInMarket. A ideia é que ele apenas faça algo que não poderíamos fazer se o servidor e o Excel estivessem em máquinas distintas.

Por isto recebemos dois parâmetros neste script. O primeiro parâmetro indica qual é a porta a ser usada. Já o segundo parâmetro, deverá ser o comando ou mensagem que o servidor executará ou repassar ao MetaTrader 5. Uma vez que isto foi feito, podemos fechar a conexão que este cliente acabou de abrir.

Neste ponto, da explicação, gostaria de dizer algumas coisas, que podem vir a ser importantes e até mesmo dúvida por parte de alguns. Se você está começando a programar, seja em Python, seja em VBA e achou interessante o que está sendo mostrado. Quero que saiba, que isto daqui é apenas uma forma que encontrei para ser didático. Muito do que foi feito aqui, pode ser melhorado e muito. Mesmo por que, não fiz ou coloquei muitos testes no código. Mas a parte que quero ressaltar, é o fato de que este, e especificamente este cliente que é feito em Python, poderia ser muito, mas muito facilmente colocado como sendo um código em VBA.

Assim o único modulo que realmente estaria em Python, seria o que cria o servidor. Porém, como o código em Python, é consideravelmente mais simples e fácil de entender do que uma implementação do mesmo cliente em VBA. Isto falando exclusivamente no caso do cliente. Por conta disto, preferi colocar o código em Python mesmo. Mas se você desejar tentar fazer a mesma coisa, só que usando o VBA, esteja preparado. Pois o passo a passo a ser seguido a fim de fazer a mesma coisa que é feita aqui, só que usando o Python é consideravelmente muito mais complicado.

Considerações finais

Apesar de neste artigo, não temos ainda finalizado completamente e explicação de como promover a comunicação entre o Excel e o MetaTrader 5. Estamos a um passo de concluir este desafio. Porém, quero que você, caro leitor, procure entender primeiro estes dois artigos. Tanto este como o anterior. Isto para que consiga de fato entender o próximo onde abordarei exclusivamente a parte referente a programação em MQL5. Apesar de que ali a coisa será igualmente voltada a ser fácil de entender. Se você não compreender estes dois últimos artigos. Com toda a certeza terá grandes problemas em entender o próximo. O motivo disto é simples: As coisas vão se acumulando. Quando mais coisas é preciso fazer, mais coisas é preciso criar e entender para poder atingir o objetivo.

Espero que você antes de tentar ler e implementar o que será visto no próximo artigo. Procure entender e praticar o que foi visto até aqui. Na dúvida procure estudar os artigos anteriores. Pois como falei no começo, este assunto sobre soquetes é algo bastante denso e com muitos detalhes. Alguns destes detalhes são mais simples e outros bem complicados. Porém entender este assunto é de suma importância para algumas outras coisas que poderão vir a surgir no futuro.

E apesar de você achar que este assunto sobre soquetes, não faz parte do sistema de replay/simulador. Quero que repense tal ideia. Pois se você em algum momento realmente desejar criar um replay/simulador, que independerá de alguma coisa rodando dentro do MetaTrader 5. Como tem sido feito até o momento. Precisará de fato entender como os soquetes funcionam. Assim poderá simular as coisas não da forma como mostrei. Mas poderá simular o servidor de negociação. E apenas dizer ao MetaTrader 5, para que se conecte a este servidor que você estará simulando.

Mas como o propósito aqui é outro. Falaremos deste tipo de coisa em um outro momento. Então até o próximo artigo.

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)