Simulação de mercado (Parte 15): Sockets (IX)

Introdução

No artigo anterior Simulação de mercado (Parte 14): Sockets (VIII), expliquei como você, que deseja fazer uso do Python em seus programas poderia fazer algumas coisas, sem depender de pacotes ou coisas de terceiros. Longe de mim, dizer para você não usar pacotes que lhe ajude a fazer as coisas em Python. Mas o intuito de tais demonstrações é justamente lhe motivar a estudar as coisas com mais interesse. Não faz sentido você ficar dependendo de pacotes ou soluções terceirizadas, quando na verdade pode você mesmo fazer as coisas com base no que a sua linguagem favorita lhe permite.

Pois bem, acredito que naquele artigo, devo ter aguçado a sua curiosidade para algumas questões, que muitos não fazem ideia de como funcionam. Acredito que grande parte, se fez algum tipo de cursinho ou estudo baseado no que grande parte das pessoas mostram, jamais ouviram falar em algumas tecnologias. Um exemplo disto é a tecnologia COM. Que apresentei brevemente e de forma bastante superficial no artigo anterior. Mas ter o conhecimento de como fazer as coisas, usando tais métodos, irá lhe ajudar muito. E isto em todas as fases da programação.

Então neste artigo daqui, começarei a explicar uma das soluções possíveis para o que venho tentando mostrar. Ou seja, como permitir que um usuário no Excel, consiga fazer algo no MetaTrader 5. Isto sem que ele de fato, envie ordens, abra ou feche uma posição usando o MetaTrader 5. A ideia, é que o usuário faça uso do Excel a fim de ter um estudo fundamentalista de algum ativo. E fazendo uso, apenas e somente do Excel, ele consiga dizer a um Expert Advisor, que esteja executando no MetaTrader 5, que é para abrir ou fechar uma dada posição.

Até o momento, tudo que foi mostrado e demonstrado, tem como intuito, apenas transferir dados como se estivéssemos fazendo uso de um chat. Mas ao fazer uso de tais métodos, acredito que tenha sido mais simples que você, caro leitor, que não tenha tanta experiência em soquetes, tenha compreendido os conceitos básicos. Lembrando que estou apenas raspando a superfície de um grande iceberg, cujo nome é soquetes. Aconselho a você estudar bem mais a fundo, esta tecnologia. Pois se você entender como ela de fato funciona, ficará encantado e provavelmente muito mais entusiasmado com as possibilidades que se abrirão.

Mas vamos ao que realmente nos interessa aqui neste artigo. Como as coisas que realmente precisam ser feitas, são em sua maioria, coisas relativamente complicadas, e outra bastante simples. Explicarei tudo com bastante calma. Desta maneira, mesmo que não venha a mostrar tudo neste artigo, você de fato entenderá como a coisa funciona. E se este objetivo for alcançado, você conseguirá modificar e adaptar o que mostrarei a fim de ter sua própria solução. Que muito provavelmente, poderá vir a superar de longe o que mostrarei. Já que o objetivo aqui é ser o mais didático quanto for possível. Então vamos começar.

Criação do servidor em Python

Como ficou evidente e provado, nos artigos anteriores. Não podemos de fato criar e rodar um servidor diretamente no Excel. Até que podemos, porém, para fazer isto teríamos que executar um verdadeiro malabarismo, a fim de evitar que o servidor comprometesse a experiência de uso do Excel. Uma das formas de fazer isto é construindo o servidor em uma thread. Mas construir e executar um servidor em uma thread, no Excel é uma tarefa bastante complicada. Talvez não tanto quanto outras. Mas com certeza, bem mais complicada do que a proposta e que será feita aqui.

