Simulação de mercado (Parte 07): Sockets (I)

Introdução

No artigo anterior Simulação de mercado (Parte 06): Transferindo informações do MetraTrader 5 para o Excel, expliquei como você pode usando meios simples e puramente o MQL5, transferir dados de cotação do MetaTrader 5, para dentro do Excel. Claro que aquilo foi apenas um exemplo bastante simples, cuja intenção era ser o mais didático quanto fosse possível. Porém, você deve ter notado que a atualização da cotação não se dava em tempo real. No entanto, aquele conhecimento que foi mostrado no artigo anterior, visa apresentar uma outra coisa que realmente precisaremos fazer.

Mas como existem diversas maneiras de se fazer a mesma coisa, e o que nos interessa realmente é sempre o resultado. Queria mostrar que sim, existe uma forma simples, de passar dados do MetaTrader 5 para dentro de outros programas, como por exemplo o Excel. Porém, a principal ideia, não é transferir dados do MetaTrader 5, para o Excel. E sim fazer o contrário. Ou seja, transferir dados do Excel, ou de qualquer outro programa, para dentro do MetaTrader 5.

Existem diversas maneiras de se fazer isto. Algumas mais simples e outras mais elaboradas. Algumas farão isto em tempo real e outras terão um pequeno delay. Mas o que importa é: Podemos controlar o MetaTrader 5, algum tipo de aplicação rodando nele, via dados externos? Este tipo de questão pode parecer bobagem. Mas isto abre alguns precedentes. Como por exemplo, você poderá fazer algum tipo de estudo ou analise. Usando para isto um programa externo, próprio para fazer este tipo de coisa. Ter ali, pontos de interesse, em temos de preço ou cotação. E colocar tais dados em um local, onde alguma aplicação, seja um Expert Advisor, Serviço, Script ou até mesmo um Indicador, possa usar tais dados. Podendo assim nos dar indicações diretamente no gráfico, ou até mesmo, no caso do Expert Advisor, nós auxiliar em tomadas de decisões.

Neste ponto, o que vale é a sua imaginação e o seu interesse. Somente isto irá de fato limitar o que se pode fazer e até aonde podemos ir. Mas quero mostrar uma outra coisa, antes de passarmos para a fase de desenvolvimento de algo que realmente precisamos no Replay/Simulador. Para isto, tais conceitos, ideias e possibilidades, precisam ser mostradas. Isto para que você consiga de fato entender, o que será desenvolvido e implementado depois. E assim possa fazer o melhor uso possível de todo este conhecimento.

O que mostrarei neste artigo, é um passo adiante nesta mesma questão que foi mostrada no artigo anterior. Pois como eu disse, aquela forma mostrada não nos permite enviar dados em tempo real. Apesar de já ser o suficiente para o que precisaremos no replay/simulador. Aquilo não se adéqua ao que precisamos caso queiramos informações em REAL-TIME.

Entendendo o conceito

Como falei no artigo anterior, fazer uso de um RTD ou de um DDE, não nos garante uma comunicação bidirecional. Pelo menos não com relação ao MetaTrader 5 e outro programa qualquer. Mas o mesmo conceito usado em um RTD ou DDE, pode ser aplicado de forma a termos o que queremos. Ou seja, uma comunicação bidirecional. Para fazer isto, precisaremos fazer algo, um pouco diferente, do que tem sido feito até aqui. Durante toda esta fase de desenvolvimento, tenho mantido e feito absolutamente tudo em MQL5 puro. No entanto, existem casos, que o MQL5 puro não é de fato o suficiente. Não por conta do que ele pode fazer, mas por conta do que outros programas não podem fazer, sem ajuda. A questão é uma só. E tem como nome: SOQUETE.

Este tal de soquete é algo que está encrustado firmemente na computação. Se você não sabe o que é um soquete e para que eles servem. Sugiro que você procure saber, principalmente se deseja fazer certas coisas. Já que usando eles, passamos a ter um grau enorme de liberdade. Aqui não irei de fato me aprofundar no assunto. Já que o mesmo é bastante extenso e com diversas possibilidades e coisas das quais você precisará estudar com calma. Isto caso realmente queira trabalhar com soquetes. Mas farei uma breve explicação a fim de que você, caro leitor não fique totalmente perdido. E sem entender o que estaremos fazendo e o que está se passando.

