EAFXTRADE
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................................... 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 ................................................................................................................. 34 Programa em MQL4 .................................................................................................................. 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 Hoje em dia, um computador pessoal tornou-se indispensável para todos. O rápido desenvolvimento da Internet e do desempenho dos computadores modernos abriu novas perspectivas em muitos campos das atividades humanas. Já há dez anos, o mercado financeiro estava disponível apenas para bancos e para uma comunidade limitada de especialistas. Hoje, qualquer um pode se juntar ao mundo dos comerciantes profissionais e iniciar a negociação independente a qualquer momento. Milhares de pessoas em todo o mundo já aprovou o uso do MetaTrader 4 pelo seu desempenho. O uso de sua linguagem de programação embutida, MQL4, eleva os comerciantes para um novo nível de negociação - para negociação automatizada. Agora, um comerciante pode implementar suas idéias como um programa de aplicação escrever um indicador personalizado, um script para executar operações únicas, ou criar um Expert Advisor - um sistema de negociação automatizado (robô comercial). 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. A principal vantagem das aplicações é a possibilidade de fazer negócios de acordo com o algoritmo definido por você. Qualquer idéia que possa ser descrita em uma linguagem algorítmica (interseção de duas médias móveis ou processamento digital de sinais, três telas por análise fractal de Elder ou Peters, uma rede neural ou construções geométricas) pode ser codificada em uma aplicação. O desenvolvimento de aplicações para MetaTrader 4 requer o conhecimento do MQL4. Este livro de texto irá ajudá-lo a criar seus próprios Expert Advisors, scripts e indicadores. Este Ebook didático destina-se a um grande número de leitores sem experiência em programação que desejam aprender a desenvolver aplicativos de negociação automatizados para MetaTrader 4 Client Terminal. O livro projetado de tal forma que qualquer pessoa vai dar conta de implementar seus próprios Robôs automatizados.
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.
Figura 1 Um programa desenvolvido na linguagem MQL4 como parte do MetaTrader 4 Terminal Cliente. 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. O terminal cliente inclui um ambiente informacional, um conjunto de parâmetros com informações sobre o estado de mercado e sobre as relações entre um comerciante e um centro de negociação. Esses parâmetros incluem informações sobre preços atuais, limitações no tamanho máximo e mínimo da ordem, distância mínima de ordens de parada, tolerância e proibição da negociação automatizada e muitos outros parâmetros úteis que caracterizam o estado atual. O ambiente informacional é atualizado quando novos sinais são recebidos pelo terminal (linha verde na Figura 1 anterior).
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. Para a gestão comercial manual, a barra de ferramentas de gestão de pedidos é utilizada. Usando esta barra de ferramentas, um comerciante pode abrir, fechar e modificar ordens. Além disso, o terminal tem a opção de gerenciamento automatizado da posição de ordem de parada. As ações de um trader com ferramentas de gerenciamento de negociação incorporadas resultam na formação de ordens comerciais, que são enviadas para um servidor.
Ferramentas de programação MQL4
Análise de mercado e gestão comercial no MetaTrader 4 é implementado com a ajuda de ferramentas de programação. A linguagem MQL4 permite a criação de tais programas. Existem três tipos de aplicativos criados em MQL4 e destinados a trabalhar no terminal cliente: 1. Um indicador personalizado é um programa que exibe graficamente regularidades do mercado de acordo com o algoritmo de um autor escrito programa. 2. Um Expert Advisor é um programa que permite a automação parcial operações de negociação, ou permite negociação totalmente automatizada. 3. Um script é um programa para executar ações únicas, incluindo a execução operações comerciais.
as no de de
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. Aplicativos e ferramentas de gerenciamento manual podem ser usados no terminal cliente simultaneamente, complementando um ao outro. OBS: A característica técnica fundamental de negociação usando o sistema de comércio on-line MetaTrader é que todas as ações de gerenciamento são produzidos no terminal do cliente e, em seguida, enviado para um servidor. Os programas de aplicação (Expert Advisor, script e indicador) podem funcionar apenas como parte do terminal cliente, desde que estejam conectados a um servidor (centro de negociação). Nenhum dos programas de aplicação fica instalado no servidor.
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 s ervidor. O escopo do nosso estudo inclui programas (Expert Advisors, scripts e indicadores personalizados) que realizam negociações parcialmente ou totalmente automatizadas e que ampliam significativamente a manutenção informacional da negociação (ver Figura 1). Neste livro, você encontrará a descrição dos componentes do programa, e você encontrará as principais regras de criação e uso de programas. Também vamos considerar em pormenor exemplos de programas e exemplos de parâmetros de ambiente informacional do terminal cliente, que estão disponíveis para um programa durante a sua execução. OBS: Os programas para negociação automatizada têm muito mais usos potenciais do que as ferramentas manuais de gerenciamento comercial.
Na maioria dos casos, um programa em MQL4 torna o trabalho de um profissional negociador mais fácil, eliminando a necessidade de um acompanhamento constante de situações de mercado, sentado diante de um computador por um longo período de tempo. 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 Esta seção representa os termos básicos para entender o MQL4: 1. alguns conceitos básicos 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 Os termos constantes e variáveis são comuns quando falamos de programação a diferença entre esses termos é explicado. Como o termo sugere, uma constante é algo que permanece o mesmo, definido uma vez e nunca mais muda. Ao contrário da constante, uma variável é um objeto de código de programação que pode ter seu conteúdo alterado a qualquer momento. É impossível escrever um programa sem usar objetos (constantes) imutáveis e / ou objetos que podem ser modificados durante a execução do programa (variáveis). 3. Tipos de dados Certos tipos de dados são usados em qualquer linguagem de programação, seja ela em C, Delphi, Java e etc... O tipo de dados de uma variável é escolhido de acordo com sua finalidade. Como podemos declarar uma variável? Como podemos inicializá-lo (predefinir seu valor inicial)? Uma escolha errada do tipo para uma variável pode atrasar o programa ou mesmo resultar em ações erradas. Mostraremos como utilizar mais a frente. 4. Operações e expressões As Como qualquer outra linguagem de programação, O MQL4 processa toda forma de operações e executa qualquer tipo de expressões criadas pelo desenvolvedor. Sem saber sobre os recursos de algumas operações, você pode fazer erros sutis. 5. Operadores Existem operadores simples e operadores compostos. Uma ação necessária não deve sempre ser executada por um operador simples. Se for necessário que um grupo de operadores seja executado como um grande operador, esse grupo deve ser incluído em um operador composto. Requisitos e exemplos específicos de utilização de operadores são dados mais a frente. 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 Programas Scripts, indicadores e Expert Advisors são os tipos de programas MQL4 que permitem cobrir praticamente toda a classe de problemas relativos à negociação em mercados financeiros. É necessário compreender as finalidades de cada tipo de programas para usar MetaTrader 4 Client Terminal da melhor maneira.
Alguns conceitos básicos O assunto de nosso interesse aqui é criar um programa escrito em MQL4. Antes de iniciar uma apresentação detalhada das regras da escrita de programas, é necessário descrever os conceitos básicos que caracterizam um programa e suas inter-relações com o ambiente de informação. O MetaTrader 4 Client Terminal funciona com uma conexão on-line. A situação nos mercados financeiros muda continuamente, o que afeta gráficos de símbolos no terminal do cliente. Os Ticks fornecem ao terminal cliente informações sobre as mudanças de preços no mercado. 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 ter minal 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. Controle é o processo de execução de ações predefinidas pelo algoritmo do programa e os recursos do terminal do cliente. O controle pode ser transferido dentro do programa de uma linha de código para outra, bem como do programa para 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 comentário
Um comentário é uma parte opcional e não executável de um programa que explica expli ca 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. No entanto, os comentários facilitam a compreensão do código do programa. Meu conselho é que sempre comente o seu código, veja o exemplo:
11
Constantes e variáveis Constantes
Constante nada mais é do que parte de um programa. Uma constante em um programa é semelhante a uma constante usada em equações matemáticas. É um valor invariável. invariável . NUNCA MUDA. Exemplos: A raça humana descobriu constantes naturais, nat urais, universais, u niversais, 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. Constante é também um termo usado em equações matemáticas. Por exemplo, na equação de Y de Y = = 3 * X + 7, os números 3 e 7 são constantes. Os valores de tais constantes são totalmente dependentes da vontade da pessoa que fez a equação. Esta é a analogia mais próxima das constantes usadas em programas MQL4. Veja a imagem um exemplo de constante no Código MQL4.
Variável
Ao Contrário da constante, as variáveis podem ser alteradas a qualquer momento dentro do programa, o valor recebido por uma determinada variável fica armazenada somente na memoria do computador, e essa essa variável pode receber receber outro valor sempre que for for necessário. 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. As variáveis podem ser:
int (números inteiros) double (números com casas decimais) bool (valores booleanos, que são valores lógicos (true (true ou false)) false )) string (valores do tipo texto) color (valores do tipo de cor) datetime (valores de data e hora)
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. Int Art
= 10 ;
// Exemplo de variável inteira
int B_27 = - 1 ;
// Exemplo integer variável
int Num
= 21 ;
// Exemplo inteiro variável
int Max
= 2147483647 ;
// Exemplo inteiro variável
int Min
= - 2147483648 ;
// Exemplo de variável inteira
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. double Art
= 10,123 ;
// Exemplo de variável real
double B_27
= - 1,0 ;
// Exemplo de variável real
double Num
= 0,5 ;
// Exemplo variável real
double MMM
= - 12,07 ;
// Exemplo de variável real
double Price_1 = 1,2756 ;
// Exemplo de variável real
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:
bool aa
= True;
// Variável booleana
bool B17
= TRUE;
// A variável booleana B17 tem o valor de true
аа tem o valor de true
bool Hamma = 1;
// Variável booleana Hamma tem o valor de true
bool Asd
= False;
// Variável booleana Asd tem o valor de false
bool Nol
= FALSE;
// A variável booleana Nol tem o valor de false
bool Prim
= 0;
// A variável booleana Prim tem o valor de false
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" ; de alimentação de linha
// o texto contém caracteres
Tipo color
As cores são armazenados como cor tipos de dados. 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. Exemplos: C'128,128,128 '(cinzento), C'0x00,0x00,0xFF' (azul), C'0xFF, 0x33,0x00 '(vermelho). Representação de inteiro A representação de inteiro é registrada como um número hexadecimal ou decimal. Um número hexadecimal é exibido como 0xRRGGBB, onde RR é o valor de intensidade vermelha, GG de verde e BB de azul. As constantes decimais não são refletidas diretamente no RGB. Eles representam o valor decimal de uma representação hexadecimal 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. Exemplos: 0xFFFFFF (branco), 0x008000 (verde), 16777215 (branco), 32768 (verde). 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
O tipo de dados datetime é usado para data e hora. 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. datetime Alfa
= D'2004.01.01 00:00';
// Novo Ano
datetime Tim
= D'01.01.2004';
// Novo Ano
datetime Tims
= D'2005.05.12 16:30:45';
// May 12, 2005 4:30:45 p.m.
datetime N_3
= D'12.05.2005 16:30:45';
// May 12, 2005 4:30:45 p.m.
datetime Compile = D''; date] 00:00:00'
// equivalent of D'[compilation
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. Na seção anterior do livro, você aprendeu sobre a necessidade de apresentar dados de diferentes tipos. Aqui vamos entrar em possíveis relações entre esses dados. Em MQL4, existem algumas limitações naturais para as regras de utilização de operações em expressões.
As noções de operando, operação, símbolo de operação e 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). Uma operação é uma ação feita sobre operandos . 17
Um símbolo de operação é um caractere predefinido ou grupo de caracteres que ordenam executar uma operação. Uma expressão é uma seqüência de operandos e símbolos de operação; Tipos de operações
Estes são os seguintes tipos de operações em MQL4:
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 booleanas (lógicas)
Os símbolos a seguir são exemplos de operação booleanos.
Operações bit a bit
Operações bit a bit só podem ser executadas com inteiros. As operações a seguir são operações bit a bit. Isso retorna o complemento do valor da variável. O valor da expressão contém um 1 em todos os locais em que os valores da variável contêm um 0 e contém um 0 em todos os locais nos quais os valores da variável contêm um 1. 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;
A representação binária de x é deslocada por y lugares para a esquerda; Os lugares vazios à esquerda serão preenchidos com zeros. X = x << y;
O exemplo seguinte demonstra a operação bit a bit E das representações binárias de x e y . O valor da expressão contém 1 (TRUE) em todos os lugares, em que x e y contêm não-zero, e o valor da expressão contém 0 (FALSE) em todos os outros locais. B = ((x & y)!= 0);
O exemplo seguinte demonstra a operação bit a bit OU das representações binárias de x e y . O valor da expressão contém 1 em todos os lugares, em que x ou y não contém 0. Ele contém 0 em todos os outros lugares. B = x | Y;
O exemplo seguinte demonstra a operação bit a bit OU EXCLUSIVO das representações binárias de x e y . O valor da expressão contém 1 nos lugares, nos quais x e y possuem valores binários diferentes. Ele contém 0 em todos os outros lugares. B = x ^ y;
Operação por vírgula
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. for(i=0,j=99; i<100; i++,j--) Print(array[i][j]); // Loop statement
A seguinte lista de parâmetros transferidos pode ser considerada como um exemplo. 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: Function_name(Parameters_list )
// Chamada de função como tal
Operadores Tipos de operadores
Existem dois tipos de operadores: operadores simples e compostos. 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. Aqui estão exemplos de operadores simples. Day_Next= TimeDayOfWeek(Mas_Big[n][0]+60); Go_My_Function_ind(); a=3;
b = a * x + n;
Print("
// Operador simples // Operador simples
i++;
// vários operadores na linha
Day= ",TimeDay(Mas_Big[s][0]),
// um operador
"
Hour=",TimeHour(Mas_Big[s][0]),
// Outro Operador
"
Minute=",TimeMinute(Mas_Big[s][0]),// mais um Operador
"
Mas_Big[s][0]= ",Mas_Big[s][0],
"
Mas_Big[s][1]= ",Mas_Big[s][1]);
// todos dentro da Print
Operadores compostos (compostos)
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. A descrição de uma função é único, chamado parte de um programa destinado à execuçã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. Da mesma forma, se uma chamada de função ocorre em um programa, então a função do mesmo nome será chamado e executado. Ou seja, uma certa seqüência de cálculos ou outras ações serão realizadas, como exibir uma mensagem ou abrir uma ordem. O uso geral de uma função é fazer com que uma parte logicamente concluída do código fora do texto básico do programa e substituí-lo apenas com a chamada para esta parte do código. Tal construção de programa tem algumas vantagens incontestáveis.
Primeiro, o nome da função é composto de tal maneira a ser lido facilmente. Em segundo lugar, é fácil ver e modificar o nome de uma função sem fazer nenhuma alteração no código básico do programa. Em terceiro lugar, uma função pode ser composta como um único arquivo e usada em outros programas. Isso libera o programador da necessidade de inserir os mesmos fragmentos do código em cada programa recém-criado. 22
A maioria do código em MQL4 é escrito na forma de funções. Esta abordagem tornou-se generalizada e é um padrão agora. Exemplo de um função escrita em MQL4: Veja que ela recebe um único parâmetro de entrada do tipo int.
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. é 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. O script
Um indicador personalizado é
um programa codificado em MQL4 e chamado pelo terminal cliente para ser executado em cada tick. Ele é basicamente destinado a exibição gráfica de dados preliminarmente calculados, como linhas. Indicadores não podem negociar. Existem dois tipos de indicadores: indicadores técnicos (incorporados) e indicadores personalizados. 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. MetaEditor é um editor especializado multifuncional destinado a criar, editar e compilar programas de aplicação escritos em MQL4. O editor tem uma interface amigável que lhe permite navegar facilmente ao escrever e verificar um programa. Veja na imagem como acessar 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. Os EAs estão localizados diretamente no diretório: ClientTerminal_folder\experts . scripts e indicadores estão em subdiretórios: 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. O arquivo executável do MetaEditor ( MetaEditor.exe ) é fornecido como parte do terminal do cliente e está localizado no diretório raiz do terminal. O guia do usuário do MetaEditor é aberto pressionando F1. Contém informações gerais necessárias para a criação de novos programas. O editor pode ser aberto clicando no nome do arquivo MetaEditor.exe ou em um atalho no seu desktop. Estrutura do terminal cliente
Para a conveniência da operação, o MetaEditor possui barras de ferramentas internas: "Navigator" ( Ctrl + D ) e "Toolbox" ( Ctrl + T ).
Criando um novo programa
Geralmente, durante a criação de um novo programa, a caixa de ferramentas e as janelas do navegador são ocultas. Assim, a atenção de um usuário fica concentrada na criação do programa. Para criar um novo programa, vá para o menu Arquivo do editor e clique em Novo . Ou, use o botão para a criação de novos arquivos:
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.
Não precisa marcar nada, basta clicar em Concluir. 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. Existem três funções especiais no programa: OnInit(), OnTick() e Ondeinit(). Cada função contém apenas um Return(0). 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. Mais a frente iremos dar inicio nas implementações e criações de funções. 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.
Além disso, quando um programa é compilado , um novo arquivo (EAFXTRADE_V01.ex4) aparece no diretório correspondente (neste caso, em Terminal_directory\experts). O programa está pronto para operação no terminal cliente MetaTrader4. Durante a compilação, a última versão do texto de origem do programa com o mesmo nome (no nosso caso, é o arquivo create.mq4) será salvo no mesmo diretório. 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.
Se forem detectados erros no programa durante a compilação, o MetaEditor mostrará a mensagem de erro correspondente. Nesse caso, você deve voltar a editar o texto de origem, 32
corrigir os erros e tentar compilar o programa novamente. Uma compilação de programas bemsucedida é possível somente se não houver erros no programa. Usando um programa na prática
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. Um EA e um indicador funcionarão até que um usuário termine a execução do programa manualmente. Um script normal irá parar de operar-se após a execução de seu algoritmo. 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. Talvez alguns comerciantes esperam dificuldades em estudar programação. É difícil para eles imaginar processos complicados em execução no interior de seus computadores. Felizmente, os desenvolvedores de linguagem MQL4 tentou torná-lo amplamente disponível para os usuários. Uma forma agradável de criar programas em MQL4 é que um programador não precisa necessariamente ter um conhecimento especial sobre a interação do terminal cliente com um sistema operacional, de características de protocolo de rede ou de uma estrutura de compilador. O processo de criação de programas em MQL4 é um trabalho simples e fácil. Por exemplo, um motorista não tem que saber uma estrutura de motor para dirigir um carro. Ele só precisa aprender a dirigir. 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.
Estrutura do programa em MQL4 Nas primeiras seções, abordamos algumas noções básicas da linguagem de programação MQL4. Agora vamos estudar como um programa é organizado em geral. Para resolver esse problema, estudaremos seu esquema estrutural. Como mencionado acima, o código do programa principal escrito por um programador é colocado dentro de funções definidas pelo usuário. Em Funções, discutimos a noção e as propriedades das funções internas e definidas pelo usuário. Resumidamente, uma função definida pelo usuário tem uma descrição e uma chamada de função é usada para iniciar sua execução em um programa. Uma função interna ou definida pelo usuário pode ser executada somente depois que ela é chamada. Nesse caso, a função é chamada em alguma parte deste programa. 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. A regra de programação em MQL4 é a seguinte. 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. Consideremos o esquema funcional de um programa comum, um EA.
Veja diretamente no código:
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
A característica distintiva dos programas destinados à operação no terminal cliente MetaTrader 4 é o seu trabalho com informações constantemente atualizadas em tempo real. Na linguagem MQL4, essa peculiaridade se reflete na forma das três funções especiais: OnInit(), OnTick() e OnDeinit(). Normalmente, após a parte do cabeçalho, são descritas funções especiais. A descrição da função especial parece a descrição de uma função definida pelo usuário, mas as funções especiais têm nomes predefinidos: init(), start() ou OnTick() e deinit(). As funções especiais são um bloco de cálculos e estão relacionadas ao ambiente de informação do terminal cliente e às funções definidas pelo usuário. As funções especiais são descritas em detalhe em Funções especiais . A propriedade principal de todas as funções especiais é sua execução em um programa sob certas condições sem usar uma chamada de função especial dentro do programa. Funções especiais são chamadas para execução pelo terminal cliente. Se um programa contém a
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). Função especial OnInit() A propriedade distinta da função OnInit() é a sua execução na inicialização do programa. Se um programa contém a descrição da função especial OnInit(), será chamado e executado no momento em que o programa for iniciado. Se não houver nenhuma função OnInit() em um programa, nenhuma ação será executada no início do programa. Em EAs, OnInit() é chamado e executado após o terminal do cliente iniciar e carregar os dados históricos, depois de alterar o período do gráfico, após a compilação do programa no MetaEditor, depois de alterar quaisquer parâmetros de entrada da janela de configuração do EA, e depois de alterar as contas. Nos scripts , OnInit() também é chamado e executado imediatamente após ele ser anexado a um gráfico. Em indicadores personalizados , OnInit() é chamado e executado imediatamente após o início do terminal do cliente, após alterar o período do gráfico, após a compilação do programa no MetaEditor e depois de alterar quaisquer parâmetros de entrada da janela de configuração do indicador personalizado. Função especial OnTick() As propriedades distintas da função especial OnTick () diferem dependendo do tipo de programa executável. Em EAs , OnTick () é chamado (e executado) imediatamente após um novo tick. Se um novo tick surgiu durante a execução de OnTick (), este tick será ignorado, e OnTick () não será chamado para execução até que um novo Tick seja recebido. 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. A possibilidade de chamar e executar OnTick () é influenciada pelo estado do botão "Negociação Automatizada" estiver ativo. Botão disponível na plataforma MetaTrader 4 conforme imagem:
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. Função especial OnDeinit() A função especial OnDeinit() tem sua execução na terminação do programa. Se um programa contém a função OnDeinit(), ele será chamado e executado no encerramento do programa. Se um programa não contém a função OnDeinit(), nenhuma ação será executada no encerramento do programa. O terminal do cliente chama a OnDeinit() no encerramento do terminal, quando uma janela Gráfica é fechada, antes de alterar um período de gráfico, e em uma nova compilação de programa bem-sucedida no MetaEditor, ao alterar parâmetros de entrada e quando uma conta é Alterada. Em EAs e scripts , o encerramento do programa com a chamada necessária de OnDeinit() pode acontecer ao anexar a um gráfico um novo programa do mesmo tipo que substitui o anterior. Em indicadores personalizados, OnDeinit() não é executado quando um novo indicador é anexado a um gráfico. Vários indicadores podem operar em uma janela de segurança, por isso a conexão de um novo indicador a um gráfico não resulta no desligamento de outros indicadores com chamada OnDeinit(). O tempo de execução da função OnDeinit() é limitado a 2,5 segundos. Se o código da função especial OnDeinit() for executado por mais tempo, o terminal do cliente terminará com força a execução da função OnDeinit(), e a operação do programa.
Em resumo as funções são executadas sempre nesta sequencia: 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. Veja a imagem do Código com Funções definidas pelo Usuário:
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. Veja imagem de uma função padrão 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. Veja o escopo geral.
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.
Seqüência de execução do código
Cabeça e funções especiais
No momento em que um programa é iniciado em uma janela Gráfica, linhas contidas no cabeçalho do programa são executadas. 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. O tempo de operação do programa principal é o período de funcionamento da função OnInit() especial. 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. O processo é repetido enquanto o programa é anexado a um gráfico e pode continuar por semanas e meses. Durante este período, um EA pode realizar negociação automatizada, ou seja, pode implementar a sua atribuição principal. Na Figura anterior, a chamada repetida de OnTick () é mostrada por várias setas amarelas envolvendo a função OnTick () especial. Quando um comerciante remove um EA de um gráfico, o terminal cliente executa a função OnDeinit() uma única vez. A execução dessa função é necessária para o encerramento correto da operação de um EA. Durante a operação, um programa pode, por exemplo, criar objetos gráficos e variáveis globais do terminal cliente. A função OnDeinit() pode conter código para excluir objetos desnecessários e variáveis. Após a conclusão do OnDeinit(), o controle é retornado ao terminal do cliente. As funções especiais executadas podem se referir ao ambiente de informação (veja as finas setas azuis na Figura abaixo) e chamar a execução de funções definidas pelo usuário (veja as finas setas amarelas na Figura abaixo). Observe que as funções especiais são executadas após serem chamadas pelo terminal cliente na ordem predefinida: inicia na OnInit(), depois qualquer número de chamadas de OnTick () e depois OnDeinit(). As condições sob as quais o terminal cliente chama funções especiais são descritas em Funções especiais .
44
Veja a imagem novamente:
Funções definidas pelo usuário
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
As habilidades de programação são mais desenvolvidas se o programador tiver um programa de funcionamento pequeno para fazer testes iniciais. Para entender todo o programa, é necessário examinar minuciosamente todos os seus componentes e rastrear sua operação passo a passo. Observe, propriedades de função especial de diferentes programas de aplicativo (EAs, scripts, indicadores) são diferentes. Aqui vamos analisar como um EA opera. Exemplo de um EA simples:
Este EA é composto de Cabeçalho, com algumas declarações veja a imagem:
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. Inclusive, essa variável pode ser utilizada em qualquer função do programa. Logo a baixo temos a OnInit()
O corpo da função contém apenas dois operadores. 2.1 Function Alert() mostra uma janela de alerta: Acionada no inicio que o EA é ligado a um Gráfico. 2.2 O retorno do operador finaliza o funcionamento do OnInit(). 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(). Na sequencia o Terminal detecta a presença de conteúdo na OnTick (), então essa função é acionada.
Note que na função OnTick (), temos uma variável Price do tipo double, inicializada com o preço de compra. Bid é o preço de cotaçã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. Para finalizar temos a função OnDeinit()
Ela é chamada pelo terminal, quando removemos o EA do gráfico. Neste exemplo foi feito somente uma chamada na função Alert();
Veja o resultado do EA quando ligado a um Gráfico, e na sequencia fazemos a exclusão do EA do Gráfico.
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. Se você entender todos os conceitos e regras, então o processo de criação de programas em MQL4 será fácil e agradável. Exemplo EA Envio de E-mail
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. Ou seja, primeiro vai a descrição de OnInit(), então OnTick (), e a última é OnDeinit(). No entanto, funções especiais são chamadas para execução pelo terminal cliente de acordo com suas próprias propriedades. É por isso que a localização de uma descrição em um programa não importa. Vamos mudar a ordem das descrições e ver o resultado. Nosso próximo EA vai enviar 3 e-mail, sendo: 1. Primeiro e-mail na função OnInit() 2. Segundo e-mail na abertura de um novo Candle na função OnTick() 3. Terceiro e-mail quando o EA for Retirado do Gráfico na função OnDeinit() Veja a imagem do código do EA:
Veja o resultado na caixa de E-mail:
49
Como disse anteriormente, não vou explicar novamente cada função, pois utilizamos as mesmas funções do EA anterior. Veja que recebemos os 3 e-mails conforme era planejado no código. 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. 2. 3. 4.
Acesse o MataTrader4 Clique no Menu Ferramentas e na sequencia clique em Opções. Clique na aba E-mail Preencha os dados na tela a seguir:
Feita a configuração, clique em Testar, será mostrado a seguinte mensagem:
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:
É importante ressaltar que a base de um EA é as 3 funções Especiais.
Exemplo EA Envio de Notificação para Seu Celular Android ou iPhone
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(). 2.Segunda notificação é feita na função OnTick(). 3.Terceira notificação é feita na função OnDeinit().
Veja a imagem abaixo as notificações no Celular:
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. 2. 3. 4.
Acesse o MataTrader4 Clique no Menu Ferramentas e na sequencia clique em Opções. Clique na aba Notificações 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.
Veja a imagem a seguir:
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. Operador de atribuição representa um registro que contém o caractere "=" (sinal de igualdade). À esquerda deste sinal de igualdade especificamos o nome de uma variável, à direita dela damos uma expressão. O operador de atribuição é terminado com ";" (ponto e vírgula).
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. Outros Exemplos de Operador de Atribuição Em um operador de atribuição, é permitido declarar o tipo de uma variável à esquerda do sinal de igualdade: Int In = 3; // O valor constante é atribuído double Do = 2,0; // O valor constante é atribuído bool Bo = true; // O valor constante é atribuído color Co = 0x008000; // O valor constante é atribuído string St = "sss"; // O valor da constante é atribuído datetime Da = D ' 01.01.2004 ';// O valor constante é atribuído
à variável Do à variável Do à variável Bo à variável Co à variável St à variável Da
As variáveis declaradas anteriormente são usadas em um operador de atribuição sem especificar seus tipos. In = 7; Do = 23,5; Bo = 0;
// O valor constante é atribuído à variável In // O valor constante é atribuído à variável Do // O valor constante é atribuído à variável Bo
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:
Em um operador de atribuição, o tipo de uma variável não pode ser repetidamente declarado.
Exemplos de utilização das funções definidas pelo usuário e padrão na parte direita: In = minha_funcao();// O valor da função definida pelo usuário é atribuído à variável In Do = funcao_2();// O valor da função definida pelo usuário é atribuído à variável Do Bo = IsConnected();// O valor da função padrão é atribuído à variável Bo St = ObjectName(0);//O valor da função padrão é atribuído à variável St Da = TimeCurrent();//O valor da função padrão é atribuído à variável Da
O exemplo de usar expressões na parte direita: In=((( minha_funcao() + 100)/2)*3);// A variável In é atribuída com o valor da expressão Do = ((funcao_2()*3)/2);// A variável Do é atribuída com o valor de expressão
Exemplo de Operadores de Atribuição de Forma abreviada. In = In / 33; // Forma padrão In /= 33 ; // Forma abreviada do operador de atribuição In = In * 33; // Forma Padrão In *= 33 ; // Forma abreviada do operador de atribuição In = In + 33; // Forma Padrão In += 33 ; // Forma abreviada do operador de atribuição In = In - 33; // Forma Padrão In -= 33 ;
// Forma abreviada do operador de atribuição
Verifique o programa EAFXTRADE_V04, toda implementação esta disponível nele. Conforme imagem a seguir:
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
Verifique o código no programa EAFXTRADE_V05 Ao Anexar o EA no gráfico de 1 Minuto, e esperar a mudança de Candle, Obtemos o seguinte resultado: 58
Exemplo 2
Vou mostrar outro exemplo de if-else A diferença neste outro exemplo, é que utilizamos um if-else um pouco diferente.
OBS: Lembre que && é operador Booleano. Exemplo: if ((Open[1] > Media_periodo_20)&&(Close[1] < Media_periodo_20)) 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. Se a condição 2 for atendida, ai sim o BLOCO 2 será executado. Neste exemplo o BLOCO 1 ou o BLOCO 2 só serão executados se uma das condições forem atendida. Veja o código do programa a seguir:
Veja o programa EAFXTRADE_V06. Execute o no seu computador e veja o resultado.
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. Se a condição 2 dentro do BLOCO 2 for atendida, ai sim o Alerta será executado. 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 Veja o código do programa a seguir:
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 Foi criado uma função com o nome analise_tendencia_MEDIA_200_72(int BUY_SELL), essa função recebe um parâmetro de entrada qe é do tipo (OP_BUY ou OP_SELL) , esses sinais representam Compra e Venda no Metatrader 4. Dentro desta função criamos o primeiro if-else, onde é testado se eu quero comprar ou vender. Exemplo: if(BUY_SELL == OP_SELL) else if(BUY_SELL == OP_BUY) Se eu passar o parâmetro OP_SELL para a função analise_tendencia_MEDIA_200_72, 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. Nesse caso a execução do programa continua, porem entrando no BLOCO 2 Assim que a execução entra no BLOCO 2, um novo if esta para testar uma nova condição. Exemplo: if((Open[1] < Media200) &&(Close[1] > Media200)) Essa condição significa o seguinte: 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
Veja imagem do programa:
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. Mais a frente vou ensinar a vocês a programação mais complexas.
Operador while e for A funcionalidade mais poderosa do MQL4 é a possibilidade de organizar ciclos (loops). 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 pe ríodos no gráfico atrás de topos e fundos, cálculo de preços, e outras analises. Portanto é bom treinar bastante essa parte. Primeiro teste, vamos descrever brevemente o coeficiente de Fibonacci. O matemático italiano, Leonardo Fibonacci, descobriu uma seqüência única de números: 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. Veja o código do programa abaixo:
66
Veja o código no programa EAFXTRADE_V10 Abaixo tem explicações sobre a função Fibonacci.
67
Deve ser particularmente observado o seguinte: Looping é uma execução continuamente repetida de operadores que compõem o corpo do ciclo. É uma situação crítica que resulta da realização de um algoritmo errado. 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:
No exemplo acima, os valores da variável i são acumulados (incrementados) em cada it eração. 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 deixá -lo mais. Esta situação é particularmente perigosa na negociação Expert Advisors e scripts. 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 ra ciocí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. for (Expressão 1; Condição; Expressão 2) {
bloco de operadores compondo o ciclo }
// cabeçalho do operador // Abertura do Loop // corpo do ciclo //fechando o ciclo
O programa a seguir faz a somatória de números inteiros de 1 a 10, a solução será 1+2+3+4+5+6+7+8+9+10 = 55. 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. Veja a imagem a seguir:
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.
Vamos fazer um outro exemplo parecido usando while.
Veja o programa inteiro no EAFXTRADE_V16. O próximo exemplo é utilizando o operador switch.
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. O operador continue consiste em uma palavra e termina em ";" (ponto e vírgula). 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:
Veja programa completo em EAFXTRADE_V18 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 if (primeira_conta < Limite_maximo_primeira_conta) Se o saldo da primeira conta for MAIOR ou IGUAL o LIMITE_MAXIMO_PRIMEIRA_CONTA, o programa vai executar o bloco marcado em vermelho. 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. O operador 'switch' consiste no cabeçalho e no corpo executável. O cabeçalho contém o nome do operador e uma Expressão entre parênteses. O corpo do operador contém uma ou várias variações 'case' e uma variação 'default'. Cada "caso" consiste na palavra-chave "case", uma constante,":" (dois pontos) e operadores. A quantidade de variações 'case' não é limitada. A variação 'default' consiste na palavra-chave 'default', ':' (dois pontos) e operadores. A variação 'default' é especificada no corpo do operador 'switch' como a última, mas também pode ser localizada em qualquer lugar dentro do corpo do operador ou mesmo estar ausente. Os valores de Expressão e de Parâmetros só podem ser os valores de tipo int . A Expressão pode ser uma constante, uma variável, uma chamada de função ou uma expressão. Cada "case" de variação pode ser marcado por uma constante de número inteiro, uma constante de caractere ou uma expressão constante. Uma expressão constante não pode incluir variáveis ou chamadas de função. Vou exemplificar com um exemplo mostrado anteriormente
Veja programa inteiro EAFXTRADE_V17 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. Veja programa completo em EAFXTRADE_V19 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. O nível de complexidade vai depender da sua criatividade. 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:
Veja programa completo em EAFXTRADE_V20
Veja outro exemplo:
79
Veja programa completo em EAFXTRADE_V21 Veja o resultado na tela de Alerta.
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:
Exemplo chamada a função padrão:
Função com retorno de valor:
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áveis predefinidas e função RefreshRates() Existem variáveis com nomes predefinidos na linguagem 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 ().
Lista de Nomes Predefinidos Simples de Variáveis Ask - último preço de venda conhecido de um título atual; Bid - último preço de compra conhecido de um título atual; Bars - número de barras em um gráfico atual; Point - ponto de um título corrente na moeda de cotação; Digits - número de dígitos após um ponto decimal no preço de um título atual.
Lista de nomes predefinidos de matrizes-Timeseries Time - tempo de abertura de cada barra no gráfico atual; Open - Preço de abertura de cada barra no gráfico atual; Close - preço de fechamento de cada barra no gráfico atual; High - preço máximo de cada barra no gráfico atual; Low - preço mínimo de cada barra no gráfico atual; Volume - volume negociado em cada barra no gráfico atual. Falamos Matrizes pois utilizamos “[0], [1], [2], [3], ...etc” na frete de cada variável. Exemplo: Time[0] ou Time[1] ou Time[1000], não tem limite. Veremos mais em tipos de variáveis
Propriedades de variáveis pré-definidas O nome da variável predefinida não pode ser usado para identificar variáveis definidas pelo usuário. Variáveis predefinidas podem ser usadas em expressões igualmente com outras variáveis de acordo com as mesmas regras, mas o valor de uma variável pré-definida não pode ser alterado. Ao tentar compilar um programa contendo um operador de atribuição, no qual uma variável predefinida é colocada à direita de um sinal de igualdade, o MetaEditor mostrará uma mensagem de erro. Em termos de visibilidade, as variáveis predefinidas referem-se a global, ou seja, estão disponíveis a partir de qualquer parte do programa. A propriedade mais importante de variáveis predefinidas é a seguinte: 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.
Veja programa EAFXTRADE_V22 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. Aqui está outra propriedade importante de variáveis predefinidas: O terminal cliente cria um conjunto de cópias locais de variáveis predefinidas separadamente para cada programa iniciado. Cada programa iniciado funciona com os seus próprios conjuntos de cópias de dados históricos. Em um terminal cliente, vários programas aplicativos (Expert Advisors, scripts, indicadores) podem ser executados ao mesmo tempo, e para cada um deles o terminal cliente criará um conjunto separado de cópias de todos os valores das variáveis predefinidas - dados históricos. Vamos analisar em detalhes as razões para essa necessidade. A figura abaixo mostra a possível operação de Expert Advisors com diferentes comprimentos de execução da função especial OnInit(). Por razões de simplicidade, vamos supor que, nos Analistas Especialistas analisados, não existem outras funções especiais e que ambos os Consultores Especialistas operam nos mesmos prazos da mesma segurança.
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 tickwaiting. 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 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. RefreshRates() retorna TRUE, se no momento de sua execução há informações sobre novos RefreshRates() dados históricos no terminal (ou seja, se um novo tick surgiu durante a execução do programa). Nesse caso, o conjunto de cópias locais de variáveis predefinidas será atualizado. RefreshRates() retorna FALSE, se a partir do momento de uma execução de função especial RefreshRates() iniciar dados históricos no terminal do cliente não foram atualizados. Nesse caso, as cópias locais de variáveis predefinidas não mudam. Tenha em atenção que RefreshRates 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 RefreshRates(). (). veja o exemplo a seguir, onde contamos o número de interações que um operador de ciclo pode executar entre os Ticks.
Veja o programa EAFXTRADE_V23 Veja o resultado da execução do programa.
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áveis locais e globais
Variável local é 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 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. Se o controle em um programa estiver dentro de uma determinada função, os valores das variáveis locais declaradas em uma função não estarão disponíveis em outras funções. O valor de qualquer variável global está disponível para qualquer função, independente se ela é especial ou definidas pelo usuário. Exemplo variável local:
89
Veja programa EAFXTRADE_V24
Agora veja outro exemplo onde a variável é declarada declarada de forma Global:
Com base nos exemplos acima, você já sabe o que é uma variável GLOBAL e 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:
Veja programa EAFXTRADE_V26 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. Você vê, que o programa EAFXTRADE_V26 tem o mesmo resultado do programa EAFXTRADE_V25. 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: As variáveis externas são especificadas na parte do cabeçalho do programa, ou seja, antes de qualquer função. O uso de variáveis externas é muito conveniente se for necessário de vez em quando para iniciar um programa com outros valores de variáveis.(mais conhecidos como parâmetros de Entrada). Veja o Exemplo:
91
Veja programa EAFXTRADE_V27 Valores de variáveis externas estão disponíveis a partir de uma janela de parâmetros do programa. O interessante dessas variáveis é que elas podem ser alteradas a qualquer momento - na fase de anexar o programa a uma janela gráfica e durante a operação do programa. 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. Se um usuário precisar alterar valores de variáveis externas durante a operação do programa, a janela de configuração deve ser aberta e as alterações devem ser feitas. Deve ser lembrado que a barra de ferramentas de propriedades do programa pode ser aberta somente no período em que o programa (Expert Advisor ou indicador) está aguardando uma nova marca, ou seja, nenhuma das funções especiais é executada. Durante o período de execução do programa, esta barra não pode ser aberta. É por isso que se um programa é escrito assim, que é executado longo tempo (vários segundos ou dezenas de segundos), um usuário pode ter dificuldades em tentar acessar a janela de parâmetros. Valores de variáveis externas de scripts estão disponíveis apenas no momento de anexar o programa a um gráfico, mas não podem ser alterados durante a operação. Se a janela de parâmetros estiver aberta, o Expert Advisor não funcionará. Exemplo de como alterar o parâmetros; 1. Clique com botão direito do mouse sobre a janela gráfica. 2. Corra o mouse até Expert Advisors(Robôs) 3. Clique em Propriedades.
Não há limite para criação de Variáveis Externas.
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. Funções para trabalhar com GlobalVariables
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()
Datetime
GlobalVariableSet(string
name , double
value)
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: Name - Nome de uma variável global. Value - Novo valor numérico. Função GlobalVariableGet()
double double
GlobalVariableGet(
string
name )
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: Name - Nome de uma variável global. Função GlobalVariableDel()
bool
GlobalVariableDel(
string de
nome )
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: Name - Nome de uma variável global. Para mostrar a conveniência e benefício de usar GlobalVariables, vamos criar um exemplo para você entender melhor todo o processo. Veja o programa a seguir:
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. Resultado da execução do programa:
Veja que adicionei o programa EAFXTRADE_V28, em 3 gráficos(EURUSD, GBPUSD, USDJPY), a divisão do valor de 10000, foi feita corretamente. 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. Basta acessar o Menu Ferramentas do Metatrader 4, em seguida clique em seguida clique em Variáveis Globais, será aberto a seguinte janela:
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
Se colocarmos o EA EAFXTRADE_V28 em janelas de diferentes títulos e rastrearmos sucessivamente todos os eventos, veremos que o código opera com sucesso. No entanto, é assim somente se pausas entre eventos são bastante grandes. Preste atenção ao operador 'if' em OnDeinit(): 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:
A figura acima mostra o desenvolvimento de eventos relativos ao valor de Quantidade GV. Vamos rastrear como esse valor vai mudar dependendo do que está acontecendo. Suponha que a execução da EA tenha começado no momento t0. Neste momento a Quantidade de GV ainda não existe. No período t0 - t1 A função especial OnInit() do EA é executada, como resultado GV Quantidade é criada, seu valor no momento t1 é igual a 1. Próximos ticks de EUR/USD iniciam a função especial OnTick(). No entanto, no período t0 - t6 existe apenas um EA no terminal cliente, por isso o valor da Quantidade GV não muda. 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: if (Experts ==1) GlobalVariableDel(Quantity);
// If valor da variavel Experts = 1 //..deleta GV
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. Vale apena fazer outros teste! Matrizes
Uma grande parte da informação processada por programas de aplicação está contida em matrizes. Conceito de matrizes
Array é um conjunto arranjado de valores de variáveis de um tipo que têm um nome comum. Arrays podem ser unidimensionais e multidimensionais. A quantidade máxima admissível de dimensões em um array é quatro. Arrays de qualquer tipo de dados são permitidos. Elemento de matriz é uma parte de uma matriz; É uma variável indexada com o mesmo nome e algum valor.
Indexação
O índice de elemento de matriz é um ou vários valores inteiros indicados na forma de uma constante, variável ou expressão enumerada separada por vírgulas, entre colchetes. O índice de elemento de matriz define unicamente o lugar de um elemento em uma matriz. O índice de elemento de matriz é indicado após um identificador de variável (nome de matriz) e é parte integrante de um elemento de matriz. Na indexação MQL4 inicia-se o zer 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. Declaração de matriz e acesso a elementos 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:
O valor dos elementos de matriz na Figura:
são os seguintes: - para uma matriz unidimensional, o valor do elemento Mas[4] é o número inteiro 34; - para matriz bidimensional, o valor do elemento Mas[3,7] é o número inteiro 28; - para a matriz tridimensional, o valor do elemento Mas[5,4,1] é o número inteiro 77. 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:
Int
Mas_i[ 3 ][ 4 ] = {0 , 1 , 2 , 3 , 10 , 11 , 12 , 13 ,20 , 21 , 22 , 23};
double
Mas_d[ 2 ][ 3 ] = {
0.1 , 0.2 , - 0.3 , - 10.2 , 1.5 , 7.0 };
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 Programa EAFXTRADE_V29 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. Arrays definidos pelo usuário
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. Veja a continuação do programa:
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. Veja programa EAFXTRADE_V30 Agora baixe esse programa, e veja o resultado no seu computador. Veja o resultado do teste:
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. Os dados contidos em arrays-timseries possuem uma informação muito importante e são amplamente utilizados na programação em MQL4. Cada array-timeseries é uma matriz unidimensional e contém dados históricos sobre uma determinada característica de barra. Cada barra é caracterizada por um preço de abertura Open[], preço de fechamento Close[], preço máximo High[], preço mínimo Low[], volume Volume[] e tempo de abertura Time[]. Por exemplo, array-timeseries Open[] traz informações sobre os preços de abertura de todas as barras presentes em uma janela de segurança: o valor do elemento array Open[1] é o preço de abertura da primeira barra, Open[2] é o preço de abertura de A segunda barra, e sucessivamente. O mesmo é acontece para os outros timeseries. Barra zero é a barra atual que ainda não se formou completamente. Em uma janela de gráfico a barra zero é a última direita. Barras (índices correspondentes de matrizes-série de tempos) contagem é iniciado a partir da barra zero. Os valores dos elementos array-timeseries com o índice [0] são valores que caracterizam a barra zero. Por exemplo, o valor de Open[0] é o preço de abertura de uma barra zero. A figura a seguir mostra a numeração das barras e características da barra (refletida em uma janela de gráfico quando um cursor do mouse é movido para uma imagem).
Veja na próxima imagem, que iremos mostrar os dados da BARRA 13:
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.
Quer dizer o seguinte: veja a imagem abaixo:
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:
Veja programa EAFXTRADE_V31 O programa acima funciona da seguinte maneira: 1. Criamos duas variáveis (Minimum e Maximum), carregamos o preço delas com o preço de cotação atual. 2. Criamos um “for” que faz a leitura do candle [0] até a quantidade definida na variável “Quant_Bars”
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. A diferença esta no uso da função ArrayMinimum() e da função ArrayMaximum(), com o uso dessas funções não foi preciso utilizar o ‘for’ para passar em todos os 30 candles.
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 programa completo:
Veja programa EAFXTRADE_V32. 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.
Programação de Operações Comerciais Ao programar operações comerciais, você deve considerar os requisitos e limitações relacionados às características de ordens e regras aceitas em seu centro de negociação, bem como as características especiais da tecnologia de execução de ordens comerciais. A seção fornece a descrição detalhada da ordem de realizar transações e contém uma série de exemplos que explicam os fins de todas as funções comerciais utilizadas para formar ordens de comércio. A seção contém alguns scripts prontos para uso restrito. Maneira comum de começar
Todos os cálculos e outras ações executadas devido à execução de um programa aplicativo podem ser divididos em dois grupos pelo local de sua execução: aqueles executados no PC do usuário e aqueles executados no lado do servidor. Uma quantidade significativa de cálculos é realizada do lado do usuário. Este grupo inclui a execução de programas de aplicação. As profissões pertencem ao segundo grupo. Fazer negócios implica conversão de dados no servidor. Considerando os negócios, distinguiremos os seguintes termos: 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. O pedido de comércio é um comando feito por um programa ou por um comerciante a fim executar um comércio. O comércio é abertura, fechamento ou modificação de ordens de mercado e pendentes. Diagrama
Três componentes estão envolvidos na realização de negócios: um programa aplicativo, o terminal cliente (MetaTrader4) e o servidor. Uma solicitação é formada no programa (como 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. Em nenhum outro lugar (nem no terminal do cliente nem no servidor) as solicitações comerciais são formadas espontaneamente. Recursos do Programa
Dependendo do algoritmo, um programa pode formar solicitações diferentes - para abertura, fechamento ou modificação de ordens de mercado e pendentes. As funções comerciais a seguir são usadas em um programa para enviar solicitações de comercio:
OrderSend() – Utilizado para abrir ordens no mercado(execução instantânea ou Pendente). OrderClose () e OrderCloseBy () - para fechar ordens que estão abertas no mercado. OrderDelete () - para excluir pedidos pendentes ; OrderModify () - para modificar Ordens que já estão no mercado e pendentes.
As funções de comércio acima podem ser usadas somente em consultores especializados e scripts. A utilização destas funções nos indicadores é proibida. 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. Recursos do Terminal do Cliente
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. O terminal cliente permite que apenas as solicitações corretas sejam enviadas ao servidor. Se o programa é codificado de tal forma que ele forma, por exemplo, um pedido para abrir uma ordem a um preço não existente, o terminal cliente não enviará esta solicitação ao servidor. Se o programa formar solicitações corretas (os pedidos são abertos e fechados com o preço conhecido mais recente, o valor da ordem está dentro do intervalo limitado pelo centro de negociação, etc.), então esse pedido será enviado ao servidor. Somente um thread de execução é fornecido no terminal do cliente para realizar transações. Isso significa que o terminal cliente pode trabalhar simultaneamente apenas com um pedido. Se houver vários Expert Advisors ou scripts negociando no terminal do cliente e nenhum programa tiver passado uma solicitação de negociação para o terminal do cliente, as solicitações de comércio de todos os outros Expert Advisors e scripts serão rejeitadas até que o terminal cliente complete o processamento do pedido atual, , Até que o segmento comercial seja livre. Recursos do Servidor
As informações sobre o histórico comercial de cada conta (abertura, encerramento, modificação de ordens) são altamente protegidas pelo servidor e têm uma prioridade maior em comparação com o histórico de negócios armazenados no terminal cliente. O direito de executar solicitações comerciais é concedido apenas a um revendedor ou ao servidor que processa solicitações automaticamente (se o centro de negociação fornecer ao servidor esse recurso por um determinado período de tempo). Um pedido que é entregue no servidor pode ser executado ou rejeitado. Se o pedido de comércio é executado (ou seja, uma negociação é feita), o servidor fará todas as conversões necessárias de dados. Se o pedido de comércio é rejeitado, o servidor não converte quaisquer dados. Não importa qual a decisão (para executar ou rejeitar um pedido). 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. Também é possível no lado do servidor proibir o funcionamento de Expert Advisors no terminal do cliente. Às vezes é necessário, se a operação do programa causar conflitos. Por exemplo, se a implementação de um algoritmo incorreto resulta em que o programa forma continuamente solicitações comerciais alternadas para abertura e fechamento de ordens com intervalos de tempo muito pequenos (por exemplo, a cada marca) ou se os pedidos de abertura, exclusão ou Modificação de ordens pendentes são muito frequentes. Existe corretoras que a funcionalidade “Negociação Automatizada” fica desabilitada no servidor,
neste caso, você deve entrar em contato com a corretora para pedir a liberação da funcionalidade. 114
Procedimento de Negociação
O procedimento de realizar transações é interativo e realizado no modo de tempo real. O diagrama abaixo mostra todos os eventos relacionados com a realização de um comércio.
Evento 0. O programa é lançado para execução no momento t0. Evento 1. No momento t1, o programa formou um pedido de comércio como resultado da execução de uma função comercial. A solicitação de comércio é passada para o terminal do cliente. Nesse momento, o programa passa o controle para o terminal do cliente e a execução do programa é interrompida (o ponto vermelho no diagrama). Evento 2. O terminal do cliente recebeu o controle e as informações sobre o conteúdo da solicitação. Dentro do período de tempo entre t2 e t3, o terminal cliente analisa o conteúdo do pedido de comércio e toma uma decisão sobre outros eventos. Evento 3. O terminal cliente executa essa decisão tomada (uma de duas alternativas). Alternativa 1. Se o pedido de comércio formado como resultado da execução de uma das funções comerciais esta incorreto, o controlo é passado para o programa. Nesse caso, o próximo evento será o Evento 4 (isso pode acontecer se, por exemplo, o programa tiver enviado o pedido de abertura de uma ordem, cujo valor exceda o valor da conta disponível). 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. Alternativa 2. Se o programa formou uma solicitação de comércio correto, o terminal cliente envia essa solicitação para o servidor; O próximo evento será Evento 5 (o momento de t5) - o servidor receberá a solicitação de negociação. A ligação entre o terminal cliente e o servidor é estabelecida via Internet, sendo que o tempo gasto no envio do pedido de transação para o servidor (intervalo de tempo entre t3 e t5) é completamente dependente da qualidade da ligação. Para uma conexão de boa qualidade, este período de tempo pode ser de
115
aproximadamente 5 a 10 ms, enquanto que pode ser medido em segundos inteiros em conexão ruim. Evento 5. No momento t5, o servidor recebeu a solicitação de negociação. O servidor pode executar ou rejeitar esta solicitação recebida. A decisão de executar ou rejeitar o pedido pode ser feita no lado do servidor dentro de um certo período de tempo (no momento t6). O intervalo de tempo entre t5 e t6 pode variar de alguns milissegundos a dezenas de segundos, dependendo da situação. Em alguns casos, se o servidor opera no modo automatizado e não há movimentos rápidos no mercado e outros comerciantes não são muito ativos, o pedido de comércio pode ser executado ou rejeitado em vários milissegundos. Em outros casos, se o servidor está sobrecarregado devido à alta atividade dos comerciantes e se a decisão sobre a execução ou rejeição do pedido é feita por um negociante humano, Evento 6. Se não houver mudanças consideráveis no mercado dentro do intervalo de tempo desde o momento da formação do pedido de comércio pelo programa (t1) até o momento da tomada de decisão pelo servidor (t6), o pedido de comércio será executado, como uma regra. Se o preço do símbolo mudou dentro deste tempo ou o valor da ordem a ser aberta é superior ao patrimônio líquido livre da conta no momento de tomar a decisão, ou outros impedimentos ocorrem, então o servidor decide rejeitar o pedido de comércio. 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. Evento 7. O terminal do cliente recebeu a resposta do servidor. A resposta do servidor segue o mesmo caminho através da Internet como a solicitação entregue ao servidor. De modo que o tempo gasto com o recebimento da resposta do servidor depende completamente da qualidade da conexão. De acordo com as modificações feitas no servidor, o terminal cliente irá refletir as alterações correspondentes. Por exemplo, se a execução de uma solicitação de negociação resultar no fechamento ou abertura de uma ordem, o terminal do cliente exibirá este evento graficamente na janela de símbolo e textualmente na janela 'Terminal' (nas guias 'Negociação' e 'Histórico da conta'). . Se o servidor tiver rejeitado a solicitação de comércio, nenhuma alteração será feita em qualquer janela do terminal cliente. Evento 8. O terminal do cliente concluiu a exibição de alterações e está passando o controle para o programa. Evento 9. O programa recebeu o controle e pode continuar operando. Conflitos em fazer negócios. Erro 146
Ao considerar acima as características do terminal do cliente, mencionamos que o terminal do cliente poderia processar apenas um pedido por vez. Vamos agora considerar quais eventos ocorrerão se várias solicitações formadas por diferentes programas forem passadas para o terminal cliente. 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
Antes de começar a descrever as funções comerciais, devemos considerar parâmetros que caracterizam os preços de mercado, os tipos de pedidos, suas características, bem como as regras para fazer negócios. Características dos símbolos
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). Spread é a diferença entre o maior e o menor preço em pontos.
Tipos de Ordem e Características
Existem seis tipos de ordem no total: dois tipos de ordens de mercado e quatro tipos de pedidos pendentes. Buy é uma ordem de mercado que define a compra. Sell é uma ordem de mercado que define a venda.
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. Lot é a quantidade de lotes. 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. Requisitos de negociação e limitações
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. Ao calcular preços corretos, também é necessário considerar as limitações do provedor de serviços (centro de negociação). Essas limitações incluem a distância mínima e a distância de congelamento. Essas limitações significam que o corretor precisa de algum tempo para os preparativos para a realização de novos negócios, seja convertendo uma ordem pendente em um mercado ou fechando uma ordem por ordem stop. Os centros de negociação limitam o valor da diferença mínima admissível entre o preço de mercado e o preço solicitado de cada ordem de paragem de uma ordem de mercado, entre o preço de mercado e o preço pedido de uma encomenda pendente, bem como entre o preço pedido de um pedido pendente Ordem e os preços solicitados de suas ordens de parada. Isso significa, por exemplo, que em uma solicitação de abertura de uma ordem de mercado, você 119