Então a primeira coisa a ser feita é construir um servidor isolado no Python. Este servidor irá de fato acessar a planilha no Excel. Mas existem alguns detalhes a serem observado. Novamente, aqui a ideia é ser didático. O que apresentarei, pode ser melhorado imensamente. Então logo abaixo, podemos ver o código primário do servidor em Python. Digo primário, pois este código pode ser melhorado e aperfeiçoado conforme as suas necessidades pessoais. Sendo necessário apenas que você o ajuste as coisas nos pontos certos. Mas antes de fazer isto. Que tal você entender como ele funciona primeiro. Assim fará bem mais sentido as mudanças que você poderá e precisará fazer.

001. import socket as sock
002. import select
003. import sys
004. from win32com import client as win32
005. 
006. class LinkMT5Excel:
007.     def __init__(self, host, port, sheet, cell) -> None:
008.         try:
009.             self.__CMD = ''
010.             self.__MT5 = None
011.             self.__server = sock.socket(sock.AF_INET, sock.SOCK_STREAM)
012.             self.__server.setblocking(False)
013.             self.__server.bind((host, int(port)))
014.             self.__server.listen()
015.             self.__CONN_LIST = [self.__server]
016.             EXCEL = win32.GetActiveObject('Excel.Application')
017.             self.__SHEET = EXCEL.Worksheets(sheet)
018.             self.__COLUNN, L = cell.split('$')
019.             self.__LINE = int(L)
020.         except:
021.             self.__CONN_LIST.clear()
022. 
023.     def __WriteInExcel(self, index, msg) -> None:
024.         try:
025.             if self.__SHEET:
026.                 self.__SHEET.Range(self.__COLUNN + str(self.__LINE + index)).Value = msg
027.         except:
028.             self.__SHEET = None
029.             self.__ShutdownServer()
030. 
031.     def __ReadInExcel(self, index) -> str:
032.         try:
033.             if self.__SHEET:
034.                 return self.__SHEET.Range(self.__COLUNN + str(self.__LINE + index)).Value
035.         except:
036.             self.__SHEET = None
037.             self.__ShutdownServer()    
038.         return ''
039. 
040.     def __MT5_Disconnect(self, conn) -> None:
041.         if conn == self.__MT5:
042.             self.__WriteInExcel(2, 'MetaTrader 5 is offline.')
043.             self.__MT5 = None
044.         if conn:
045.             conn.close()
046.             if self.__CONN_LIST:
047.                 self.__CONN_LIST.remove(conn)
048. 
049.     def __ShutdownServer(self) -> None:
050.         for conn in self.__CONN_LIST:
051.             conn.close()
052.         self.__CONN_LIST.clear()
053. 
054.     def __Command(self, cmd, conn) -> bool:
055.         if cmd.lower() == '/force server shutdown':
056.             self.__ShutdownServer()
057.             return True
058.         elif cmd.lower() == '/shutdown':
059.             self.__MT5_Disconnect(conn)
060.             return True
061.         self.__CMD = '' if cmd.lower() == 'n/d' else cmd
062.         return False
063.     
064.     def __Refused(self, conn) -> bool:
065.         conn.send('Connection Refused...\n\r'.encode())
066.         conn.close()
067.         return False
068. 
069.     def __Checking(self, conn) -> bool:
070.         try:
071.             info, cmd = conn.recv(512).decode().rstrip(None).split(':')
072.             if info.lower() != '<mt5 with excel>':
073.                 return self.__Refused(conn)
074.             if self.__Command(cmd, conn):
075.                 return True
076.             if (self.__MT5) or (cmd.lower() != 'mt5'):
077.                 return self.__Refused(conn)
078.             self.__MT5 = conn
079.             self.__WriteInExcel(2, 'MetaTrader 5 is online.')
080.         except:
081.             return self.__Refused(conn)
082.         return True
083.     
084.     def __SwapMsg(self, rec, conn) -> None:
085.         try:
086.             if rec:
087.                 data = conn.recv(1024).decode().rstrip(None)
088.                 if data:
089.                     if '/' in data:
090.                         if self.__Command(data, conn):
091.                             return
092.                     else:
093.                         self.__WriteInExcel(4, data)
094.                 else:
095.                     self.__MT5_Disconnect(conn)
096.                     return
097.             conn.send((self.__ReadInExcel(3) + f'[{self.__CMD}]').encode())
098.         except:
099.             self.__MT5_Disconnect(conn)
100. 
101.     def Run(self) -> None:
102.         self.__WriteInExcel(0, 'Server online.')
103.         self.__MT5_Disconnect(None)
104.         while self.__CONN_LIST:
105.             read, write, err = select.select(self.__CONN_LIST, [], [], 0.5)
106.             for slave in read:
107.                 if slave is self.__server:
108.                     conn, addr = slave.accept()
109.                     conn.setblocking(False)
110.                     if not self.__Checking(conn):
111.                         continue
112.                     self.__CONN_LIST.append(conn)
113.                     self.__SwapMsg(False, conn)
114.                 else:
115.                     self.__SwapMsg(True, slave)
116. 
117.     def __del__(self) -> None:
118.         for n in range(3):
119.             self.__WriteInExcel(n, '')
120.         self.__WriteInExcel(0, 'Server offline...')
121. 
122. if __name__ == '__main__':
123.     if len(sys.argv) == 5:
124.         Mt5_Excel = LinkMT5Excel(sys.argv[1], sys.argv[2], sys.argv[3], sys.argv[4])
125.         Mt5_Excel.Run()
126.         del Mt5_Excel
127.     else:
128.         print(f'Usage: {sys.argv[0]} <HOST> <PORT> <SHEET> <CELL>')