Protocolo TCP

A primeira coisa que você precisa entender, é que existem uma infinidade de tipos diferentes de soquetes. Cada um serve para um propósito diferente. Porém os mais comuns são o do tipo Stream e DataGram. O tipo stream, ou soquete de fluxo, é comumente utilizado em comunicações bidirecionais confiáveis. Esta palavra confiável tem haver, com o fato, de que ele é sempre testado, quanto ao recebimento da informação. Tais soquetes do tipo Stream, fazem uso do protocolo de controle de transmissão, ou mais conhecido como TCP.

Este tipo de soquete, tem um outro detalhe também. Ele é projetado para que os pacotes de informação, sempre cheguem em uma dada sequência. Ou seja, você pode transferir a informação como se fosse uma enorme lista que vai se desenrolando, conforme os pacotes vão chegando. Assim você deve claramente perceber onde ele é mais usado. Como por exemplo em controle de aplicativos a distância. Onde não podemos nos dar ao luxo de perda de dados na transmissão. E precisamos ter uma garantia de que as informações serão recebidas. Porém isto torna o protocolo um pouco mais lento em seu uso. Tipicamente ele tem a seguinte forma, mostrada na imagem abaixo:

Mas o que nos interessa, em termos de programação é uma outra coisa. E esta coisa é como este protocolo é escolhido e implementado no código que estaremos criando. Existem algumas poucas diferenças em termos de estrutura no código, quando vamos usar o TCP no Windows ou no Linux. Apesar de tais diferenças existirem no código. Elas não interferem na questão da comunicação em si. Ou seja, você pode colocar uma aplicação no Windows se comunicar com uma no Linux, usando o TCP. E ambas as aplicações conseguirão se entender perfeitamente bem. Isto desde é claro, as regras de comunicação venham a ser seguidas. A mesma coisa acontece com o próximo protocolo, que veremos no próximo tópico.

Protocolo UDP

Dito tais coisas sobre o tipo Stream, vamos agora entender o tipo DataGram. O tipo DataGram, ou soquete de datagrama, é um tipo completamente diferente do soquete de fluxo, ou o TCP. Isto por que, este soquete de datagrama, é voltado para uma comunicação unidirecional e não confiável. Mas como assim. Como uma comunicação pode ser unidirecional e não confiável? Bem, vamos com calma.

Primeiro vamos entender que este soquete faz uso do protocolo mais conhecido como UDP. Este protocolo não é uma conexão real, mas apenas um método de enviar dados. Para que você possa compreender melhor. Seria como se fosse uma carta. Você a escreve e a envia. Porém uma vez que você a enviou não sabe quando e se ela irá de fato chegar ao destinatário.

Mas a coisa é um pouco mais complicada do que isto. Pois você depois de enviar a carta, acaba percebendo que faltou alguns detalhes a serem explicados. Daí você escreve uma outra carta explicando aqueles detalhes. E isto pode acontecer diversas vezes. Onde cada uma das cartas que você escreveu é enviada.

Agora vem o grande detalhe: Se o serviço postal, trabalhar corretamente, e nenhuma das cartas for extraviada ou perdida no caminho. Quem as receber, pode receber todas de uma única vez. Pode as receber na ordem em que você as enviou, ou também pode as receber em uma ordem aleatória.

Pense no trabalho que você, como receptor terá em entender a mensagem enviada. No entanto, se você foi quem enviou a carta, e espera uma resposta, não terá nenhuma certeza ou segurança, que o destinatário recebeu e conseguiu entender as mensagens. Por isto este protocolo UDP, é do tipo unidirecional e não confiável. Entenderam por que não podemos levar as coisas ao pé da letra. Apesar de você achar que ele não tem utilidade, isto não é verdade.

Já que existem situações, como por exemplo, no que envolve sondagem de dados, onde não precisamos que os dados estejam em uma sequência. E muito menos precisamos de todos. Podemos nos dar ao luxo de poder perder alguns dados. E mesmo assim, os dados recebidos serão suficientes para que possamos entender a informação.

