Escolar Documentos
Profissional Documentos
Cultura Documentos
Bot Development PDF
Bot Development PDF
MQL4
Desenvolvendo seu Robô
Flávio Moraes
17
1
Sumário
Introdução ..................................................................................................................................... 5
Introdução à programação MQL4 ................................................................................................. 6
Noções básicas de MQL4 ........................................................................................................... 9
Alguns conceitos básicos ......................................................................................................... 10
A noção de um tick .............................................................................................................. 10
A noção de controle ............................................................................................................ 10
A noção de comentário ....................................................................................................... 11
Constantes e variáveis............................................................................................................. 12
Constantes........................................................................................................................... 12
Variável................................................................................................................................ 12
Tipos de dados ........................................................................................................................ 13
Tipo int ................................................................................................................................ 13
Tipo double.......................................................................................................................... 14
Tipo boll ............................................................................................................................... 14
Tipo string............................................................................................................................ 14
Tipo color............................................................................................................................. 15
Tipo datetime ...................................................................................................................... 17
Operações e Expressões.......................................................................................................... 17
As noções de operando, operação, símbolo de operação e expressão .............................. 17
Tipos de operações ............................................................................................................. 18
Operadores.............................................................................................................................. 21
Tipos de operadores............................................................................................................ 21
Funções ................................................................................................................................... 22
Tipos de programas ................................................................................................................. 24
Meta Editor ................................................................................................................................. 26
Sistema de arquivo .................................................................................................................. 26
Criando e usando programas .................................................................................................. 27
Programa em MQL4 .................................................................................................................. 34
Estrutura do programa em MQL4 ........................................................................................... 34
Ambiente de Desenvolvimento do MT4 ................................................................................. 36
Estrutura do programa ............................................................................................................ 36
Parte do cabeçalho .............................................................................................................. 37
2
Funções especiais ................................................................................................................ 37
Funções definidas pelo usuário ........................................................................................... 40
Funções padrão ................................................................................................................... 41
Seqüência de execução do código ...................................................................................... 43
Execução do programa ........................................................................................................ 46
Operadores ................................................................................................................................ 55
Operador de Atribuição .......................................................................................................... 55
Operador condicional 'if - else' ............................................................................................... 57
Exemplo 1 ............................................................................................................................ 58
Exemplo 2 ............................................................................................................................ 59
Exemplo 3 ............................................................................................................................ 61
Exemplo 4 ............................................................................................................................ 62
Exemplo 5 ............................................................................................................................ 64
Operador while e for ............................................................................................................... 65
Operador while ................................................................................................................... 65
Operador for........................................................................................................................ 69
Operador break ....................................................................................................................... 72
Operador Continue ................................................................................................................. 75
Operador switch ...................................................................................................................... 77
Chamada de função ................................................................................................................ 81
Variáveis ...................................................................................................................................... 84
Variáveis predefinidas e função RefreshRates() ..................................................................... 84
Lista de Nomes Predefinidos Simples de Variáveis ................................................................. 84
Lista de nomes predefinidos de matrizes-Timeseries ............................................................. 84
Propriedades de variáveis pré-definidas ................................................................................. 84
Função RefreshRates () ........................................................................................................... 87
Tipos de Variáveis.................................................................................................................... 89
Variáveis locais e globais ..................................................................................................... 89
Variáveis estáticas ............................................................................................................... 90
Variáveis externas ............................................................................................................... 91
GlobalVariables ................................................................................................................... 93
Matrizes............................................................................................................................. 100
Programação prática em MQL4 ............................................................................................ 112
Programação de Operações Comerciais ............................................................................... 112
3
Maneira comum de começar ............................................................................................ 112
Características e Regras de Ordem para Fazer Negócios .................................................. 118
4
Introdução
Um Expert Advisor (EA) pode trabalhar 24 horas por dia, 7 dias por semana, sem qualquer
intervenção - acompanhar os preços com segurança, e enviar mensagens eletrônicas, para o
seu celular, bem como fazer muitas outras coisas úteis.
5
Introdução à programação MQL4
Antes de começar a estudar a programação MQL4, vamos definir o escopo do nosso estudo. Em
primeiro lugar, deve-se notar que os programas discutidos neste livro podem ser usados apenas
como aplicativos para trabalhar no MetaTrader 4 Client Terminal. A ilustração a seguir
mostra o papel desses programas na gestão das negociações. Vejamos a ilustração.
Se você estiver interessado em programação MQL4, você já deve ter se familiarizado com o
terminal MetraTrader 4. O terminal do cliente (Metatrader 4) é uma parte do sistema de
comércio on-line. Este sistema de comércio on-line também inclui um servidor instalado em um
centro de negociação. O centro de negociação está conectado com outros participantes do
mercado, como bancos e instituições financeiras.
6
Controles do MetaTrader 4
O terminal cliente contém ferramentas internas que lhe permitem realizar análises técnicas do
mercado e executar a gestão comercial manual. Para análise de mercado, você pode usar
indicadores técnicos e vários estudos de linha de suporte / linhas de resistência, canais de
tendência, níveis de Fibonacci e assim por diante.
A Figura 1 mostra que os programas em MQL4 tem os mesmos meios de acesso ao ambiente
informacional do terminal do cliente utilizado nas negociações manuais (setas azuis).
Programas em MQL4 pode influenciar diretamente na gestão da sua conta de negociação (setas
vermelhas).
Programas de diferentes tipos podem ser usados simultaneamente e podem trocar dados entre
eles. Usando essas aplicações, um programador pode automatizar uma grande parte das
operações de negociação, ou criar um robô que irá negociar sem a interferência humana.
7
O servidor só processará sinais provenientes de um terminal cliente. Se um terminal cliente
estiver desconectado da Internet ou se um programa aplicativo (Expert Advisor ou script)
executado nele não gerar nenhuma ação de gerenciamento, nada acontecerá no servidor.
OBS: Os programas para negociação automatizada têm muito mais usos potenciais do que as
ferramentas manuais de gerenciamento comercial.
Também pode ajudar a aliviar a tensão nervosa e a diminuir o número de erros que aparecem
em períodos de extrema tensão emocional. Mas, o principal é que o uso do método do
programa de gestão do comércio permite que os comerciantes desenvolvam suas próprias
idéias e testá-los em dados históricos, selecionar parâmetros ótimos para aplicar essas idéias e,
finalmente, implementar uma estratégia de negociação pensada.
8
Noções básicas de MQL4
Termos básicos são descritos, tais como tick (a mudança de preço), controle de
algoritmos, e comentário em programas.
O principal evento quando a negociação em mercados financeiros é a mudança
de preço. É por isso que tick é um evento importante que faz com que os
mecanismos básicos dos programas MQL4 sejam executados.
O que acontece quando um novo tick entra?
Que ações o terminal deve tomar?
Veremos mais sobre o assunto, neste E-book.
2. Constantes e variáveis
3. Tipos de dados
4. Operações e expressões As
5. Operadores
9
6. Funções
A necessidade de criar funções nos leva ao termo função . Para usar a função de
diferentes localizações no programa, é necessário fornecer-lhe parâmetros
de função . Vamos considerar o processo para criar uma função
personalizada. Exemplos de utilização de funções padrão são fornecidos.
7. Tipos de
A noção de um tick
Um tick é um evento que é caracterizado por um novo preço do símbolo em algum instante.
Os Ticks são entregues a cada terminal do cliente por um servidor que está instalado em um
centro de negociação. Conforme a situação atual do mercado, os Ticks são atualizados sempre
que houver mudança nos preços, e podem ser recebidos mais ou menos freqüentemente, mas
cada um deles traz uma nova cotação de preço.
Por exemplo, um Expert Advisor (EA) não fica funcionando o tempo todo. Um EA é ativado no
momento que cada tick é recebido pelo terminal cliente. Por esta razão, não caracterizamos tick
como apenas uma nova cotação, mas como um evento a ser processado pelo terminal cliente.
A duração da operação de uma EA depende do que foi programado para ele fazer. Normal EAs
completar um ciclo de processamento de informações durante alguns décimos ou centésimos
de segundo. Dentro deste período, o EA pode ter processado alguns parâmetros, feito uma
decisão de negociação, desde o comerciante com algumas informações úteis e assim por
diante. Tendo terminado esta parte do seu trabalho, a EA vai para o modo de espera até um
novo Tick ser recebido pelo Terminal Cliente. Este novo tick lança o EA novamente, o programa
faz as operações apropriadas novamente e retorna ao modo de espera. A descrição detalhada
de como o aparecimento de um novo tick influencia a operação do programa segue a seguir.
A noção de controle
10
Controle é o termo usado para falar sobre o fluxo de execução de código dentro de um
programa, bem como o fluxo entre o programa e o terminal do cliente.
Antes de iniciar o EA, o controle está sob a supervisão do terminal cliente. Uma vez que o EA é
iniciado e um novo Tick é recebido, o terminal cliente transfere o controle para o EA. O código
do programa começa a ser executado neste momento.
O terminal cliente, depois de ter transferido o controle para o programa, não interrompe sua
operação. Ele continua trabalhando com o desempenho máximo durante todo o período de
tempo em que é iniciado no PC. O programa só pode começar a operar no momento em que o
terminal cliente transferiu o controle para ele.
A noção de comentário
Um comentário é uma parte opcional e não executável de um programa que explica o código.
Portanto, o comentário é uma parte opcional de um programa. Isso significa que um programa
pronto funcionará de acordo com seu código, independentemente de haver comentários ou
não.
11
Constantes e variáveis
Constantes
Exemplos:
A raça humana descobriu constantes naturais, universais, cujos valores não dependem de nós
de modo algum. Por exemplo, em física, a aceleração de queda livre é sempre igual a
9,8 m / s / s ;
Em matemática, Pi = 3,14.
Variável
12
Veja o Exemplo de uma Variável.
Tipos de dados
Acima falamos de constantes e variáveis, agora vou mostrar para vocês os tipos de dados
utilizados na hora de declarar uma variável em MQL4.
Tipo int
13
Os valores de tipo Int são inteiros, também conhecidos como números inteiros. Esse tipo inclui
valores que são inteiros por sua natureza.
Tipo double
As variáveis do tipo double são números reais que contêm uma parte fracionária.
Os valores de exemplo deste tipo podem ser quaisquer valores que tenham uma parte
fracionária.
Tipo boll
Os valores de um tipo bool são valores de tipo booleano (lógico) que contêm falsidade ou
verdade. Essas variáveis podem receber valores como True e False ou 1 e 0 veja o
exemplo:
Tipo string
Valores de um tipo string são aqueles representados como um conjunto de caracteres ASCII.
14
string Prefix = "MetaTrader 4" ; // Exemplo variável string
string Postfix = "_of_my_progr. OK" ; // Exemplo variável string
string Name_Mass = "Histórico" ; // Exemplo variável string
string text = "Linha Superior \nLinha Baixa" ; // o texto contém caracteres
de alimentação de linha
Tipo color
O significado de "cor" (azul, vermelho, branco, amarelo, verde e assim por diante) é de
conhecimento comum. É fácil imaginar o que uma variável ou uma constante do tipo de color
pode significar. É uma constante ou uma variável, cujo valor é uma cor. Pode parecer um pouco
incomum, mas é muito simples, geralmente falando. Como o valor de uma constante de
número inteiro é um número, o valor de uma constante de cor é uma cor.
Os valores de constantes e variáveis de cores podem ser representados como um dos três tipos:
literais, representações inteiras e nomes de cores.
Literais
O valor do tipo de cor representado como um literal consiste em três partes que representam os
valores numéricos da intensidade de três cores básicas: vermelho, verde e azul (RGB). O valor
deste tipo começa com 'C' e é citado por aspas simples.
Os valores numéricos da intensidade RGB variam de 0 a 255, e podem ser gravados decimal e
hexadecimal.
Representação de inteiro
Representação dos valores de tipo de cor como inteiros e como hexadecimais literais é muito
amigável. A maioria dos editores modernos de texto e gráficos fornece informações sobre a
intensidade dos componentes vermelho, verde e azul no valor selecionado de cor. Basta
selecionar uma cor em seu editor e copiar os valores encontrados em sua descrição para a
representação do valor de cor correspondente em seu código.
Em MQL4 A maneira mais fácil de definir uma cor é especificar seu nome de acordo com a
tabela de cores. Neste caso, o valor de uma cor é representado como uma palavra
correspondente à cor, por exemplo, Vermelho representa a cor vermelha. Veja a tabela:
15
16
Tipo datetime
Valores desse tipo podem ser usados em programas para analisar o momento de início ou
término de alguns eventos, por exemplo, a liberação de notícias importantes, início / fim do dia
de trabalho e assim por diante. As constantes de data e hora podem ser representadas como
uma linha literal composta de seis partes que representam os valores numéricos de ano, mês,
dia (ou dia, mês, ano), hora, minuto e segundo.
A constante começa com "D" e é enquadrada em aspas simples. Você também pode usar
valores truncados sem data, ou sem tempo, ou apenas como um valor vazio. O intervalo de
valores é de 1 de janeiro de 1970 até 31 de dezembro de 2037. Os valores de constantes e
variáveis de tipo de data e hora tomam 4 bytes na memória do computador. Um valor
representa a quantidade de segundos decorridos desde 00:00 de 1 de janeiro de 1970.
Aqui estão alguns exemplos de como usar uma variável do tipo datetime em um programa.
Operações e Expressões
Para entender o significado de operações e expressões em MQL4, não são necessárias
analogias especiais. Praticamente, é o mesmo que operações e expressões na aritmética
simples. Todo mundo entende que no registro f = n + m , membros f , n , e m são variáveis,
sinais = e + são sinais operacionais e n + m é uma expressão.
Operando é uma constante, uma variável, um componente de matriz ou um valor retornado por
uma função. (As funções são consideradas na seção sobre as funções , as matrizes são
consideradas na seção sobre arrays , neste estágio atual de aprendizagem, é suficiente para
entender os operandos como constantes e variáveis que já estudamos).
17
Um símbolo de operação é um caractere predefinido ou grupo de caracteres que ordenam
executar uma operação.
Tipos de operações
Aritmética
Atribuição
Relacional
Boolean
Bit a bit
Comma
Chamada de função
Operações são usadas em operadores (ver Operadores ). Somente em operadores faz seu uso
faz sentido e é realizado em um programa. A possibilidade de utilizar uma operação é
determinada pelas propriedades dos operadores; Se as propriedades do operador permitem que
você utilize esta operação específica, você pode usá-la; Caso contrário, você não deve usar esta
operação. É proibido o uso de operações fora dos operadores.
Operações aritméticas
Os seguintes símbolos são exemplos de operação aritmética.
Operações de atribuição
Os seguintes símbolos são exemplos de operação de atribuição.
18
Operações relacionais
Os símbolos a seguir são exemplos de operação relacional.
Operações bit a bit só podem ser executadas com inteiros. As operações a seguir são operações
bit a bit.
B = ~n;
19
A representação binária de x é deslocada por y lugares para a direita. Esse deslocamento para
a direita é lógico; Isso significa que todos os lugares esvaziados à esquerda serão preenchidos
com zeros.
X = x >> y;
X = x << y;
B = x | Y;
B = x ^ y;
As expressões separadas por vírgulas são calculadas da esquerda para a direita. Todos os
efeitos dos cálculos na expressão esquerda ocorrem antes da expressão direita ser calculada. O
tipo e o valor do resultado coincidem com o tipo e valor da expressão direita.
My_function (Alf, Bet, Gam, Del) // Calling for a function with arguments
Chamada de função
Uma chamada de função pode ser usada como um operador separado e ser encontrada em
qualquer lugar em um programa onde implique um determinado valor (com exceção de casos
predefinidos). O formato e as regras de execução de uma chamada de função abrangem
funções padrão (built-in) e definidas pelo usuário.
20
Uma chamada de função consiste no nome da função e na lista dos parâmetros passados entre
parênteses:
Operadores
Tipos de operadores
Operadores simples
Operadores simples em MQL4 terminam com o caractere ";" (ponto e vírgula). Usando este
separador, o PC pode detectar onde um operador termina e outro começa. Um ponto e vírgula
é tão necessário em um programa como um espaço vazio é necessário em um texto normal
para separar frases. Um operador pode tomar várias linhas. Vários operadores podem ser
colocados numa linha.
Um operador composto consiste em vários simples separados pelo caractere ";" E é fechado em
chaves. Para poder usar vários operadores onde apenas se espera encontrar um deles, os
programadores usam um operador composto (também o chamam de "bloco" ou "bloco de
código"). A lista de operadores em um composto é separada por chaves. A presença de uma
chave de fecho marca o fim de um operador composto.
Aqui está uma utilização exemplar de um operador composto. Ele começa com o operador
condicional if (expressão) seguido por um composto. O operador composto contém uma lista de
operadores executáveis.
21
Funções
O avanço tecnológico mais importante na engenharia de computadores é a possibilidade de
criação e armazenamento de fragmentos de código separados que descrevem as regras de
processamento de dados para resolver um problema ou completar uma pequena tarefa. Tal
possibilidade também existe em MQL4.
Uma função é uma parte específica nomeada de um programa que descreve um método a ser
executado.
Vamos considerar dois aspectos das funções: descrições de função e chamadas de função.
Uma chamada de função (ou, referência de função) é um registro, cuja execução resulta na
execução da função a que se refere.
Em nossa vida cotidiana, podemos encontrar muitas funções analógicas. Tomemos, por
exemplo, o sistema de frenagem de um carro. O mecanismo de atuação que realiza
corretamente a frenagem, bem como a idéia implementada pelo engenheiro, é como uma
função, enquanto que o pedal do freio é como uma chamada da função. O motorista pressiona
o pedal para baixo, e os mecanismos de atuação executa algumas ações até parar o carro.
22
A maioria do código em MQL4 é escrito na forma de funções. Esta abordagem tornou-se
generalizada e é um padrão agora.
Outro exemplo de função, onde parte dos cálculos é composto como uma função. O código
básico contém uma chamada de função definida pelo usuário. A descrição da função definida
pelo usuário está localizada depois do código básico.
23
Veja como é a escrita de uma função:
Isso resume no que é uma função, o que vai diferenciar uma função de outra é a parte da
funcionalidade, a parte de estrutura é igual.
Tipos de programas
Ao começar a escrever um programa em MQL4, você deve, em primeiro lugar, responder à
pergunta sobre o tipo de programas que será. O conteúdo e a funcionalidade do programa
24
dependem totalmente disso. Em MQL4, existem três tipos de programas de aplicação: EAs,
scripts e indicadores personalizados. Qualquer programa que você desenvolver irá
pertencer a um destes tipos. Todos eles têm seus propósitos e características especiais.
Um Expert Advisor (EA) é um programa codificado em MQL4 e chamado pelo terminal cliente
para ser executado em cada tick. O objetivo principal dos EAs é o controle programado sobre
os comércios. Os EAs são codificados pelos usuários. Não existem EAs incorporados no
terminal do cliente.
O script é um programa codificado em MQL4 e executado pelo terminal cliente apenas uma
vez. Scripts são destinados a executar operações que devem ser executadas apenas uma
vez. Os scripts são codificados pelos usuários. Eles não são entregues com o terminal do
cliente como programas internos.
Você escolhe o tipo de programa a ser criado, isso vai depender da finalidade do programa
específico e das propriedades e limitações dos diferentes tipos de programas.
É importante ressaltar que se tratando de EAs, você pode anexar apenas 1 EA por janela
Gráfica.
25
Meta Editor
Nesta seção, vamos nos debruçar sobre a ordem geral de criação de programas em MQL4
usando o MetaEditor.
Sistema de arquivo
O terminal cliente reconhece os tipos de programas pela sua localização em diretórios
separados.
Todos os programas de aplicação estão concentrados no diretório ClientTerminal_folder\
experts.
EAs, scripts e indicadores personalizados que você vai usar diariamente devem estar localizados
em diretórios correspondentes, como mostrado na Figura abaixo a seguir.
ClientTerminal_folder\experts\scripts
ClientTerminal_folder\experts\indicadores.
26
Criando e usando programas
27
Os programas escritos em MQL4, EAs, scripts e indicadores, são criados usando o MetaEditor.
Após todas essas ações, o "Assistente de EA" oferece uma lista de tipos de programas a serem
criados.
28
Se você precisa criar um EA, marque EA e clique em Avançar . Na próxima janela é necessário
indicar o nome do EA a ser criado. Suponha que ele é chamado de EAFXTRADE_V01.mq4.
Depois de clicar em Avançar, você será direcionado para próxima tela, manipuladores de
eventos do Expert Advisor.
29
Você não precisa marcar nada nesta tela, pois as configurações faremos diretamente no código.
Agora você será levado para próxima tela Testador de Manipuladores de Eventos.
Veja que o arquivo EAFXTRADE_V01.mq4 esta aberto no MetaEditor veja a figura abaixo:
30
Você vê, o código contém principalmente comentários. Já sabemos que os comentários
constituem uma parte não obrigatória de um programa e o texto dos comentários não é
processado pelo programa.
O código de programa gerado pelo EA Wizard é apenas um padrão, usando o qual você pode
criar um novo programa. O código final do programa não contém obrigatoriamente todas as
funções especiais indicadas. Eles estão presentes apenas no padrão, porque, como regra geral,
um programa médio contém todas essas funções. Se alguma das funções não for usada, sua
descrição pode ser apagada.
OnInit(), responsável em inicializar o EA, usamos essa função para carregar variáveis, obter
todas informações necessárias para o EA começar a trabalhar.
OnTick(), essa função ela é chamada sempre que o MetaTrader, recebe uma nova cotação de
preço(Tick) de um determinado comercio. Aqui é onde o robô vai executar tudo que você
programou nele.
31
OnDenit(), responsável em liberar todas as variáveis e funções utilizadas durante o
processamento do EA. Essa função é chamada sempre que o EA é desligado.
Compilação do programa
Para tornar um programa utilizável na prática, ele deve ser compilado.
Para isso, o botão (F5) no MetaEditor deve ser usado. Se um programa não
contiver quaisquer erros, ele é compilado e a seguinte mensagem ocorre na caixa de
ferramentas.
Outra coisa que acontece quando um programa é compilado é que uma linha com o nome do
EA criado aparecerá na pasta EAs da janela do navegador do terminal do cliente.
32
corrigir os erros e tentar compilar o programa novamente. Uma compilação de programas bem-
sucedida é possível somente se não houver erros no programa.
Se um programa aplicativo (EA, script ou indicador) tiver sido compilado com êxito e seu nome
tiver aparecido na janela do navegador do terminal do cliente, ele poderá ser usado na prática.
Para utilizar o EA, basta usar o (método "arrastar e soltar"). Isso significa que o programa será
anexado a um gráfico que você desejar. E estará pronto para execução.
Mostrarei detalhes mais a frente, quando estivermos concluído o desenvolvimento do nosso EA.
33
Programa em MQL4
Deve ser observado desde o início que qualquer pessoa pode programar em MQL4, embora ele
requer atenção e certo conhecimento.
No entanto, antes de dirigir um carro em ruas movimentadas, cada motorista tem que passar
por treinamento. Algo como isso deve ser feito por um programador de partida, aprender
alguns princípios simples é a base para criar programas, e depois disso, lentamente começando
a aprofundar no seu desenvolvimento.
As propriedades das funções especiais são descritas em detalhe em Funções especiais. Aqui,
estudamos apenas as principais informações sobre eles. Uma função especial é uma função
chamada e executada pelo terminal cliente. Distintas de funções comuns, funções especiais só
têm uma descrição, e funções especiais não são chamadas de dentro de um programa. Funções
especiais são chamadas para serem executadas pelo terminal cliente. (Há uma possibilidade
técnica de chamar funções especiais de dentro de um programa, mas vamos considerar este
método incorreto e não discuti-lo aqui.) Quando um programa é iniciado para execução em
uma janela de segurança, o terminal cliente passa controle para uma das funções
especiais. Como resultado, esta função é executada.
Isso significa que as linhas de programa que estão fora das funções especiais não podem ser
executadas. Na tentativa de compilar esse programa, o MetaEditor mostrará a mensagem de
34
erro correspondente e o arquivo executável * .exe não aparecerá como resultado da
compilação.
35
Ambiente de Desenvolvimento do MT4
O ambiente de desenvolvimento (informação do MT4) não é um componente do programa. O
ambiente de informação é um conjunto de parâmetros disponíveis para serem processados por
um programa. Por exemplo, é o preço de segurança que vem com um novo tick, o volume
acumulado em cada novo tick, a informação sobre os preços máximos e mínimos das barras de
histórico, os parâmetros que caracterizam as condições de negociação oferecidas por um centro
de negociação e assim por diante. O ambiente de informação é sempre guardado e, a cada
nova marca, que é atualizado pelo terminal do cliente ligado ao servidor.
Estrutura do programa
36
Parte do cabeçalho
A parte do cabeçalho consiste das primeiras linhas no início de um programa, que contêm
informações gerais sobre o programa. Por exemplo, esta parte inclui linhas de declaração e
inicialização de variáveis globais. (A necessidade de incluir essa ou aquela informação na parte
do cabeçalho será discutido mais adiante).
Veja a imagem:
Funções especiais
37
descrição de uma função especial, ela será chamada (e executada) de acordo com as condições
de chamada (e suas próprias propriedades).
Nos scripts , OnInit() também é chamado e executado imediatamente após ele ser anexado a
um gráfico.
OBS: Tick é a mudança de preço que é mostrada no Gráfico. Cada novo preço, você deve
considerar que seja um novo Tick.
Se este botão estiver desabilitado, o terminal de cliente não chamará para execução
OnTick() independentemente de novas cotações vir ou não. No entanto, alterar o estado do
botão de habilitado para desabilitado não encerra a sessão de operação atual de OnTick().
38
O processamento da função OnTick() é concluído assim que todos os comandos que estão
dentro desta função for executada. É bom lembrar que ela é executada uma única vez na
inicialização do EA, script ou Indicador Personalizado.
1-OnInit()
2-OnTick()
3-OnDeinit()
39
Funções definidas pelo usuário
As funções definidas pelo usuário geralmente são dadas após a descrição de funções
especiais. O número de funções definidas pelo usuário em um programa é ilimitado. Na Figura
anterior, nosso exemplo contém apenas uma função definida pelo usuário, mas um programa
pode conter 10 ou 500, ou nenhum. Se nenhuma função definida pelo usuário for usada em um
programa, o programa terá uma estrutura simples: a parte do cabeçalho e a as funções
especiais.
40
Funções padrão
Como mencionado anteriormente, as funções padrão podem ser apresentadas apenas como
uma chamada de função. A descrição de uma função padrão está oculta do programador e,
portanto, não pode ser alterada. No entanto, ele está disponível para o MetaEditor. Durante
a compilação do programa, o MetaEditor formará um arquivo executável, no qual todas as
funções padrão chamadas serão executadas corretamente até o máximo.
41
Com base no que foi mostrado, você entende que para um programa ser compilado e começar
a ter funcionalidades, ele vai precisar do cabeçalho, funções especiais, e funções
padrões. Funções definidas pelo usuário, vai depender da sua criatividade.
Nenhuma das funções pode ser criada dentro de outra função. É proibido.
Veja arranjos Corretos, note que a posição das funções não interfere. A única coisa que é
importante permanecer é o cabeçalho sempre no topo do código.
42
Seguem-se exemplos de arranjos incorretos para escrever funções.
Depois que as preparações descritas na parte do cabeçalho são feitas, o terminal do cliente
passa a controlar a função OnInit() especial, e essa função é executada (a passagem de
controle é mostrada no esquema estrutural em grandes setas amarelas mostrado
anteriormente). A função especial OnInit() é chamada e executada somente uma vez no início
da operação do programa. Esta função normalmente contém um código que deve ser
executado apenas uma vez antes da operação principal do programa ser iniciado.
Por exemplo, quando OnInit() é executado, algumas variáveis globais são inicializadas, objetos
gráficos são exibidos em uma janela de gráfico ou mensagens podem ser mostradas. Depois
que todas as linhas de programa em OnInit() são executadas, a função termina sua execução
e o controle é retornado ao terminal do cliente.
Terminado todo o trabalho na OnInit(), assim que é feita a recepção de um novo tick pelo
terminal cliente a partir de um servidor, o terminal cliente chama a execução de OnTick(). Esta
função (como outras funções) pode se referir ao ambiente de informações do terminal do
cliente, realizar cálculos necessários, abrir e fechar ordens e em breve. Ou seja, ele pode
executar quaisquer ações permitidas pelo MQL4.
43
Quando OnTick() é executado, geralmente é produzida uma solução que é implementada
como uma ação de controle (veja as setas vermelhas na Figura anterior). Este controle pode ser
implementado como uma solicitação de negociação para abrir, fechar ou modificar uma ordem
formada pelo programa.
Depois que todo o código da função OnTick() especial do EA é executado, OnTick() termina
sua operação e retorna o controle para o terminal do cliente. O terminal segura o controle por
algum tempo, não começando nenhuma função especial. Aparece uma pausa durante a qual o
programa não funciona. Mais tarde, quando um novo sinal vem, o terminal cliente passa o
controle para OnTick() novamente, e como resultado, a função é executada novamente.
44
Veja a imagem novamente:
As funções definidas pelo usuário são executadas quando uma chamada para essa função está
contida em alguma outra função. Neste caso, o controle é passado oportunamente para a
função definida pelo usuário e, após a execução da função, o controle é retornado ao local da
chamada (veja as flechas finas de laranja na Figura acima). A chamada de funções definidas
pelo usuário pode ser contida não somente na descrição de uma função especial, mas também
na descrição de outras funções definidas pelo usuário. Uma função definida pelo usuário pode
chamar outras funções definidas pelo usuário. Isso é amplamente utilizado na programação.
As funções definidas pelo usuário não são chamadas para execução pelo terminal
cliente. Quaisquer funções definidas pelo usuário são executadas dentro da execução de uma
função especial que retorna o controle para o terminal do cliente. As funções definidas pelo
usuário também podem solicitar para usar os valores das variáveis do ambiente de informação
do terminal do cliente (veja as finas setas azuis na Figura acima).
45
Se um programa contém uma função definida pelo usuário, mas não há chamada dessa função,
essa função definida pelo usuário será excluída do programa pronto na fase de compilação e
não será usada no funcionamento do programa.
Execução do programa
Exemplo de um EA simples:
46
Temos as declarações padrões como as #property e a variável Global int Count=0;
Nesta linha, a variável global Count é declarada e inicializada com um valor de zero.
2.1 Function Alert() mostra uma janela de alerta: Acionada no inicio que o EA é ligado a um
Gráfico.
Como resultado da execução OnInit(), um alerta será gravado. A finalidade aqui é mostrar um
EA simple, em EAs mais complexos, vai ser raro encontrar um Alert() na função OnInit().
Note que na função OnTick(), temos uma variável Price do tipo double, inicializada com o
preço de compra.
Temos também a variável global sendo incrementada com o sinal (++) que é a mesma coisa de
(Count=Count+1).
47
Em seguida temos a função padrão Alert() mostrando a variável Count e o novo Preço de
cotação.
Lembrando que a função OnTick() será acionada somente quando um novo Tick ocorrer.
A partir deste exemplo, você pode facilmente ver que um programa é executado de acordo com
as funções especiais e funções descritas dentro das funções especiais.
Terminar o programa, e iniciá-lo novamente. Tendo feito isso várias vezes, você terá
experiência usando seu primeiro programa. Vai funcionar tanto agora como da próxima
vez. Outros programas que você escreverá também serão construídos de acordo com a
estrutura descrita e, para iniciar sua execução, você também precisará anexá-la a um gráfico.
48
Como regra são as mesmas, não vou descrever todos os passos novamente, os programas a
seguir segue o mesmo padrão nas sequência em que são chamadas para execução pelo
terminal cliente.
49
Como disse anteriormente, não vou explicar novamente cada função, pois utilizamos as
mesmas funções do EA anterior.
Para que seja possível o envio de e-mail pela plataforma ou pelo programa em
MQL4, você precisa fazer os seguintes passos a seguir:
1. Acesse o MataTrader4
2. Clique no Menu Ferramentas e na sequencia clique em Opções.
3. Clique na aba E-mail
4. Preencha os dados na tela a seguir:
50
Clique em OK e depois feche a tela de opções clicando em OK.
Você consultara se o teste de envio de e-mail deu certo, consultado em Terminal na aba diário.
Veja a imagem:
Aqui não iremos explicar novamente o uso das funções OnInit(), OnTick() e OnDeinit()
Vamos mostrar como é feito todo processo para envio das notificações.
Veja que o código abaixo esta fazendo exatamente o proposto nesse título, Enviamos 3
notificações utilizando a função SendNotification().
51
1.Primeira notificação é feita na função OnInit().
52
Veja que recebemos os 3 notificações no Celular conforme era planejado no código.
Para que seja possível o envio de Notificações pela plataforma ou pelo programa em
MQL4, você precisa fazer os seguintes passos a seguir:
1. Acesse o MataTrader4
2. Clique no Menu Ferramentas e na sequencia clique em Opções.
3. Clique na aba Notificações
4. Preencha os dados na tela a seguir:
53
Preencha os dados Habilitar notificações via Push e Notificar Operações de
negociação. Informe o campo MetaQuotes ID: e clique em testar, depois novamente clique
em OK.
Para obter o MetaQuotes ID, você deve ter instalado o MetaTrader 4 no seu Celular Android
ou iPhone. Após instalado o Metatrader 4 você deve clicar no link MQID no topo da aplicação
no celular.
Após te o MetaQuotes ID, digite esse numero no seu MetaTrader 4 e clique em OK.
Pronto, é bem simples, esse tipo de notificação serve tanto para EAs simples ou EAs complexos.
54
Operadores
Esta seção trata das regras de formatação e execução dos operadores usados no MQL4. Cada
seção inclui exemplos simples que demonstram a execução dos operadores. Para digerir o
material na íntegra, recomenda-se a criação real de um código e a compilação para que seja
visto na pratica a execução de todos exemplos. Isso também irá ajudá-lo a consolidar
habilidades em trabalhar com o MetaEditor.
Operador de Atribuição
O operador de atribuição é o operador mais simples e mais utilizado.
Variável = Expressão ;
Você pode distinguir o operador de atribuição de outras linhas no texto do programa pela
presença do sinal de igualdade. Você pode especificar como uma expressão: uma constante,
uma variável, uma chamada de função ou uma expressão como tal.
O operador de atribuição, como qualquer outro operador, é executável. Isso significa que o
registro que compõe o operador de atribuição é executado de acordo com a regra. Ao executar
o operador, o valor da parte direita é calculado e então atribuído à variável à esquerda do sinal
de igualdade. Como resultado da execução do operador de atribuição, a variável na parte
esquerda sempre toma um novo valor; Esse valor pode ser diferente ou igual ao valor anterior
da variável. A expressão na parte direita do operador de atribuição é calculada de acordo com a
ordem das operações.
55
Em um operador de atribuição, o tipo de uma variável não é permitido ser declarado na
parte direita do sinal de igualdade:
Exemplos de utilização das funções definidas pelo usuário e padrão na parte direita:
56
Operador condicional 'if - else'
Como regra, se você escrever um programa aplicativo, você precisa codificar várias soluções em
um programa. Para resolver essas tarefas, você pode usar o operador condicional 'if-else' em
seu código.
O operador de formato completo «if-else» contém um cabeçalho que inclui uma condição, e o
corpo 1, a palavra-chave «else» e o corpo 2. Os corpos do operador podem consistir em um ou
vários operadores; Os corpos são fechados em chaves.
57
If(Condição) // Cabeçalho do operador e condição
{
corpo 1 dos operadores // Se a condição for verdadeira, então ...
os operadores que compõem o corpo 1 são executados
}
else // Se a primeira condição não for atendida
{
Corpo 2 dos operadores são executados;
}
Exemplo 1
Este é um exemplo simples, vou mostrar em código alguns exemplo do Operador if-else
58
Exemplo 2
Vou mostrar outro exemplo de if-else
Para que a condição a cima seja verdadeira então a parte em verde da expressão tem que ser
verdadeira e a parte cinza também tem que ser verdadeira. Em resumo, dentro desta condição
esta sendo feito 2 testes e os dois tem que ser verdadeiros para que o programa passe pelo
BLOCO 1. E esse mesmo processo se repete na condição 2.
Primeiro temos um if para resolver o BLOCO 1 e no else temos outro if para resolver o
BLOCO 2.
59
Significa que para executar o BLOCO 1, a condição 1 deve ser atendida. Caso a condição 1
não seja atendida, o programa passara pela condição 2.
Neste exemplo o BLOCO 1 ou o BLOCO 2 só serão executados se uma das condições forem
atendida.
60
Exemplo 3
A diferença deste exemplo, com o exemplo 2, é que utilizamos um if-else de forma um pouco
diferente.
Primeiro temos um if para resolver o BLOCO 1 e no else BLOCO 2 temos outro if para ser
executado.
Significa que para executar o BLOCO 1, a condição 1 deve ser atendida. Caso a condição 1
não seja atendida, o programa passara para o BLOCO 2.
Neste exemplo o BLOCO 1 só será executado se a condição 1 for atendida, caso contrario o
programa passara pelo BLOCO 2.
É importante mostrar esse tipo de exemplo, para que você veja a variedade de formas que será
possível de ser criada com o operador if-else
61
Veja o programa EAFXTRADE_V07. Execute o no seu computador e veja o resultado.
Exemplo 4
Vamos um exemplo um pouco mais complexo, onde usaremos if-else dentro de outro if-else
Dentro desta função criamos o primeiro if-else, onde é testado se eu quero comprar ou
vender.
Exemplo: analise_tendencia_MEDIA_200_72(OP_BUY)
62
Significa que nesse caso a condição 1 não seria atendida, então a execução do programa
passaria para testar a condição 2 sendo que ela é justamente a condição que eu solicitei.
Assim que a execução entra no BLOCO 2, um novo if esta para testar uma nova condição.
Se o candle anterior abriu com o preço menor que o preço da media 200 e se o candle anterior
teve o preço de fechamento maior que o preço da media 200, então a função retorna
verdadeiro. Isso significa que o alerta “Alert("Sinal de Compra", "Veja Possibilidade de
Compra");” vai ser acionado. Devido o retorno da função analise_tendencia_MEDIA_200_72 ter
retornado verdadeiro para um sinal de compra
63
Veja o programa EAFXTRADE_V08. Execute o no seu computador e veja o resultado.
Exemplo 5
Aqui vou simplesmente mostrar uma imagem de uma função utilizada por um de meus robôs,
ela é responsável em abrir ordens de compra e de venda.
Estou mostrando ela, para que você veja o nível de desenvolvimento que irei ensinar a vocês
mais a frente.
Veja imagem:
64
Note que fazemos analise de medias, analise de suporte e resistência e outras analises.
Ao criar programas de aplicação, você pode frequentemente usar os cálculos repetidos, que são
na maior parte as linhas repetidas do programa. Para tornar a programação confortável e o
programa em si fácil de usar, usamos operadores de ciclo. Existem dois operadores de ciclo em
MQL4: While e for. Consideraremos o primeiro nesta seção.
Operador while
O operador while consiste no cabeçalho que contém uma condição e o corpo do ciclo
executável encerrado entre chaves.
65
Código disponível no programa EAFXTRADE_V09
Esse programa faz algo bem simples, ele simplesmente mostra um alerta 10 vezes, pois foi o
tanto de vezes que eu estipulei para o while ficar no ciclo.
Significa que enquanto a variável contador for menor ou igual a 10, ele vai repetir o processo
novamente.
A estrutura básica do while é essa, o que pode mudar é a condição que pode ser ou não mais
complexa e a codificação dentro do loop.
While ele vai ser muito utilizado em nossos EAs, pois podemos percorrer períodos no gráfico
atrás de topos e fundos, cálculo de preços, e outras analises. Portanto é bom treinar bastante
essa parte.
A função dos Loops na programação é facilitar o acesso a dados e cálculos, note que com
pouco mais de 6 linhas o while resolveu uma conta complexa.
66
Veja o código no programa EAFXTRADE_V10
67
Deve ser particularmente observado o seguinte:
Uma vez que ocorre um loop, o programa executa indefinidamente o bloco de operadores que
compõem o corpo do ciclo.
Abaixo está um exemplo simples de um operador de ciclo em loop 'while' que você nunca
deve fazer:
Como resultado, a condição nunca se tornará falsa. Uma situação semelhante ocorre, se nada é
calculado no corpo do ciclo em tudo. Por exemplo, no seguinte código:
68
Em ambos os casos acima, este processo se repetirá sem parar. Depois de ter entrado na
armadilha de um código em loop, o controle não pode deixá-lo mais. Esta situação é
particularmente perigosa na negociação Expert Advisors e scripts. Em tais casos, as
variáveis de ambiente geralmente não são atualizadas, uma vez que a função especial não
completa sua operação, enquanto o comerciante pode não ter conhecimento do loop
existente. Como resultado, o controlo no programa de execução não pode ser passado para as
linhas de programas correspondentes onde é tomada a decisão de abrir ou fechar ordens.
O programador deve evitar tais condições, nas quais um loop não controlado torna-se
possível. Não há nenhuma técnica que ajudaria a descobrir esta situação, nem na compilação
do programa nem na sua execução. O único método possível para detectar tais erros
algorítmicos é exame atento de seu código - raciocínio lógico e senso comum.
Operador for
O operador de ciclo de formato completo 'for' consiste no cabeçalho que contém Expressão 1,
Condição e Expressão 2 e do corpo do ciclo executável incluído entre chaves.
Note que as variáveis Nom_1 = 1 e Nom_2 =10, neste caso ele fara a somatória de 1 a 10.
Depois quero que você teste mudando Nom_1 = 20 e Nom_2 = 38 e veja o resultado.
69
Veja que o for possibilita percorrer 2,10,100,1000... números com o mesmo código.
Para testar outros valores, basta você acessar o programa EAFXTRADE_V11 e mudar os valores
das variáveis Nom_1 e Nom_2.
Vou mostrar um outro exemplo, onde é feito o mesmo calculo, porem de traz para frente.
70
Veja o código no programa EAFXTRADE_V12
Próximo exemplo eu mostro a você como ler o histórico de ordens que você já negociou.
Veja:
71
Acesse o programa EAFXTRADE_13, faça o teste no seu computador para você ver o resultado.
Os exemplos mostrados acima é para mostrar varias formas de utilizar o operador for.
É muito importante que você treine escreva códigos pequenos, com as funções já ensinadas
até agora.
Caso tenha duvida, não deixe de acessar os códigos disponíveis neste curso, garanto que vai te
ajudar muito.
Operador break
Em alguns casos, por exemplo, ao programar algumas operações de Loop, pode ser necessário
quebrar a execução de um Loop antes que sua condição se torne falsa. Para resolver tais
problemas, você deve usar o operador break.
72
O operador "break" consiste em apenas uma palavra e termina em caráter ";”.
Peguei uma parte do código do ultimo exemplo, e nesse caso o break é acionado caso não
tenha localizado nenhum registro.
O "break" interrompe a execução do operador externo mais próximo do tipo 'while', 'for' ou
'switch'. A execução do "break" do operador consiste em passar o controle para fora do
operador composto do tipo "while", "for" ou "switch" para o operador seguinte mais
próximo. A interrupção do operador só pode ser utilizada para interrupção da execução dos
operadores listados acima.
Vamos criar um programa onde a função dele é simplesmente contar de 1 a 100, porem
quando a execução do programa chegar em 49 ele vai parar através do break
73
Veja o programa inteiro no EAFXTRADE_V15.
74
Veja o programa inteiro no EAFXTRADE_V17.
Resumindo o Operador break, sempre será utilizado em algum tipo de situação parecido com as
situações mostrada nos exemplos acima.
Em outros casos ele pode ser a única porta de saída de um LOOP, isso significa que o LOOP só
será encerrado se certa condição acontecer e o break for acionado.
Durante o curso faremos todos os exemplos do livro e mais outros exemplos com mais
complexidade na pratica, para que você realmente entenda o uso de cada operador.
Operador Continue
75
Às vezes, quando você usa um LOOP no código como mostrado anteriormente, é necessário
encerrar o processamento da iteração atual e ir para o próximo passo sem executar os
operadores restantes que compõem o corpo do ciclo. Nesses casos, você deve usar o operador
continue.
Vamos ver o seguinte programa, onde temos 2 contas, sendo que uma das contas, tem 100
USD de saldo, enquanto a segunda conta tem 0 USD.
A função deste programa é rentabilizar o saldo da conta 1 com 1% ao dia e sempre que o saldo
da conta 1 for maior que o limite para transferência 130 USD, eu tenho que transferir 10% da
conta 1 para conta 2, até que eu consiga atingir o saldo de 100 USD na conta 2
Veja o programa:
Note que sempre que a execução chega no operador continue, o código circulado de vermelho
é ignorado, e a execução do LOOP externo continua a ser executado.
O código marcado de vermelho só será executado, quando a condição abaixo for FALSA
76
Com base no exemplo a cima, é importante você treinar, criar mais exemplo, para que você
realmente entenda o uso do operador continue.
Operador switch
Alguns programas implicam ramificação de seu algoritmo em várias variações. Em tais casos, é
muito conveniente usar o operador 'switch', especialmente se houver dezenas ou centenas de
variações, enquanto o código 'if' se torna inchado se você usar muitos operadores aninhados.
A estrutura do switch é conforme mostrado acima, o que vai poder mudar é a expressão e as
variações “case”.
77
Veja outro exemplo, porem não utiliza o break e é feito uma chamada a função;
O problema de não se utilizar o operador break, é que ele executara sempre a partir do numero
inteiro passado na expressão do operador switch.
Note que este exemplo já é um pouquinho mais complexo, pois no “case”, faço chamada a
função “verifica_valores_candle”, que na sequencia faz chamada a função
“verifica_media”. inclusive neste exemplo não utilizamos o variação 'default' no final.
Vamos ver outro exemplo onde eu optei em escrever o código dentro de cada “case”
78
Desta vez estou utilizando break, pois quero que meu alerta mostre somente o que esta sendo
passado como parâmetro no swith, que nesse caso é 1 ou 2:
79
Veja programa completo em EAFXTRADE_V21
80
Ao contrário do algoritmo realizado no programa anterior, neste, não estamos usando o
operador 'break' em cada variação 'case'. Portanto, se o valor da Expressão for igual ao valor
de uma das Constantes, todos os operadores serão executados a partir dos operadores da
correspondente variação 'case'.
Veja que usamos o 'break' do operador na última variação 'case' para outro propósito: evitar
que os operadores correspondentes à variação 'default' sejam executados. Se não houver
valor igual à Expressão, o controle será passado para o operador que corresponde ao rótulo
default.
Assim, se o valor da variável predefinida não está dentro do intervalo de valores de 1 a 10, será
mostrado a mensagem de “Número errado inserido”.
OBS: não se usa expressão booleana(true ou False) pois o retorno desses operadores são
respectivamente 1 para True e 0 para False;
Chamada de função
Uma chamada de função já fizemos em vários exemplos, e imagino que você já tenha
ambientado com esse procedimento.
Basicamente uma chamada de função consiste no nome da função e na lista dos parâmetros
passados entre parênteses, algumas funções são somente para execução de códigos, outras
são para retorno de valores, mas a chamada sempre será da mesma forma.
Veja exemplo:
81
Outro exemplo:
Chamada de função se resume a isso, os exemplos mostrados a cima, mostra claramente como
é feito uma chamada a uma função. A diferença que vai ter de uma chamada para outra, é se a
função ter parâmetros de entrada e se a função retorna algum valor. O importante é você saber
que chamada de função sempre é feita dessa forma.
Quase todos os códigos que foram implementados neste livro, tem chama de função, é
interessante você acessar os exemplos e praticar para você entender a fundo essa parte.
Para finalizar esta parte, vou mostrar a forma de se escrever uma função, veja os dois
exemplos abaixo:
82
Exemplo 1:
Exemplo 2
83
Variáveis
Para criar programas em qualquer linguagem algorítmica saber diferentes tipos de variáveis é
muito importante. Nesta seção analisaremos todos os tipos de variáveis utilizadas no MQL4.
Variável predefinida é uma variável com um nome predefinido, cujo valor é definido por um
terminal de cliente e não pode ser alterado por métodos de programa. Variáveis predefinidas
refletem o estado de um gráfico atual no momento do início do programa (Expert Advisor,
script ou indicador personalizado) ou como resultado da implementação RefreshRates ().
Falamos Matrizes pois utilizamos “[0], [1], [2], [3], ...etc” na frete de cada variável.
84
Os valores de todas as variáveis predefinidas são atualizados automaticamente por um terminal
cliente no momento em que são iniciadas funções especiais para execução.
Os valores anteriores e atuais de variáveis predefinidas podem ser iguais, mas o próprio valor
será atualizado. No momento de uma função especial, os valores iniciais dessas variáveis já
estão atualizados e estão disponíveis nas primeiras linhas do programa.
Iniciando este programa é fácil ver que os valores da variável Bid exibidos nos alertas serão
iguais ao preço atua. Da mesma forma você pode verificar valores de outras variáveis
dependendo das condições atuais. Por exemplo, a variável Ask também depende do preço
atual. O valor da variável Bars também será alterado se o número de barras mudar. Isso pode
acontecer em uma marca, em que uma nova barra é formada em uma janela de gráfico. O
valor de Point depende de uma especificação de segurança. Por exemplo, para EUR / USD este
valor é 0.0001, para USD / JPY é 0.01. O valor dos dígitos para esses títulos é igual a 4 e 2,
respectivamente.
85
Expert Advisors diferem no momento da execução OnTick(). Para os Expert Advisors simples o
nível médio, é aproximadamente igual a 1 até 100 milissegundos. Outros Expert Advisors
podem ser executados por muito mais tempo, por exemplo, vários segundos ou dezenas de
segundos. O intervalo de tempo entre carrapatos também é diferente: de vários milissegundos
a minutos e às vezes até dezenas de minutos. Vamos analisar no exemplo dado como a
frequência do recebimento de Ticks influencia a operação do Expert Advisor 1 e do Expert
Advisor 2 que têm tempo de execução OnTick() diferente.
No instante t0 Expert Advisor 1 está ligado a um terminal cliente e muda para o modo tick-
waiting. No momento t1 um tick vem e o terminal inicia a função especial OnTick
(). Juntamente com isso, o programa obtém acesso ao conjunto atualizado de cópias de
variáveis predefinidas. Durante a execução, o programa pode se referir a esses valores, eles
permanecerão inalterados dentro do tempo de operação OnTick(). Depois que o OnTick()
terminar sua operação, o programa entrará no modo tick-waiting.
O evento mais próximo no qual variáveis predefinidas podem obter novos valores é um novo
tick. O tempo de execução T1 do Expert Advisor 1 é consideravelmente mais curto do que um
tempo de espera entre carrapatos, por exemplo, o intervalo t 1 - t 2 ou t 2 - t 3, etc. Assim,
durante o período de execução do Expert Advisor 1 analisado há Nenhuma situação na qual
valores de variáveis predefinidas possam tornar-se velhos, ou seja, diferem valores verdadeiros
(do último conhecido) do momento atual.
Na operação do Expert Advisor 2 há outra situação, porque o seu OnTick() período de execução
T2 às vezes excede o intervalo entre Ticks. A função OnTick() do Expert Advisor 2 também é
iniciada no momento t 1. A figura acima mostra que o intervalo t 1 - t 2 entre Ticks é maior do
que o tempo de execução do OnTick() T2, por isso durante este período de operação do
programa as variáveis predefinidas não são atualizadas (nesse período os novos valores não
vêm de um servidor, Seus valores verdadeiros devem ser considerados valores que apareceram
no momento t 1).
Próxima vez que o início do Expert Advisor 2 é iniciado no momento t 2 quando o segundo tick
é recebido. Juntamente com esse conjunto de cópias de valores predefinidos também é
atualizado. Na figura acima vemos que o momento de t 3 tick coming está dentro do período
em que OnTick() ainda está sendo executado. Uma pergunta surge: quais serão os valores de
variáveis predefinidas disponíveis para o Expert Advisor 2 no período de t 3 quando o terceiro
tick chegar a t 32 quando OnTick() terminar sua operação? A resposta pode ser encontrada de
acordo com a seguinte regra:
86
Valores de cópias de variáveis predefinidas são salvos durante todo o período de funcionamento
das funções especiais. Esses valores podem ser atualizados à força usando a função padrão
RefreshRates().
Assim, se a função RefreshRates() não tiver sido executado) durante todo o período de
execução do OnTick, o Expert Advisor 2 terá acesso ao conjunto de cópias locais de variáveis
predefinidas que foi criado quando o segundo tick foi recebido. Embora os Consultores
Especialistas operem nas mesmas janelas, a partir do momento do recebimento do t 3, cada EA
operará com valores diferentes de variáveis predefinidas. O Expert Advisor 1 trabalhará com seu
próprio conjunto de cópias locais de dados históricos, cujos valores são definidos no momento t
3, e o Expert Advisor 2 trabalhará com suas próprias cópias de dados, cujos valores são iguais a
t 2.
Quanto maior o tempo de execução do programa aplicativo e quanto menor o intervalo entre
Ticks, maior a probabilidade de que o próximo Tick venha durante o período de execução do
programa. O conjunto de cópias locais de dados históricos fornece condições para cada
programa que garantem a constância de variáveis pré-definidas durante todo o tempo de
execução de uma função especial.
A partir do momento t 4, quando o próximo Tick chega, ambos EAs serão reiniciados, cada um
deles tendo acesso ao seu próprio conjunto de cópias de variáveis predefinidas, cujos valores
são formados no momento t 4 quando o quarto tick vem.
Função RefreshRates ()
bool RefreshRates()
Exemplo:
87
A função padrão RefreshRates() permite atualizar valores de cópias de dados históricos
locais. Em outras palavras, essa função atualiza os dados referente a um mercado atual
(Volume, tempo do servidor da última cotação, Bid, Ask, etc.) Esta função pode ser usada
quando um programa realiza cálculos por um longo período de tempo e Precisa de dados
atualizados.
Tenha em atenção que RefreshRates() influencia apenas no programa no qual é iniciado (não
influencia em todos os programas que funcionam num terminal de cliente ao mesmo tempo).
Significa que cada programa é responsável por sua chamada a função RefreshRates().
veja o exemplo a seguir, onde contamos o número de interações que um operador de ciclo
pode executar entre os Ticks.
88
Veja que pode ter milhões de interações entre os Ticks.
Tipos de Variáveis
Um programa aplicativo em MQL4 pode conter dezenas e centenas de variáveis. Uma
propriedade muito importante de cada variável é a possibilidade de usar seu valor em um
programa. A limitação desta possibilidade está relacionada com o escopo variável.
Escopo de variável é um local em um programa onde o valor da variável está disponível. Cada
variável tem seu escopo. De acordo com o escopo, existem dois tipos de variáveis no MQL4:
local e global.
Variável local é uma variável declarada dentro de uma função. O escopo das variáveis locais é
dentro do corpo da função, no qual a variável é declarada. Variável local pode ser inicializada
por uma constante ou uma expressão correspondente ao seu tipo.
Variável global é uma variável declarada fora de todas as funções. O escopo das variáveis
globais é todo o programa. Uma variável global pode ser inicializada apenas por uma constante
correspondente ao seu tipo (e não expressão). As variáveis globais são inicializadas apenas uma
vez antes de iniciar sua execução.
89
Veja programa EAFXTRADE_V24
Com base nos exemplos acima, você já sabe o que é uma variável GLOBAL e uma variável
LOCAL
Variáveis estáticas
No nível físico, as variáveis locais são apresentadas numa parte de memória temporária de uma
função correspondente. Existe uma maneira de localizar uma variável declarada dentro de uma
90
função em uma memória de programa permanente, basta utilizar o modificador 'static'
indicado antes de um tipo de variável durante sua declaração:
Exemplo:
As variáveis estáticas são inicializadas uma vez. Cada variável estática pode ser inicializada por
uma constante correspondente (como distinta de uma variável local simples que pode ser
inicializada por qualquer expressão). Se não houver inicialização explícita, uma variável estática
é inicializada por zero. Variáveis estáticas são armazenadas em uma parte de memória
permanente, seus valores não são perdidos ao sair de uma função. No entanto, as variáveis
estáticas têm limitações típicas de variáveis locais - o escopo da variável é a função, dentro da
qual a variável é declarada, distinta das variáveis globais cujos valores estão disponíveis em
qualquer parte do programa.
Variáveis externas
Variável externa é uma variável, cujo valor está disponível a partir de uma janela de
propriedades do programa. Uma variável externa é declarada fora de todas as funções e é
global - seu escopo é todo o programa. Ao declarar uma variável externa, o modificador 'extern'
deve ser indicado antes de seu tipo de valor:
Veja o Exemplo:
91
Veja programa EAFXTRADE_V27
Veja a imagem:
92
No momento de anexar o programa a uma janela de Gráfico, os valores das variáveis contidos
no código do programa serão indicados em uma janela de parâmetros do programa. Um
usuário pode alterar esses valores. A partir do momento em que um usuário clica em OK, o
programa será iniciado pelo terminal do cliente. Os valores das variáveis externas serão aqueles
indicados por um usuário. No processo de operação, esses valores podem ser alterados pelo
programa executado.
GlobalVariables
93
Vários programas de aplicação podem operar no terminal do cliente ao mesmo tempo. Em
alguns casos a necessidade pode ocorrer para passar alguns dados de um programa para
outro. Especialmente para este MQL4 tem variáveis globais do terminal do cliente.
A variável global do Client Terminal é uma variável cujo valor está disponível em todos os
programas de aplicação iniciados em um terminal cliente (forma abreviada: GV).
Nota, variável global do terminal do cliente e variável global são variáveis diferentes
com nomes semelhantes. O escopo de variáveis globais é um programa, no qual a variável é
declarada; Enquanto o escopo de variáveis globais do terminal do cliente é todos os
programas lançados no terminal do cliente.
Propriedades de GlobalVariables
Como diferente de outras variáveis, GV pode ser criada não somente de qualquer programa,
mas também suprimido. O valor GV é armazenado em um disco rígido e salvo depois que um
terminal cliente é fechado. Uma vez que o GV declarado existe no terminal cliente por 4
semanas a partir do momento da última chamada. Se durante este período nenhum dos
programas chamou essa variável, ele é excluído pelo terminal do cliente. GV pode ser apenas
do tipo double.
Há um conjunto de funções em MQL4 para trabalhar com GV (mostraremos mais a frente mais
conteúdo sobre GlobalVariables ). Vamos analisar os que serão usados em outros exemplos.
Função GlobalVariableSet()
Esta função configura um novo valor de uma variável global. Se uma variável não existir, o
sistema cria uma nova variável global. No caso de uma execução bem-sucedida, a função
retorna a hora do último acesso, caso contrário, 0. Para obter uma informação de erro, a
função GetLastError() deve ser chamada.
Parâmetros:
Função GlobalVariableGet()
94
A função retorna o valor de uma variável global existente ou, em caso de erro, retorna 0. Para
obter uma informação de erro, a função GetLastError() deve ser chamada.
Parâmetros:
Função GlobalVariableDel()
Esta função exclui uma variável global. No caso de uma exclusão bem-sucedida a função
retorna TRUE, caso contrário - FALSE. Para obter uma informação de erro, a função
GetLastError() deve ser chamada.
Parâmetros:
95
Veja programa completo em EAFXTRADE_V28
96
Agora você vai pegar este programa, faça a instalação dele no seu MetaTrader. Em seguida
anexe ele em 3, 4 ou 5 gráficos, veja como a variável Experts se torna acessível para todos,
assim sendo possível ratear o dinheiro entre os gráficos.
ATENÇÃO: Nota, variável global do terminal do cliente e variável global são variáveis
diferentes com nomes semelhantes. O escopo de variáveis globais é um programa, no qual a
variável é declarada; Enquanto o escopo de variáveis globais do terminal do cliente é
todos os programas lançados no terminal do cliente.
Inclusive se o programa for anexado em mais gráficos, o valor vai continuar a ser rateado.
Existe uma opção no terminal do cliente para consultar, adicionar e remover "Variáveis
Globais" onde pode-se ver todas as GlobalVariables abertas e seus valores.
Depois que todos os EAs forem removidos dos Gráficos, esta janela deve estar vazia sem
quaisquer registros sobre as variáveis globais abertas do terminal do cliente.
97
Erros na utilização de GlobalVariables
If (Experts == 1) // Se existe um EA ..
Neste caso, o valor da variável global Experts é analisado. Embora reflita o valor GV, ele pode
ficar antiga (deve ser lembrado todos os programas operam em modo de tempo real). Para
entender as razões, vamos ver o diagrama a seguir:
No momento t6, a segunda EA é anexada ao gráfico GBP/USD. Como resultado do seu valor de
execução OnInit() das variações de quantidade de GV e no momento t7 é igual a 2. Depois
disso no momento t8 o terceiro EA é anexado ao gráfico USD/CHF, como resultado no
momento t9 GV Quantidade é igual a 3.
No momento t10 um comerciante decide remover um EA da janela EUR / USD. Note-se que a
última vez que a variável Especialistas da EA operando nesta janela foi alterada durante a
execução de OnTick() lançada no segundo tick, isto é, no período t4 - t5. No momento t10 o
valor de Experts no EA operando na janela EUR/USD ainda é igual a 1. É por isso que quando
OnDeinit() deste EA é executado, GV Quantidade será excluído como resultado da execução das
seguintes linhas:
98
Assim, embora ainda existam dois EAs anexados, o GlobalVariable excluído. Não é difícil de
entender, que conseqüências isso causara nos cálculos de EAs anexados. Na execução de
OnTick(), estes EAs detectarão que o valor atual de New_Experts é igual a zero, por isso o novo
valor de Experts também será zerado. Como resultado, o valor do dinheiro não pode ser
calculado, porque na fórmula utilizada para os cálculos especialistas está no
denominador. Assim, os cálculos adicionais nas EAs serão erróneos.
Além disso, na execução das funções OnDeinit() dos EAs (ao desvincular-se de GBP/USD e
USD/CHF) a GV será aberta novamente, mas o valor será igual a -1 depois que uma delas
forem removidas e -2 após a Último ser removido. Tudo isso resultará em um valor negativo do
Dinheiro. Importante é o fato de que após todos os EAs serem destacados, a Quantidade de GV
permanecerá aberta no terminal do cliente e influenciará ainda mais a operação de todos os
EAs que usam seu valor.
Há também outro caso possível. Imagem a seguir mostra como o valor de GV mudará se antes
de um EA ser removido chegar um outro Tick.
Com base em tudo que vimos, o erro pode ser facilmente corrigido. Precisamos simplesmente
atualizamos a variável Experts antes da análise (antes da execução do operador if):
Veja o exemplo:
Tais erros algorítmicos são perigosos porque nem sempre são óbvios e é difícil detectá-los. Mas
isso não significa que um usuário deve recusar usar GlobalVariables. No entanto, isso significa
que um código de qualquer programa deve ser construído corretamente levando em conta
todos os eventos que podem influenciar o desempenho do programa.
99
O uso de variáveis globais no trabalho prático pode ser muito útil: por exemplo, isso ajuda a
informar sobre eventos críticos em um outro Gráfico (atingindo um certo nível de preço, sua
quebra, etc.), sobre a ligação de outro Consultor Especializado (com o objetivo de Partilha de
autoridade), realizar negociação sincronizada sobre vários títulos ao mesmo tempo. A variável
global do terminal do cliente também pode ser criada a partir de um indicador que calcula
alguns eventos importantes. O valor de tal variável pode ser usado por qualquer Expert Advisor
ou script operacional.
Matrizes
Uma grande parte da informação processada por programas de aplicação está contida em
matrizes.
Conceito de matrizes
Indexação
100
A maneira de especificar índices quando cada índice está entre colchetes também é aceitável:
Um exemplo do nosso cotidiano mais próximo de uma matriz bidimensional é uma sala de
cinema. O número da linha é o primeiro valor do índice, o número do acento é o valor do
segundo índice, os espectadores são elementos da disposição, o sobrenome do cliente é o valor
de um elemento da disposição, o ingresso do cinema (especificando a linha e o lugar) é um
método Para acessar o valor de um elemento de matriz.
Antes de usar uma matriz em um programa, ele deve ser declarado. Uma matriz pode ser
declarada como uma variável no nível global e local. Consequentemente, valores de elementos
de matriz global estão disponíveis para todo o programa, valores de um local - apenas para a
função, na qual é declarado. Uma matriz não pode ser declarada no nível de um terminal de
cliente, é por isso que as variáveis globais do terminal de cliente não podem ser reunidas em
uma matriz. Os valores dos elementos da matriz podem ser de qualquer tipo. Os valores de
todos os elementos da matriz são do mesmo tipo, ou seja, do tipo indicado na declaração de
matriz. Ao declarar uma matriz, o tipo de dados, o nome da matriz e o número de elementos de
cada dimensão devem ser especificados:
101
O acesso aos elementos da matriz é implementado de forma elementar, ou seja, em um
momento de tempo, apenas um componente pode ser acessado. O tipo de valor do
componente de matriz não é especificado no programa. O valor do componente de matriz pode
ser atribuído ou alterado usando o operador de atribuição:
são os seguintes:
- para uma matriz unidimensional, o valor do elemento Mas[4] é o número inteiro 34;
Nota: o valor mínimo do índice de elemento de matriz é 0 (zero) eo valor máximo é menor em
um que o número de elementos em uma dimensão correspondente indicada na declaração de
matriz.
Por exemplo, para a matriz Mas[10][15] o elemento com o menor valor de índices é o elemento
Mas[0,0], aquele com valores de índices máximos é o elemento Mas[9,14].
Operações com matrizes também podem ser realizadas usando funções padrão.
102
Uma matriz pode ser inicializada apenas por constantes de um tipo correspondente. As matrizes
unidimensionais e multidimensionais são inicializadas pela sequência unidimensional de
constantes separadas por vírgulas. A sequência é incluída em colchetes:
Na sequência inicializada, uma ou várias constantes podem ser omitidas. Nesse caso, os
elementos de matriz correspondentes de tipo numérico são inicializados por zero, os elementos
de matrizes de tipo string são inicializados pelo valor de string "" (aspas sem espaço), isto é,
por uma linha vazia (não deve ser confundida com um espaço). O próximo programa exibe
valores de arrays, inicializados por uma seqüência com omissão de alguns valores:
Veja o resultado:
103
Se o tamanho de uma matriz inicializada não tiver a dimensão especificada, ela será definido
por um compilador baseado na seqüência inicializada. Uma matriz também pode ser inicializada
pela função padrão ArrayInitialize(). Todos os arrays são estáticos, ou seja, são de tipo
estático, mesmo que na inicialização isso não é explicitamente indicado. Isso significa que todos
os arrays preservam seus valores entre chamadas da função, em que a matriz é declarada.
Todos os arrays usados no MQL4 podem ser divididos em dois grupos: arrays definidos pelo
usuário (criados por iniciativa de um programador) e arrays-timeseries (arrays com nomes
predefinidos e tipos de dados).
Definir tamanhos de arrays definidos pelo usuário e valores de seus elementos depende de
como um programa é criado e em última instância, conforme a vontade do programador.
Valores de elementos de matriz definidos pelo usuário são preservados durante todo o tempo
de execução do programa e podem ser alterados após cálculos. No entanto, valores de
elementos em arrays-timeseries não podem ser alterados, seu tamanho pode ser aumentado
quando o histórico é atualizado.
Vamos ver o próximo exemplo onde o programa tem a função de analisar o preço e fazer uma
analise com base no nível estipulado pelo usuário.
Se o preço exceder um determinado nível, o programa vai exibir uma mensagem, em que o
excesso é indicado (até 100 pontos), caso contrário ele mostrara de forma escrita a quantidade
e pontos que o preço esta de distancia do limite declarado pelo usuário.
104
Veja que foi feito a leitura da matriz Text[101], sendo que o LOOP externo inicializou na
posição 20, com limite até 90, incrementando de 10 em 10.
Na função OnTick() o programa faz uma verificação Tick a Tick para saber se o preço esta
dentro do Nivel.
Caso a Variável Delta Retorne um valor MENOR que ZERO, será mostrado a mensagem “Preço
abaixo do nível”.
Caso a Variável Delta Retorne um valor MAIOR que 100, será mostrado a mensagem “Mais de
cem pontos”.
Se Delta estiver fora das duas verificações, ai sim será mostrado a mensagem referente a
quantos pontos de distancia estamos do limite definido pelo usuário.
105
Arrays-Timeseries
Array-timeseries é uma matriz com um nome predefinido (Open, Close, High, Low, Volume
ou Time), cujos elementos contêm valores de características correspondentes de barras
históricas.
Barra zero é a barra atual que ainda não se formou completamente. Em uma janela de gráfico
a barra zero é a última direita.
106
Após algum tempo, a barra atual será formada e uma nova barra aparecerá em uma janela de
segurança. Agora, esta nova barra será uma barra zero e a barra que acaba de se formar vai se
tornar o primeiro depois da BARRA ZERO(com o índice 1):
Os valores dos elementos array-timeseries são características próprias de uma barra, e são
alterados (exceto as seguintes características de uma barra zero: Close [0], High [0], Low [0],
Volume [0]); Seu aprofundamento no futuro para o momento atual e é mudado no decorrer do
tempo.
107
Sempre que um novo Candle surgir, o Gráfico é indexado novamente, significa que neste
gráfico mostrado acima, o Open[0] agora é o candle laranja, sendo que o Open[0] era o candle
anterior antes do surgimento do candle laranja.
É importante saber isso pois Open[0] de agora, nem sempre vai ser o Open[0] de daqui a
pouco.
Vamos mostrar um exemplo onde vamos encontrar o preço mínimo e máximo entre as últimas
n barras. E faremos o uso de Arrays-timeseries
Exemplo:
108
3. Fazemos a verificação, se o menor preço (Low[i]) é menor que o valor carregado na
variável Minimum, caso o valor seja menor, então atualizamos a variável Minimum
com o novo valor.
4. Fazemos a verificação, se o maior preço (High[i]) é maior que o valor carregado na
variável Maximum, caso o valor seja maior, então atualizamos a variável Maximum
com o novo valor.
5. Após concluir o LOOP do ‘for’, mostramos um Alerta com os valores atualizados.
Veja o resultado:
Existe uma maneira mais simples e confiável de fazer o mesmo trabalho - analisando o tempo
de abertura de uma barra zero. O tempo de abertura de uma barra zero é a característica da
barra que não muda durante a formação da barra.
Os Novos ticks vêm durante a formação de um bar e podem mudar seu High[0], Close[0] e
Volume[0]. Mas características como Open[0] e Time[0] não são alteradas.
No exemplo abaixo mostramos uma outra forma de trazer o mesmo resultado do exemplo
acima.
Fizemos também a criação de uma função que verifica a existência de um novo candle, com
base no array Time[0].
109
Se o valor New_Time (calculado no histórico anterior) não é igual a Time[0] de uma barra
zero, o programa entende que é de fato a formação de uma nova barra. Nesse caso, o controle
é passado para o corpo do operador 'if', onde é atribuído o novo tempo de abertura da barra
zero para variável New_Time e atualizado o valor da variável New_Bar para true.
Veja resultado:
110
111
Programação prática em MQL4
Esta segunda parte do livro considera as seguintes questões: a ordem de realização de
operações comerciais, os princípios de codificação e uso de scripts simples, Expert Advisors e
indicadores, bem como funções padrão frequentemente usadas na programação em
MQL4. Todas as seções contêm alguns exemplos de programas prontos para uso, mas com
campo de aplicação limitado.
A seção denominada Criação de Programas Normais dá um exemplo que você pode usar como
base para projetar seu próprio Expert Advisor simples para ser usado na negociação real.
Todos os critérios de negociação abaixo são usados para propósitos educacionais e não devem
ser considerados como diretrizes na negociação em contas reais.
Ordem de mercado - é uma ordem executada para comprar ou vender ativos para um
símbolo (segurança). Uma ordem de mercado é exibida na janela de símbolo até que a ordem
seja fechada.
Ordem pendente é uma ordem comercial para comprar ou vender ativos quando o nível de
preço predefinido é atingido. A ordem pendente é exibida na janela de símbolo até que ela se
torne uma ordem de mercado ou seja excluída.
Diagrama
112
mencionamos acima, qualquer programa aplicativo pode ser executado somente no PC do
usuário, nenhum programa aplicativo é instalado no servidor). O pedido formado pelo programa
será passado para o terminal cliente que, por sua vez, envia o pedido ao servidor. No lado do
servidor, a decisão sobre a execução da solicitação ou rejeição será feita. As informações sobre
os resultados obtidos serão passadas pelo servidor para o terminal cliente e, em seguida, para
o programa.
Solicitações
Um pedido de comércio ou abertura de ordem pode ser feito por um comerciante ou por um
programa (EA). Para que um operador possa fazer uma solicitação, o terminal cliente fornece o
painel de controle "Nova Ordem".
Quando se trata de Programas (EA) As solicitações são feitas de acordo com o algoritmo criado
pelo desenvolvedor, como resultado da execução de funções comerciais.
Recursos do Programa
Existem outras funções que pertencem ao módulo comercial (consulte o arquivo de ajuda no
MetaEditor). No entanto, a sua execução é atribuída a chamar o ambiente de informação do
terminal, a fim de obter informações de referência, por isso não resulta na formação de pedidos
e chamada para o servidor.
113
Uma solicitação feita pelo programa como resultado da execução de uma função comercial é
passada para o terminal cliente para processamento. O terminal cliente analisa o conteúdo da
solicitação e executa uma das duas ações a seguir: envia a solicitação ao servidor para que ela
seja executada no servidor ou rejeita a solicitação e não envia nada para o servidor.
Recursos do Servidor
Uma solicitação comercial formada como resultado da execução do programa e uma solicitação
de negociação formada manualmente pelo operador são absolutamente iguais, do ponto de
vista do servidor, de modo que o servidor não faz distinção entre solicitações ao processá-las.
Em resumo o servidor não sabe se a ordem esta sendo gerada manualmente ou através de um
EA.
114
Procedimento de Negociação
Evento 3. O terminal cliente executa essa decisão tomada (uma de duas alternativas).
Evento 4. O programa recebeu o controle (momento t4, ponto verde) e pode continuar a
execução a partir do local onde a solicitação foi formada anteriormente. No mesmo momento, o
programa recebeu a informação de que a ordem comercial não foi executada. Você pode
descobrir sobre o motivo, para o qual a solicitação de comércio não foi executada, analisando a
ode do erro retornado. Abaixo vamos considerar a questão de como fazer isso. Aqui, apenas
deve ser notado que nem todas as solicitações resultam na execução de negócios. Nesse caso,
o programa formou uma solicitação incorreta, o que resulta em que o terminal cliente rejeitou
essa solicitação e retornou o controle para o programa. Nesse caso, nenhuma referência ao
servidor ocorre.
115
aproximadamente 5 a 10 ms, enquanto que pode ser medido em segundos inteiros em conexão
ruim.
A rejeição do servidor de pedidos comerciais (embora eles já tenham sido verificados pelo
terminal cliente) é comum. Em geral, as solicitações comerciais que são entregues ao servidor
são aceitas para execução. No entanto, em alguns casos, um pedido pode ser rejeitado, e o
programa de aplicação tem de ser codificado de tal forma que considere essa possibilidade e
funcione corretamente em tais situações.
Seja qual for a decisão (para executar / rejeitar uma solicitação de negociação, Evento 6), a
decisão é feita pelo servidor, as informações sobre ele são enviadas pelo servidor para o
terminal cliente que entregou a solicitação.
116
Podemos ver que dois Trading Expert Advisors são lançados para execução no terminal
cliente simultaneamente. EA1 formou uma solicitação de negociação no momento t1 e passou-o
o terminal cliente no momento t2.
EA2 também criou uma solicitação e refere-se ao terminal cliente quando o terminal cliente está
processando a primeira solicitação (período de t2 a t3). Nessa situação, o terminal cliente não
pode considerar a solicitação formada por EA2, portanto, ele irá rejeitar essa solicitação e
retornar o controle para EA2. Observe que, neste caso, o pedido é rejeitado pelo terminal
cliente não para a solicitação está incorreta, mas porque o terminal está ocupado com o
processamento do outro pedido. EA2 continuará operando. Ele pode analisar o código de erro
que explica o motivo pelo qual o pedido foi rejeitado (no nosso caso, é o erro 146).
Se for EA2 (em um caso geral, pode ser um ou vários programas de negociação) que passa sua
solicitação para o terminal cliente dentro do período de tempo entre t1 e t4, então esse pedido
será rejeitado (um grupo de eventos no Rosa). O terminal cliente fica livre no momento t4
(ponto verde). A partir deste momento, o EA2 pode passar com sucesso sua solicitação para o
terminal cliente (um grupo de eventos na área verde). Esta solicitação será recebida e
considerada pelo terminal cliente que pode finalmente rejeitá-la, também, mas pela razão de
sua incorreção, ou pode enviar essa solicitação ao servidor.
Se a solicitação comercial criada por EA1 for considerada pelo terminal cliente como correta,
essa solicitação será enviada pelo terminal cliente para o servidor no momento t3. Neste caso,
o terminal do cliente muda para o modo de espera e não pode considerar quaisquer outros
pedidos de comércio. O terminal cliente só ficará livre para considerar de outras solicitações
comerciais no momento t9. Assim, de acordo com a Variante 2, o terminal cliente não pode
analisar pedidos de comércio dentro do período de tempo entre t1 e t9. Se dentro desse
período qualquer programa se refere ao terminal cliente para passar uma solicitação para
consideração, o terminal cliente rejeitará este evento e passará o controle para o programa (um
grupo de eventos na área cor-de-rosa dentro do período de tempo entre t6 E t7). O programa
que recebeu o controle continua seu funcionamento e,
A partir do momento t9, o terminal cliente será completamente livre para analisar quaisquer
outros pedidos de comércio. EA2 pode passar com êxito a solicitação de negociação para o
terminal cliente dentro do período de tempo que segue o momento t9. De acordo com o cliente
terminal considera este pedido para ser correto ou não, o pedido será passado pelo terminal
cliente para o servidor ou rejeitado.
A análise de erros que ocorrem na realização de negócios é considerada em mais detalhes nas
seções abaixo.
117
Características e Regras de Ordem para Fazer Negócios
Em primeiro lugar, devemos considerar o princípio utilizado pelas corretoras para formar preços
de títulos. Este princípio consiste em que o corretor oferece ao comerciante uma cotação de
duas vias para a realização de comércios.
Citação de duas vias é um par ligado de preços de mercado oferecidos pelo corretor para a
compra e venda de ativos no momento presente.
Bid é o menor dos dois preços oferecidos pelo corretor em uma cotação.
Ask é o maior dos dois preços oferecidos pelo corretor em uma cotação.
Point é a unidade de medição de preço para um símbolo (a variação de preço mínima possível,
o último valor significativo do valor do preço).
Existem seis tipos de ordem no total: dois tipos de ordens de mercado e quatro tipos de
pedidos pendentes.
118
BuyLimit é uma ordem pendente para comprar ativos para uma segurança a um preço inferior
ao atual. A ordem será executada (modificada para a ordem de compra no mercado) se o preço
Ask atingir ou cair abaixo do preço definido na ordem pendente.
SellLimit é uma ordem pendente para vender ativos para um título a um preço superior ao
atual. A ordem será executada (modificada na ordem de venda do mercado) se o preço da
Oferta atingir ou ficar acima do preço definido na ordem pendente.
BuyStop é uma ordem pendente para comprar ativos para uma segurança a um preço superior
ao atual. A ordem será executada (modificada para a ordem de compra do mercado) se o preço
de Ask atingir ou sobe acima do preço definido na ordem pendente.
SellStop é uma ordem pendente para vender ativos para um título a um preço inferior ao
atual. A ordem será executada (modificada para venda no mercado) se o preço da Oferta
atingir ou cair abaixo do preço definido na ordem pendente.
StopLoss é uma ordem de paragem; É um preço estabelecido pelo trader, no qual uma ordem
de mercado será fechada se o preço do símbolo se move em uma direção que produz perdas
para a ordem.
TakeProfit é uma ordem de paragem; É um preço estabelecido pelo comerciante, no qual uma
ordem de mercado será fechada se o preço do símbolo se move em uma direção que produz
lucros para a ordem.
Para formar solicitações corretas de comércio em seus programas de aplicação (Expert Advisors
e scripts), você deve levar em consideração os requisitos e limitações existentes. Vamos
considerá-los em mais detalhes.
Todos os negócios são realizados a preços corretos. O preço de execução de cada transação é
calculado com base no preço correto de uma cotação bidirecional.
A regra acima é a regra comum para todos os participantes no mercado e não pode ser
alterada à vontade dos desenvolvedores de uma plataforma de negociação ou com base em um
acordo entre um corretor e um comerciante. Isso significa, por exemplo, que uma ordem de
mercado só pode ser aberta ao preço de mercado atual, mas não a qualquer outro preço. O
procedimento de cálculo do preço correto para diferentes operações é considerado abaixo.
119
pode especificar apenas os valores de preço de parada que não estão distantes do preço atual
menor que a distância mínima prescrita. Uma solicitação comercial contendo preços de parada
que estejam mais próximos do preço de mercado do que a distância mínima é considerada pelo
terminal cliente como incorreta. Diferentes centros de negociação podem estabelecer limites
específicos para o centro específico para a distância mínima permitida. Como uma regra, O
valor dessa distância varia entre 1 e 15 pontos. Para os títulos mais utilizados (EUR/USD, GBP/
USD, EUR/CHF, etc.), esta distância faz na maioria dos centros de negociação 3-5 pontos. Não
há limitações para a distância máxima. O valor da distância mínima para qualquer símbolo pode
ser alterado pelo corretor a qualquer momento (isso geralmente precede a transmissão de
notícias comerciais importantes). Não há limitações para a distância máxima.
A distância Freeze limita a possibilidade de modificar os preços solicitados para abrir os pedidos
pendentes, bem como os níveis de parada solicitados para as ordens de mercado que estão na
área de congelamento. Isto significa, por exemplo, que, se o preço de mercado for 1.3800, a
ordem pendente é colocada para ser aberta em 1.3807 e a receita do corretor é 10, a ordem
pendente está na área de congelamento, ou seja, não é possível modificá-la ou excluí-la. Em
um mercado calmo, os corretores geralmente não definem a distância de congelamento, ou
seja, seu valor = 0. No entanto, durante o período anterior à notícia importante ou com alta
volatilidade, o corretor pode definir um certo valor de uma distância de congelamento. Em
condições diferentes e para diferentes corretores, esse valor pode variar de 1 a 30 pontos para
símbolos básicos e assumir valores mais altos para outros símbolos.
As limitações dos níveis de preços limitadas pelos valores de distância mínima e de distância de
congelamento são calculadas com base em preços corretos.
A abertura de uma ordem de mercado implica a compra ou venda de alguns ativos para um
símbolo aos preços de mercado atuais.
O preço correto para ordem de Compra é o mais recente preço de mercado conhecido Ask.
120