Código em Python

Se você vem acompanhando esta fase do replay/simulador, onde estou focando em explicar sobre soquetes. Nada neste código será de fato, muito estranho a você. E se você já estuda Python a algum tempo. Este código será ainda mais simples de ser entendido. Porém se este não é o seu caso, vamos entender o que está acontecendo aqui. Então para em vem acompanhando a sequência, tenhamos paciência com os demais. Mas principalmente com aqueles com menos experiência na área. Pois existem coisas aqui neste código que precisam ser bem entendidas.

Ok, começando com as linhas entre um e quatro, fazemos a importação de alguns dos pacotes que precisamos. Note que, não estamos usando nenhum pacote fora da instalação padrão do Python. Assim como também não estou fazendo nada de muito complicado neste ponto. Você poderia usar algum pacote como o pandas, xlwings, openpyxl ou qualquer outro, a fim de executar alguns dos passos que serão mostrados aqui, no decorrer deste artigo. Mas como dirigir a codificação a um determinado pacote, iria parecer está discriminando outro. Vamos fazer a coisa usando a instalação padrão do Python. Assim fica mais simples, para você que prefere usar um ou outro pacote, fazer isto da maneira que você achar melhor. A ideia aqui é ser o mais simples possível, sem puxar a sardinha para qualquer direção especifica.

Muito bem, uma vez feito tais importações. Iniciamos criando uma classe na linha seis. Daria para fazer isto sem usar classes. Mas quando usamos classes, podemos nos beneficiar de outras coisas. Assim na linha sete começamos definindo o inicializador da classe. Aqui recebemos alguns argumentos que nos dirão algumas coisas importantes para que o servidor funcione adequadamente. Observe onde tais parâmetros são usados, para entender o que está sendo esperado e como melhorar este mesmo código. 

Nas linhas nove e dez, declaramos e inicializamos duas variáveis que serão importantes depois. Já na linha 13, começamos a usar os argumentos passados. Observe que ali estamos dizendo ao servidor qual é o host, ou de onde esperamos receber uma conexão. Se este valor de host for 0.0.0.0, indica que aceitaremos qualquer endereço de cliente. Mas também pode ser um valor especifico. Este fica ao seu critério. Um detalhe importante nesta linha. Como a inicialização do servidor, se dará via Excel. Os argumentos passados serão strings. Por conta disto é preciso converte o valor da string em um valor adequado, que no caso é um integer, para indicar a porta a ser usada. Assim o Python saberá interpretar corretamente o valor a ser usado. As demais linhas, ou seja, entre as linhas 11 e 14 fazemos a inicialização do soquete, a fim de que o servidor possa ficar observando a porta esperando uma conexão. Se tiver alguma dúvida com relação a isto, veja os artigos anteriores.