Um exemplo típico, seria em chamadas de vídeo conferência ou chamadas de voz. Onde a velocidade de transferência é o que desejamos e damos na maior parte das vezes prioridade. Uma outra aplicação, seria em sondas ou sensores remotos. Onde o intuito seria apenas atestar uma determinada condição. Este tipo de coisa, na maior parte das vezes não existe uma confirmação de recebimento dos dados. Isto, desde que a quantidade de dados que conseguimos coletar, seja suficiente para que possamos analisar a informação. Este protocolo tipicamente tem o seguinte formato:

Acredito que isto já deva ter aguçado, a sua curiosidade a ponto de desejar se aprofundar, ainda mais no estudo sobre este tema. De fato, ele é muito extenso e bastante interessante. Aqui estou apenas dando um leve deslumbre de tudo que se pode fazer. Você encontrará, aqui mesmo na comunidade MQL5, várias pessoas que comentam sobre o tema. Seja em artigos ou seja no fórum. De qualquer modo, o tema é extremamente extenso. Mas dei esta leve introdução, para que você consiga entender o que faremos a seguir.

Programando um sistema modesto

Aqui temos de abrir um parêntese. Isto por que, para demonstrar o que será feito precisamos utilizar um código que seja bastante simples. Já que o MQL5, não nos permite criar um servidor, diretamente dentro da linguagem. Vamos usar o MQL5, para produzir a parte do cliente. Sim, vamos criar um modelo Cliente - Servidor. A parte do servidor, será feita via programação externa. Neste caso, você poderá fazer isto usando qualquer tipo de código, ou linguagem que permita criar um servidor de rede. Mas existem alguns detalhes, que você precisa ficar atento, como por exemplo: a porta e o tipo de protocolo a ser utilizado. Para simplificar ao máximo, usarei um código, que você poderá estudar diretamente da fonte. Ou seja, vamos usar um código público e disponível na WEB. O código do servidor, pode ser encontrado na página da Microsoft. Você terá acesso a ele usando este link daqui: Servidor WinSock.

No final do artigo, deixarei este mesmo local como uma referência. Assim você poderá estudar passo a passo como o código funciona. Assim como também diversos outros detalhes relacionados a questão dos soquetes. E isto não se aplica, somente a parte referente ao servidor, mas também a parte referente ao cliente. Este também é explicado no mesmo local.

NOTA IMPORTANTE: Este servidor, que estou indicando é um modelo muito simples. Onde ele recebe uma conexão. Captura o que foi enviado a ele. Logo em seguida ele fechará a conexão, não podendo receber outra. Devolvendo ao cliente a exata informação enviada. Ou seja, ele seria um servidor de eco, onde servirá apenas para demonstração.

Porém aqui, faremos algo um pouco diferente na parte do cliente. Vamos criar o cliente diretamente no MQL5. Dispensando assim o código em linguagem C/C++, que pode ser encontrada no referido site. Desta forma, você poderá entender como a comunicação realmente acontece. Lembrando, que você poderia até tornar o MetaTrader 5 um servidor. Mas isto nos forçaria a fazer uso de uma DLL. E no momento, não quero usar este tipo de recurso. Pelo menos por enquanto.

Então mãos a obra. Você pode usar o código que indiquei, ou então criar o seu em qualquer linguagem ou plataforma. A ideia aqui é simplesmente fazer um sistema modesto. E que seja o mais simples possível. Porém que sirva de gatilho, para você entender, como as coisas funcionam. Uma vez com o servidor compilado e funcionando, vamos partir para a parte referente ao MQL5. Para isto abra o MetaEditor criar o cliente em MQL5 puro.

Executando a parte do MetaTrader

Antes de fazemos uma conexão com o nosso servidor local. Temos que entender e aprender como realmente fazer uma conexão. Isto por que, por padrão, o MetaTrader 5 evita que você se conecte a algum servidor, que não seja o de negociação. Este tipo de coisa é uma questão se segurança, que você deve aceitar e compreender. Não é nem um pouco adequado, permitir que uma plataforma como o MetaTrader, se conecte a torto e a direita com qualquer endereço. Por isto é preciso fazer uma pequena coisa antes de o MetaTrader, permitir uma conexão.

Para que você entenda de maneira muito, mas muito simples. Vamos usar algo que se encontra presente na própria documentação do MQL5. Então o código abaixo, não é de minha autoria. Ele faz parte da documentação e pode ser acessado ao se pesquisar sobre: SocketCreate. O código fonte pode ser visto logo abaixo da maneira como se encontra na documentação.

001. //+------------------------------------------------------------------+
002. //|                                                SocketExample.mq5 |
003. //|                        Copyright 2018, MetaQuotes Software Corp. |
004. //|                                             https://www.mql5.com |
005. //+------------------------------------------------------------------+
006. #property copyright   "Copyright 2018, MetaQuotes Software Corp."
007. #property link        "https://www.mql5.com"
008. #property version     "1.00"
009. #property description "Add Address to the list of allowed ones in the terminal settings to let the example work"
010. #property script_show_inputs
011.  
012. input string Address="www.mql5.com";
013. input int    Port   =80;
014. bool         ExtTLS =false;
015. //+------------------------------------------------------------------+
016. //| Send command to the server                                       |
017. //+------------------------------------------------------------------+
018. bool HTTPSend(int socket,string request)
019.   {
020.    char req[];
021.    int  len=StringToCharArray(request,req)-1;
022.    if(len<0)
023.       return(false);
024. //--- if secure TLS connection is used via the port 443
025.    if(ExtTLS)
026.       return(SocketTlsSend(socket,req,len)==len);
027. //--- if standard TCP connection is used
028.    return(SocketSend(socket,req,len)==len);
029.   }
030. //+------------------------------------------------------------------+
031. //| Read server response                                             |
032. //+------------------------------------------------------------------+
033. bool HTTPRecv(int socket,uint timeout)
034.   {
035.    char   rsp[];
036.    string result;
037.    uint   timeout_check=GetTickCount()+timeout;
038. //--- read data from sockets till they are still present but not longer than timeout
039.    do
040.      {
041.       uint len=SocketIsReadable(socket);
042.       if(len)
043.         {
044.          int rsp_len;
045.          //--- various reading commands depending on whether the connection is secure or not
046.          if(ExtTLS)
047.             rsp_len=SocketTlsRead(socket,rsp,len);
048.          else
049.             rsp_len=SocketRead(socket,rsp,len,timeout);
050.          //--- analyze the response
051.          if(rsp_len>0)
052.            {
053.             result+=CharArrayToString(rsp,0,rsp_len);
054.             //--- print only the response header
055.             int header_end=StringFind(result,"\r\n\r\n");
056.             if(header_end>0)
057.               {
058.                Print("HTTP answer header received:");
059.                Print(StringSubstr(result,0,header_end));
060.                return(true);
061.               }
062.            }
063.         }
064.      }
065.    while(GetTickCount()<timeout_check && !IsStopped());
066.    return(false);
067.   }
068. //+------------------------------------------------------------------+
069. //| Script program start function                                    |
070. //+------------------------------------------------------------------+
071. void OnStart()
072.   {
073.    int socket=SocketCreate();
074. //--- check the handle
075.    if(socket!=INVALID_HANDLE)
076.      {
077.       //--- connect if all is well
078.       if(SocketConnect(socket,Address,Port,1000))
079.         {
080.          Print("Established connection to ",Address,":",Port);
081.  
082.          string   subject,issuer,serial,thumbprint;
083.          datetime expiration;
084.          //--- if connection is secured by the certificate, display its data
085.          if(SocketTlsCertificate(socket,subject,issuer,serial,thumbprint,expiration))
086.            {
087.             Print("TLS certificate:");
088.             Print("   Owner:  ",subject);
089.             Print("   Issuer:  ",issuer);
090.             Print("   Number:     ",serial);
091.             Print("   Print: ",thumbprint);
092.             Print("   Expiration: ",expiration);
093.             ExtTLS=true;
094.            }
095.          //--- send GET request to the server
096.          if(HTTPSend(socket,"GET / HTTP/1.1\r\nHost: www.mql5.com\r\nUser-Agent: MT5\r\n\r\n"))
097.            {
098.             Print("GET request sent");
099.             //--- read the response
100.             if(!HTTPRecv(socket,1000))
101.                Print("Failed to get a response, error ",GetLastError());
102.            }
103.          else
104.             Print("Failed to send GET request, error ",GetLastError());
105.         }
106.       else
107.         {
108.          Print("Connection to ",Address,":",Port," failed, error ",GetLastError());
109.         }
110.       //--- close a socket after using
111.       SocketClose(socket);
112.      }
113.    else
114.       Print("Failed to create a socket, error ",GetLastError());
115.   }
116. //+------------------------------------------------------------------+