Agora voltemos na linha oito, pois apesar de estes passos acima não acusarem falhas sem um bom motivo, nesta linha oito abrimos um ponto para analisar falhas no código. Tais falhas ocorrem em RUN-TIME. Então para que o usuário não venha a ver coisas estranhas sendo mostradas quando o script executar. Fazemos com que qualquer exceção seja tratada pelo próprio código.

Assim, na linha 16 tentamos capturar a seção ativa do Excel. Já que o servidor será inicializado por ele, teremos sucesso ao fazer isto. Porém, na linha 17 temos algo que pode falhar. Este é justamente o ponto em que tentamos acessar uma folha no Excel. Tal coisa pode falhar a qualquer momento, pelo simples fato, de que a folha não existe na planilha. E precisamos que esta folha exista. Se tivermos sucesso, iremos na linha 18 capturar a célula especifica a ser usada pelo servidor. Repare que dividimos isto em dois pontos. Na linha 18 capturamos a coluna e um valor numérico. Este valor numérico é convertido na linha 19 em um inteiro par podermos fazer alguns cálculos simples aqui no servidor. Mas calma, isto será entendido depois.

Agora o que realmente é preciso que você, caro leitor entenda, é que se alguma falha ocorrer durante esta inicialização. A linha 21 e isto encerrará o servidor, assim como também evitará alguma tentativa de enviar dados ao Excel. Tal coisa é importante ser feita, já que algo não foi devidamente acessado ou configurado e não queremos que o usuário veja mensagens que ele não entenda.

Bem, agora começamos a dura peregrinação, a fim de fazer as coisas funcionarem. Começamos na linha 23, onde temos um procedimento que irá tentar escrever algo no Excel. Mas não escreveremos em qualquer lugar. Faremos isto de uma forma bastante controlada. Então precisamos de um índex para nos descolocar em relação a coluna e linha que foi indicada na inicialização. Como aqui o objetivo é apenas didático, não usaremos a coluna, apenas a linha. Então baseado no valor da primeira linha, começamos a tentar escrever na folha indicada na inicialização. Mas como tal processo pode falhar, na linha 24, dizemos ao Python, que esperamos alguma falha.

Na linha 25 verificamos se temos algo válido na variável. Isto é importante, pois pode ocorrer de durante o desligamento, a folha não existir, e não queremos entrar sem motivos em um loop. Onde o servidor, está tentando sair, e é gerado uma exceção que dispara uma nova tentativa de saída, e esta faz com que este procedimento seja chamado, disparando uma nova exceção, e assim por diante. Para impedir justamente isto, fazemos um teste na linha 25. Então na linha 26, tentamos escrever na planilha. Neste ponto é que pode ocorrer um erro. Onde o usuário sem perceber, pode ter removido a folha que o servidor precisa na planilha. Isto fará com que a linha 27 seja disparada e o código ali executado. Finalizando assim o servidor.

Agora chegamos na linha 31. Esta linha capturará algo que esteja contido em uma célula especifica da planilha. Tal célula tem como referência a célula indicada na inicialização. Por isto é tão importante fazer as coisas com calma, e entender o que está acontecendo. Dá mesma maneira que ao tentarmos escrever em uma célula, o processo pode falhar, aqui temos a mesma coisa podendo ocorrer. Mas caso, a leitura aconteça de maneira esperada, na linha 34 retornaremos o valor contido na célula para que o servidor possa fazer uso de tal valor.

Talvez neste momento, você tenha pensado em uma coisa. Que é o seguinte: Se esta função na linha 31, consegue ler a planilha no Excel. Por que não simplesmente, durante a inicialização, dizer qual a folha e a célula para que o servidor busque o restante das informações diretamente no Excel? Bem, se você pensou nisto. Meus sinceros parabéns. Isto indica que você já percebeu uma possível melhoria que pode ser feita aqui, no script em Python. Mas vamos continuar, pois ainda temos muito a ser visto.

Na linha 40 temos um procedimento, que ajuda ao usuário no Excel, saber quando o MetaTrader 5, por qualquer motivo se tornou inacessível. Isto por conta que ele se desconectou. Tal procedimento é bem simples, não merecendo maiores explicações. Já na linha 49, temos outro procedimento igualmente simples, onde desconectamos o servidor por qualquer motivo. Muitos dos motivos, são por falhas durante a execução do script do servidor. Mas existem outros motivos que depois explicarei. Por hora não se preocupe com isto. Assim como também na linha 54, temos uma função bastante interessante. A partir de agora, a coisa começa realmente a ficar interessante. Mas primeiro vamos ver o que está acontecendo nesta função da linha 54.

Ela é bastante simples, tendo como objetivo, analisar algum comando que possa ter sido postado no soquete. Tal comando deverá ser executado pelo servidor. Por hora, temos apenas dois comandos. O primeiro se encontra presente na linha 55. Este tem como objetivo forçar o servidor a se desligar. Algo bem simples e direto. O segundo comando está na linha 58, Este estará forçando a desconexão do cliente, que no caso é o MetaTrader 5. Se não foi feito nenhum pedido ao servidor, a fim de executar algum comando, retornaremos na linha 62 um valor indicando falso. Ou seja, não era um comando o que foi postado.

Mas por que estamos retornando um valor falso? O motivo é justamente a função na linha 69. Esta função tem como principal objetivo checar se o cliente, que está tentando se conectar ao servidor, pode ou não ser aceito. Agora a coisa realmente fica interessante. Por que a princípio, qualquer um pode se conectar ao servidor. Porém, esta função tem como objetivo impedir que isto aconteça. Mas como? Simplesmente testando o que o cliente estará postando no soquete, assim que o servidor aceitar olhar a conexão. Assim na linha 72, verificamos o cabeçalho inicial da conexão. Apenas durante a tentativa de se conectar é que tal cabeçalho deverá estar presente. Mas durante todo o restante do tempo, isto não será mais necessário. Mas depois você entenderá como isto de fato funciona.

O que realmente precisa ficar claro aqui, é que na linha 71, fazemos uma separação entre o cabeçalho e algum comando enviado. O motivo disto é simples, e será entendido no próximo artigo, onde veremos a parte referente ao código no VBA do Excel. Mas se o cabeçalho informado pelo cliente não corresponder ao que é esperado pelo servidor, teremos a execução da função da linha 64. Esta função irá informar ao cliente que o servidor o está desconectando, pois o cliente, não foi reconhecido.

Caso o cabeçalho seja o esperado, na linha 74 tentaremos executar algum comando passado pelo cliente. Se não era um comando, iremos testar na linha 76, se já existe alguma conexão com o MetaTrader 5. Se existir, ou se o comando for diferente do esperado indicando que o cliente é o MetaTrader 5, a conexão será negada. Na última hipótese, teremos na linha 78 e 79 a informação de que o MetaTrader 5 está online. Se em qualquer momento tivermos uma exceção, teremos a conexão sendo recusada. Isto devido ao disparo da linha 80.

Agora chegamos a um procedimento crucial. Este é visto na linha 84. E o que este procedimento faz? Ele é o responsável pela troca de mensagens entre o MetaTrader 5 e o Excel. Agora preste atenção, pois apesar deste procedimento ser relativamente simples, se você não o entender, não conseguirá adaptar o código ao que você deseja fazer. É bem verdade, que apenas depois de ver os próximos artigos é que tudo isto realmente fará sentido. Mas por hora, vamos tentar entender o que está acontecendo aqui no script em Python.