Código presente na documentação do MQL5

Este código é perfeito para explicar, como trabalhar e ajustar as conexões no MetaTrader 5. Isto por que além de ser muito simples, ele nos fornece a possibilidade de um acesso remoto. Ou seja, iremos de fato acessar uma página na WEB. Acredito que muitos, com alguma experiência em programação de rede, consigam entender este código sem dificuldade. Mas para quem não sabe nada do assunto. Vou dar uma rápida explicação. Isto por que iremos depois precisar saber algumas coisas presentes aqui.

Este código é um script, e deverá ser compilado como tal. Não é possível usar soquetes em indicadores. Leia a documentação para mais detalhes. Agora vamos ver como isto funciona. Na linha 12, dissemos qual o nome do site a ser acessado. Na linha 13 indicamos a porta a ser utilizada. No caso, será uma porta que responde a requerimentos do tipo HTTP. Ou seja, é um servidor WEB. Veja na referência o que esperar em cada tipo de porta.

Pois bem, quando o código inicia, isto na linha 71, a primeira coisa que fazemos é criar um soquete. Isto na linha 73. Até ai tudo muito simples. Porém precisamos verificar se o soquete criado é valido, isto é feito na linha 75. Na linha 78 tentamos nos conectar ao servidor e a porta indicada lá nas linhas 12 e 13. Se isto falhar você verá algo do tipo mostrado na imagem abaixo:

Este tipo de coisa, possivelmente está sendo gerada por conta que o MetaTrader 5, está bloqueando a conexão. Para habilitar a mesma, você deverá pressionar CTRL + O e adicionar uma exceção a regra, conforme mostrado abaixo:

Uma vez feita a mudança que você pode ver logo acima. Você poderá rodar novamente o script, e o resultado será algo parecido com a imagem abaixo:

Mas como isto aconteceu. Como conseguimos saber algumas informações vindas do servidor WEB? Não seria preciso usar uma chamada WebRequest para isto? Na verdade não necessariamente. A chamada WebRequest faz praticamente a mesma coisa que acabamos de fazer. Porém agora estamos em uma camada um pouco mais próxima do Hardware. Isto por que a chamada WebRequest, cria uma abstração para o soquete que está logo abaixo. Por isto o resultado é o mesmo em ambos modos de uso. No passado exploramos o uso da chamada WebRequest. Se desejar saber mais detalhes, veja os seguintes artigos:

• Desenvolvendo um EA de negociação do zero( Parte 15): Acessando dados na WEB (I)
• Desenvolvendo um EA de negociação do zero (Parte 16): Acessando dados na WEB (II)
• Desenvolvendo um EA de negociação do zero (Parte 17): Acessando dados na WEB (III)

O que foi feito nestes três artigos acima mencionados, pode ser feito usando os soquetes diretamente. Porém você terá que programar um pouco mais, de forma a obter o mesmo resultado. Mas vamos voltar ao nosso sistema, que estamos vendo neste artigo. Depois que o código do servidor, que indiquei no tópico anterior tenha sido compilado. Você deverá deixar ele sendo executado, antes de executar o script que mostrarei em breve. Lembrando mais uma vez que você pode criar o seu próprio servidor em qualquer linguagem desejada. A única exigência no momento, é que os dados recebidos pelo servidor, sejam repostados para o cliente. Isto para que tenhamos o mesmo comportamento que estarei explicando.