Já que podemos ter falhas ocorrendo aqui, iniciamos o código já dizendo ao Python que esperamos erros. Isto é feito na linha 85. Agora caso o chamador esteja dizendo para este procedimento aqui, ler o soquete, a linha 86 terá sucesso e entraremos na parte de leitura do soquete. Isto é feito na linha 87.

Agora muita, mas muita atenção ao que irei explicar. Pois isto será de grande importância depois. Na linha 88, verificamos se recebemos algo no soquete, se isto não ocorreu iremos desconectar o MetaTrader 5. Porém, se temos algo no soquete, verificamos na linha 89 a existência de um dado carácter na mensagem recebida. Se tal carácter existir na mensagem, significa que ela é um comando vindo do MetaTrader 5. Isto fará com que a linha 90 seja executada. Mas se esta execução falhar, nada mais será postado. Mas observe o código de comandos para ver que tipo de coisa é esperada vindo do MetaTrader 5. Quando formos falar sobre o código em MQL5, voltaremos neste ponto. Por hora, saiba que o MetaTrader 5, pode enviar comandos para o servidor executar.

Ok, mas e se não foi um comando? Isto por conta que a linha 89 falhou. O que acontecerá? Neste caso, teremos a execução da linha 93. Esta postará em uma determinada célula a informação postada pelo MetaTrader 5, em resposta a uma solicitação do Excel. Mas qual solicitação? Agora chegamos ao ponto realmente de interesse. E este ponto é a linha 97. Repare nesta linha o que estamos fazendo. Nela usamos o servidor para postar no soquete uma solicitação ao MetaTrader 5. Tal solicitação pode ser de duas formas:

• A primeira é que o conteúdo da leitura de uma célula ou range especifico de células no Excel. Se bem que para simplificar não estamos usando um range, apenas lendo o conteúdo específico de uma célula.
• A segunda coisa é que dentro dos colchetes enviaremos, quando o Excel disser, algum comando para o MetaTrader 5 executar.

A maneira como a execução de tais comandos ou pedidos do Excel ao MetaTrader 5, será de fato implementado será visto depois. Por hora, note que temos um protocolo bastante simples para que a comunicação aconteça. Ou seja, basicamente o que estiver na célula ou como comando postado pelo Excel, será enviado ao MetaTrader 5. O servidor não tomará parte desta fase de troca de mensagens. Ele apenas irá protocolar as mensagens nos pontos indicador nesta rotina para que o VBA e o MQL5 façam a sua parte depois.

Porém, se você desejar aumentar ou melhorar a quantidade e qualidade das informações a serem transferidas entre o Excel e o MetaTrader 5. Pode fazer uso do Python para simplificar o trabalho que será feito no VBA ou em MQL5. Mas já que o intuito aqui é ser o mais didático quanto for possível. Estaremos usando um protocolo bem simples de mensagens. Fazendo uso de apenas e somente uma célula no Excel. Se você entender com isto foi feito, poderá fazer qualquer outra coisa de seu interesse.

Agora, observe que todas as posições das células usadas aqui, tem como origem justamente aquela primeira célula, indicada na inicialização do servidor. É importante que você entenda estes detalhes, já que faremos todo o restante das coisas diretamente dentro do VBA do Excel. Algo que será bastante simples e fácil de ser feito e executado.

Muito bem, com isto estamos chegando aos finalmente. Assim chegamos na linha 101. Praticamente tudo que está neste procedimento, já foi visto nos artigos anteriores sobre soquetes. Mas existem alguns pontos que merecem algum destaque ou explicação. Como por exemplo, na linha 113 onde temos algo estranho a primeira vista. Mas não tão estranho se você pensar bem e estiver acompanhando esta sequência. Se a checagem que é feita na linha 110 passar, enviaremos algo para o cliente que acaba de se conectar. Normalmente é uma mensagem de boas vindas.

Mas aqui, faremos algo inteiramente diferente. Como o Excel, quando fizer uma conexão, não ficará muito tempo nela. Entenda esta informação que estará sendo enviada como sendo uma informação direcionada ao MetaTrader 5. Por isto é importante entender o procedimento da linha 84, que foi explicado a pouco. Assim esta primeira chamada não irá ler o soquete, apenas escrever nele. Já quando o servidor receber uma resposta do MetaTrader 5, teremos a execução da linha 115. Desta vez sim iremos ler o soquete e também escrever nele. Assim ficaremos dentro de um loop recebendo constantemente informações vindas do MetaTrader 5 e sendo repassadas ao Excel.

Para finalizar temos um procedimento bastante estranho para muitos de vocês. Isto por que ele é um destructor da classe. Assim como tivemos um constructor que é o __init__ temos também um destructor que no caso é o __del__. Normalmente este destructor não é colocado no código de um script em Python. Isto por que o Python, tem um coletor de lixo, que quando o script encerra remove as coisas e limpa a memória utilizada. Porém este destructor aqui, tem uma tarefa um pouco mais nobre. Ele de fato faz com que o Excel, exiba na posição que normalmente indica que o servidor está online, uma mensagem de que o servidor está offline. Assim você poderá visualizar, isto diretamente no Excel, sem precisar usar outros meios ou recursos. O restante do código é tão simples, que não será preciso dar nenhuma outra atenção a ele.

Considerações finais

Com estas explicações dadas aqui, finalizamos a parte referente ao servidor em Python. Novamente, este servidor, tem como objetivo ser o mais didático e simples quanto é possível criar em Python. Isto usando apenas e somente os pacotes que são colocados durante a instalação padrão do Python. Você, caro leitor, conseguiria de fato criar algo bem mais elaborado e prático, usando outros pacotes e componentes a fim de manipular arquivos em Excel. Tanto que poderia criar toda a planilha em Excel, assim como diversas outras coisas, diretamente dentro deste código em Python.

Mas não quero complicar, ou mesmo puxar a sardinha para um ou outro pacote em especifico no Python. Sei que existem diversos, e de excelente qualidade, que nos permite fazer diversas coisas. Inclusive substituir totalmente a necessidade de se criar algo usando o Excel. Mas como foi dito em um outro artigo. A ideia aqui, e atender a algum cliente, ou usuário que se nega a fazer uso de qualquer outra coisa que não o Excel. Isto para criar uma planilha para analise fundamentalista de um determinado ativo. A fim de poder comprar ou vender ele em determinadas faixas de preço. Alguns de vocês podem se perguntar: Mas por que não colocar a ordem no book do ativo nas posições desejadas. Assim não precisaria de fato ficar fazendo as coisas diretamente no Excel. Poderia fazer elas diretamente no MetaTrader 5.

Eu entendo você que pensa assim. Mas tem gente que não tem paciência ou mesmo disposição de ficar ali, olhando um gráfico e colocando e tirando ordens. Abrindo e fechando posições. A pessoa simplesmente gosta de fazer tudo em poucos programas. Normalmente programas que elas dominam e já tem todo um estudo dentro dele. E não abrem mão de tal coisa. Então eles querem simplesmente que você, como programador, crie algum método ou meio, para que eles usando este determinado programa, que no caso é o Excel. Consigam enviar ordens, fechar posições ou abrir posições em uma determinada faixa de preço.

Não querem se preocupar em entender como isto será feito. Eles apenas te contratam e lhe pagam para que isto seja feito, da melhor forma possível. E é esta a proposta que estou mostrando como fazer. Pelo menos em parte. Já que você como programador, poderá desejar fazer as coisas de uma outra forma, ou ligeiramente diferente. Pessoalmente, para mim isto pouco importa. O que realmente me dá satisfação é saber, que ao ler estes artigos, você que pensava não ser possível fazer certas coisas. Veja que é sim possível fazer qualquer coisa. Basta que para isto, você estude e dedique algum tempo em fazer as coisas acontecerem. No próximo artigo, vamos ver a parte do VBA no Excel, onde você entenderá como colocar este servidor visto neste artigo em funcionamento junto com o Excel. Então até o próximo artigo desta mesma sequência.

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)