Então vamos ver o código em MQL5, do que será o nosso cliente. Este pode ser visto logo abaixo, na íntegra.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. #property version   "1.00"
04. #property script_show_inputs 
05. //+------------------------------------------------------------------+ 
06. input string user00 = "127.0.0.1";          //Address
07. input int    user01 = 27015;                //Port
08. //+------------------------------------------------------------------+
09. bool ConnectionWrite(int socket, string szMsg, bool TLS = false)
10. {
11.     char buff[];
12.     int  len = StringToCharArray(szMsg, buff) - 1;
13. 
14.     if (len < 0) return false;
15.     Print("To Server:", szMsg);
16.     return (TLS ? SocketTlsSend(socket, buff, len) : SocketSend(socket, buff, len)) == len;
17. }
18. //+------------------------------------------------------------------+
19. string ConnectionRead(int socket, uint timeout)
20. {
21.     uint len;
22.     int  ret;
23.     char resp[];
24.     string info;
25.     uint timeout_check = GetTickCount() + timeout;
26.     
27.     info = "";
28.     do
29.     {
30.             len = SocketIsReadable(socket);
31.             ret = SocketRead(socket, resp, len, timeout);
32.             if (ret > 0)
33.                     info += CharArrayToString(resp, 0, ret);
34.     }while ((GetTickCount() < timeout_check) && (!_StopFlag));
35.     
36.     return info;
37. }
38. //+------------------------------------------------------------------+
39. void OnStart()
40. {
41.     int socket = SocketCreate();
42.     
43.     if (socket == INVALID_HANDLE)
44.     {
45.             Print("Unable to create socket. Error: ", GetLastError());
46.             return;
47.     }
48.     if (!SocketConnect(socket, user00, user01, 1000))
49.     {
50.             Print("Connection with the address [", user00,"] in port: ",user01, " failed. Error code: ", GetLastError());
51.             SocketClose(socket);
52.             return;
53.     }
54.     
55.     Print("Trying to send ", ConnectionWrite(socket, "Testing Server Echo...") ? "Ok..." : "Failed...");
56.     
57.     Print("From Server:", ConnectionRead(socket, 1000));
58. 
59.     SocketClose(socket);
60. }
61. //+------------------------------------------------------------------+

Código para demonstração

Vamos entender alguns detalhes neste código. Antes de ver como ele executará no MetaTrader 5. A primeira coisa é a linha seis. Nesta linha dizemos onde está o nosso servidor. No caso, estamos dizendo que ele está na mesma máquina, que o MetaTrader 5 se encontra. A linha sete, informa qual é a porta que estaremos acessando o servidor. Um detalhe muito importante: Esta porta deverá ser a mesma indicada lá no código do servidor. Por isto que indiquei um código publico e que está muito bem explicado no referido site. Em caso de dúvidas, estude a documentação presente no site. Ela estará sendo indicada no final deste artigo como referência.

Basicamente, todas as funções presentes neste script do MQL5, são autoexplicativas. E em caso de dúvidas, bastará você ler a documentação para entender alguns detalhes a respeito do que está acontecendo. Porém, existe uma parte em que as coisas não são tão claras. E este ponto merece alguma explicação.

Observe que na linha 28 entramos em um loop. Este tem como finalidade ler o que o servidor postará no soquete. Mas por que usar um loop? Não bastaria simplesmente ler o soquete? Bem, isto de fato parece um pouco confuso. Mas tem as suas razões. Quando algo é postado no soquete, não sabemos como será postado. Somente sabemos que será postado. A informação pode ir em um único pacote. Mas também pode fazer uso de pequenos pacotes. Mesmo que a informação seja relativamente curta.

Este tipo de coisa, faz com que muita gente que começa a experimentar uma programação que envolve soquetes, tenha alguma dificuldade. Justamente pelo motivo, de que a pessoa, pensa que a informação será postada em um bloco só. Quando ela pode estar dividida em muitos blocos ou pacotes. Mas tem como saber disto de ante mão? Na verdade não existe uma forma simples de saber disto. Tudo que podemos esperar é que o pacote que foi enviado seja recebido. Isto quando usamos o protocolo TCP como expliquei no começo do artigo. Mas a questão é que a informação será postada e recebida, normalmente em termos de pacotes.

Para entender melhor, observe a linha 55. Nesta linha efetuamos uma chamada a linha nove. Esta receberá a informação que deverá ser colocada no soquete. Pois bem, na linha 15 informamos qual será a mensagem. E na linha 16 enviamos ela. A forma como o servidor irá de fato receber a mensagem e em quantos pacotes ela utilizará, não depende mais de nos. O próprio sistema fará esta divisão.

Assim que a linha 57 for executada, iremos de fato ler o que o servidor postou. Preste atenção a isto. Não estaremos lendo o que postamos. Mas sim o que o servidor postou. Por conta que o servidor que indiquei é um do tipo eco. A mesma mensagem que postamos será devolvida a nos. Isto seria mais ou menos como se fosse dado um PING no servidor.

Mas da mesma forma que não controlamos como a mensagem será transmitida. Também não sabemos como o servidor estará a devolvendo. Isto falando em termos de número de pacotes usados. Assim sendo, se você remover o loop da linha 28 e executar apenas a chamada da linha 31 e logo depois usar a linha 33 para converter para uma string, o que o servidor postou. Irá fatalmente notar que a mensagem poderá estar fragmentada. Como se estivesse faltando algum pedaço. Porém em alguns momentos ela será postada de forma completa. Isto por que a mesma é bem curta. E é justamente este tipo de coisa que muitos não conseguem entender.

Sei que isto parece bastante confuso e pouco eficiente. Não servido para absolutamente nada. Porém gostaria de ressaltar uma coisa. Se você entender como estes dois códigos funcionam. Tanto o que faz o papel de servidor, quanto este que será executado no Metatrader 5. Notará que podemos fazer muita, mas muita coisa.

Mas antes de colocar este script para funcionar. Será preciso informar ao MetaTrader 5, que o endereço usado deverá ser permitido. Desta forma o mesmo valor indicado na linha seis deverá constar na lista de endereços no MetaTrader 5. Então você deverá ver algo como mostrada na imagem abaixo.

Com esta modificação feita, podemos executar ambos os programas. Para que você saiba como fazer isto. Caso não tenha experiência em programação em múltiplas linhas. Estou colocando no vídeo abaixo, a forma de você experimentar localmente como a coisa funciona. Porém quero ressaltar que a ideia do vídeo não é promover nenhuma ferramenta específica. Ele tem como objetivo, apenas mostrar, para quem não sabe, como executar programas em múltiplas linhas de trabalho. E assim conseguir promover algum tipo de desenvolvimento, sem grandes problemas.

Considerações finais

Neste artigo, dei uma breve introdução a um dos conceitos mais complexos que você poderá fazer uso no MetaTrader 5. Que é o uso de soquetes. Este artigo teve como finalidade apenas explicar o básico do básico, de como fazer uso de soquetes dentro do MetaTrader 5. Isto para que você possa minimamente entender alguns dos conceitos necessários e envolvidos. Porém, apenas do conteúdo deste artigo, ser muito básico, ele é primordial para quem deseja estudar soquetes e sua utilização.

Mas como aqui tudo que fizemos foi apenas dar um eco no servidor. Talvez não tenha ficado realmente claro o quanto podemos de fato fazer. Mas para ajudar neste quesito, no próximo artigo faremos algo um pouco mais elaborado. Já que este conceito sobre soquetes, poderá lhe ajudar muito a ter uma melhor qualidade no uso do sistema de replay/simulador. Isto por que, ainda precisaremos implementar algumas coisas, como por exemplo o sistema de ordens. E estou pensando seriamente em fazer isto de uma maneira um pouco mais elaborada. Mas para que você, caro leitor venha de fato a entender o que estará sendo programado. Será preciso que você entenda estes pequenos conceitos que estou mostrando aqui.

Se existe alguma coisa que fará você estudar muito, quando o assunto é programação. Esta coisa deve ter um nome. E o nome dela é SOQUETE. Quando o assunto é soquete, nunca se sabe o bastante. E quando você achar que já explorou de tudo, no que diz respeito a soquetes. Irá definitivamente perceber que ainda existe algo a ser explorado. Então não perca o próximo artigo. Pois mostrarei, um uso coisa bastante interessante, e simples de ser implementado a respeito deste assunto.

Referência

Documentação de uso do WinSock da Microsoft

Lista de portas TCP e UDP

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 mantem o serviço de replay e simulação de mercado (Arquivo principal de todo o sistema)
Code VS C++\Servidor.cpp	Cria e mantem um soquete servidor criado em C++ ( Versão Mini Chat )
Code in Python\Server.py	Cria e mantem 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)