Três Aspectos Sobre Automação da Negociação Manual. Parte 1: Negociação
2 430
0
Introdução
Ao longo dos anos de trabalho em desenvolvimentos para a plataforma de negociação MetaTrader 4, eu tentei um monte de modelos e abordagens para a criação de uma estação de trabalho automatizada para um trader. A primeira solução, a mais óbvia foi implementada no conjunto de scripts de negociação Mouse Only Trader, por sinal foi bastante bem sucedida. Tendo reforçado com cálculos de gestão de riscos e funções de gerenciamento de dinheiro, eu desenvolvi uma ferramenta bastante funcional chamado Trading Mouse.
Saturado por desenvolvedores que principalmente olham como um meio de criar robôs de negociação totalmente automatizados, o terminal de negociação MetaTrader 4 e sua ergonomia parecia ser absolutamente inadequado para pessoas que precisam de um espaço de trabalho confortável. Então eu comecei a experimentar uma interface gráfica, ao olhar para as possibilidades de usar um mouse e teclado diretamente no gráfico de negociação. O resultado do experimento foi representado por dois produtos muito bem destacados: Trading Console e Buy/Sell.
Infelizmente, houve um reverso a todos os seus grandes recursos e facilidade de uso - os Expert Advisors mostraram pouca resposta as alterações rápidas de preços e execução de comandos de negociação. O terminal passou mais tempo desenhando os recursos da interface do que negociando. Todas as tentativas de negociação através dessa interface aparentemente fácil de usar, envolveram uma quantidade justa de problemas (especialmente em pipsing e scalping).
Fig. 1. Variantes de interface.
Depois de ter reconsiderado os requisitos para o Expert Advisor na luz desses fatos, eu criei um Scalper que poderia oferecer o máximo de eficiência no apelo mínimo do olho. Infelizmente, ainda tinha velhos defeitos sob a forma de processamento de comando do mouse ou a utilização de um sensor de tela. Como resultado, ele acabou por ser um produto de nicho principalmente destinado para tablets. Eu consegui finalmente me livrar de praticamente todos os óbices apenas no Simple Trader, que forneceu a base do Expert Advisor introduzido neste artigo.
Eu descrevi intencionalmente a evolução dos meus produtos para ajudar você a entender, tudo o que foi estabelecido neste artigo não foi derivado dos fatos ao acaso, onde o autor não tivesse experiência. É justo que depois de muita tentativa e erro, eu tenha encontrado uma solução mais simples e confiável, a qual quero compartilhar com você.
Uma Imagem Vale Mais do que 1.000 Palavras
Antes de começarmos, primeiro vamos olhar o funcionamento do Expert Advisor a ser considerado. O vídeo vai lhe dar uma idéia dos processos que ocorrem no terminal durante a negociação, como resultado, o artigo será muito mais fácil de entender.
Para uma melhor compreensão do vídeo, é o suficiente saber que existe um Expert Advisor que opera no terminal, gerenciado por scripts de controle na janela do terminal. O Expert Advisor em si não negocia, ele somente movimenta os níveis de parada (Stop Loss e Take Profit) após receber um comando a partir do trader. Os nomes dos scripts correspondem claramente a suas respectivas ações, enquanto o uso é explicado nas dicas de ferramentas.
Agora que temos uma idéia geral do assunto deste artigo, vamos olhar para ele.
Princípios Básicos de Automação da Negociação Manual
Primeiro de tudo, gostaria de dizer que sou muito impaciente para negociar diariamente, eu fico com uma posição aberta mais do que um dia somente em caso de uma tendência absolutamente estável e claramente forte. Meu período de trabalho é de 5 e 15 minutos. Há muito barulho no gráfico de minuto, enquanto que os gráficos de hora matam a minha paciência. Muitos de vocês pensam de imediato: duas MAs, jacaré, telas de Elder, etc. - como podemos trabalhar sem os timeframes maiores? Não podemos usá-los para identificar tendências de curto prazo e os pontos de entrada no mercado? Eu não os uso de forma explícita. Em vez disso, eu trabalho muito bem com uma combinação do zigzag com gráfico de ponto e figura, eu ploto com com base no timeframes de 5 e 15 minutos em andamento. No entanto, este não é o ponto agora, estamos a falar de traders intraday, o que fazem é praticamente um clássico escalpelamento. Monitoram com muito cuidado o preço em andamento e respondem instantaneamente aos impulsos do mercado!
Esta consciência intraday me permitiu simplificar drasticamente os requisitos para o sistema de negociação. O EA usa apenas uma ordem para cada símbolo! Sem atrasos: se você verifica que o preço vai contra você, fecha a posição com o mínimo de perda, ou abre uma posiçãos na direção oposta, ou espera por melhores condições para uma entrada na mesma direção. Nada de bloqueio ou grades, se você não tem certeza da direção para abrir uma posição, simplesmente não abri-la! Esta declaração provavelmente pode parecer controversa, mas é assim que eu negocio e esta abordagem foi seguida no Expert Advisor a ser descrita neste artigo.
A decisão de usar uma ordem por símbolo resolveu num "tapa" todos os problemas relacionados com a seleção interativa de uma ordem de trabalho para fins de modificação e encerramento. Como resultado, o código do Expert Advisor foi reduzido em várias vezes, assim como os erros no código. Entre os recursos automáticos estão as condições de abrir /modificar/fechar ordem rapidamente e a aplicação do princípio clássico de negociação: "deixe seus lucros correrem", na forma de uma execução automática do trailing stop. Em contraste com o padrão de trailing stop implementado no terminal, o apresentado neste Expert Advisor é totalmente controlado pelo trader e pode a qualquer momento ser facilmente modificado, de acordo com a rápida evolução das condições do mercado.
Mas a principal diferença do trailing stop padrão é a possibilidade de definir o preço de desencadeamento. Logo após a abertura, você pode especificar o preço em cima do objetivo, de tal forma que o Expert Advisor vai começar a trilhar o lucro acumulado. Isto será muitas vezes o preço pelo qual o Take Profit está definido. Surge a pergunta: por que cortar o lucro nesse nível se continua a crescer ainda mais?! Como não podemos saber de fato se vamos começar a ter lucro naquele momento, então deixamos correr usando o controle automático do Trailing Stop.
Sabendo Bem Como Conhecer
Eu não acho que eu estou explorando um novo terreno, dizendo que a única maneira de executar manualmente um comando de negociação seja através de um determinado script, as ações são realizadas no momento que o script é acionado no gráfico. Ao contrário do script, o Expert Advisor tem de esperar a próxima escala para desencadear o início, mas sobre o novo tick, o preço pode ser bem diferente do que você esperava, provavelmente não é tão importante quando a negociação em períodos maiores, mas na negociação intraday agressiva, tais atrasos são inaceitáveis.
No entanto numa janela, você pode executar somente um script de cada vez, assim que você começar a executar um novo script, o script anterior para de trabalhar. A funcionalidade do script é reconhecidamente muito mais pobre do que as capacidades de um Expert Advisor, então eu decidi dividir o funcionamento do Expert Advisor em duas etapas: gerar o comando de negociação e a execução. Como resultado, temos um conjunto de scripts que não realizam quaisquer ações específicas, mas apenas transmitem ao Expert Advisor os detalhes do que ele precisa fazer.
Para unificar este mecanismo de comando, eu decidi não incluir quaisquer ações de negociação significativas nos scripts, cada um é associado ao comando específico que tem um índice numérico único (abrir uma ordem, modificar o Stop Loss/Take Profit, fechar uma ordem). Então quando um script é acionado no gráfico, sabemos o comando que deseja executar. O preço e, se necessário, o tempo para execução de comandos podem ser definidos usando as coordenadas de ponto para acionar, somente precisamos verificar como transmitir os dados relacionados com o acionamento do script no gráfico pelo Expert Advisor.
Durante o desenvolvimento de versões anteriores, eu tentei quase todos os métodos adequados de comunicação programa a programa, usando software ao nível de sistema operacional e o Win32API:
- escrita/leitura via arquivos de disco ou via mapeamento de arquivo na memória,
- interação usando protocolos HTTP,
- utilização de processadores de mensagens, etc.
Eles tinham características bem bacanas (por exemplo, negociação espelho em várias contas e em diferentes terminais ou o controle remoto de um Expert Advisor operando em VPS), mas infelizmente todos eles eram muito trabalhoso em termos de implementação e suporte, não valeu a pena. Eu consegui me livrar do desnecessário com a experiência, deixando a única escolha certa - o uso de variáveis globais do terminal. A interação do script com o Expert Advisor na forma final resume o seguinte:
Benefícios e Recursos do Mecanismo de Comando do Script Global
A primeira vantagem clara é a utilização de mecanismos da plataforma padrão que asseguram uma interação confiável. O código fonte do Expert Advisor torna-se significativamente reduzido e fica livre do excesso, extensões .ex4 e bibliotecas .dll tornam-se mais fácil de modificar e manter,
A característica mais marcante deste mecanismo é a possibilidade de operar no modo visualização do Testador de Estratégia, permitindo que você facilmente melhore suas habilidades de negociação e suas táticas no acelerado modo "reprodução de mercado"! Você pode definir qualquer velocidade conveniente reproduzindo as cotações e praticar... Ao contrário de uma conta de demonstração que oferece operação junto com o mercado, na velocidade do mercado ao vivo, o visualizador está disponível em todos os momentos (mesmo nos fins de semana, quando nenhuma conexão com a Internet está disponível). Você pode pausar a qualquer momento (para tomar um cafezinho ou a fim de realizar uma análise complexa da situação em andamento) e determinar a eficácia dos seus métodos de negociação, executando através do histórico de vários meses em apenas um par de minutos, utilizando o controle de velocidade da reprodução.
Igualmente importante é a possibilidade de negociar com este Expert Advisor, usando sinais vindos praticamente de qualquer indicador, onde não seria possível negociar por conta própria, os indicadores no gráfico têm como regra simplesmente exibir um determinado objeto gráfico, ou seja, um sinal para entrar no mercado ou fechar uma ordem, infelizmente isso é tudo o que eles podem fazer. Em geral, é impossível negociar ou executar o código no Testador de Estratégia, mas se você tem o código fonte do indicador, você somente precisa modificá-lo, adicionando um bloco para criar as variáveis globais necessárias (que é apenas algumas linhas no código fonte) e chamar no ponto ao qual o indicador define o seu sinal. Você não terá de se preocupar com a repetição do sinal em cada tick! Desde que o Expert Advisor somente pode abrir uma ordem por símbolo, um comando repetido não vai fazer o Expert Advisor abrir novas ordens infinitamente. Com tal indicador de comando na mão, você poderá testar facilmente sinais de negociação do indicador no Testador de Estratégia: basta começar a testar o Expert Advisor, anexar o seu indicador no gráfico principal e verificar como o Expert Advisor opera com base no indicador sinais.
Temos o suficiente como informação teórica, é hora de avançar para a implementação prática da idéia.
Parâmetros de Comandos e Controle
Cada script de controle cria diversas variáveis globais que são usadas para transmitir os seguintes parâmetros ao Expert Advisor:
-
#Trader-Chart - manipulador da janela na qual o script é acionado. Precisamos dele para permitir o funcionamento de vários Expert Advisors diferentes num terminal (por exemplo, para símbolos diferentes ou em diferentes intervalos de tempo). Ao ser acionado em uma determinada janela, o script recebe o seu manipulador. Este comando será manipulado pelo Expert Advisor que está anexado na mesma janela. Assim, diferentes Expert Advisors somente manipularão comandos correspondentes, ignorando o resto. O manipulador é obtido utilizando a função WindowHandle().
-
#Trader-Command - Código de comando. Infelizmente, o terminal permite armazenar somente números em variáveis globais, então somente podem ser atribuídos códigos numéricos a elas, não existe a possibilidade de atribuir valores de string. Para garantir a sincronização entre os valores do Expert Advisor e os scripts, usamos o arquivo "include", #Trader-commands.mqh, com as seguintes definições:
#define COMMAND_NOACTION 0 #define COMMAND_OPEN 1 #define COMMAND_MODIFY 2 #define COMMAND_CLOSE 3 #define COMMAND_TRALSTART 4 #define COMMAND_TRALSTOP 5 #define COMMAND_TRALSTART0LOSS 6 #define COMMAND_TRALSTART50PROFIT 7
Se você precisa adicionar novo comando, basta adicionar seu código "COMMAND_MYNEWCOMMAND" e atribuir um código único, permitindo que você dimensione praticamente infinitamente a funcionalidade de sua versão do Expert Advisor.
-
#Trader-Price - O preço do script no ponto de acionamento. Normalmente é uma nova ordem na abertura do preço, Stop Loss ou Take Profit ou gatilho automático de preço ao Trailing Stop.
-
#Trader-Time - Tempo para gerar o comando de negociação. É um parâmetro muito importante, não permitirá que o Expert Advisor manipule quaisquer comandos antigos pendurados, seja qual o motivo que permaneça no terminal, para este efeito existe um parâmetro especial na Expert Advisor - ExecDelaySec. O Expert Advisor verifica o tempo vigente do terminal antes de executar um comando e se o tempo armazenado no script é maior do que o tempo vigente em segundos pelo ExecDelaySec, o comando não será executado e seus detalhes serão simplesmente excluídos.
Códigos Fonte dos Scripts de Controle
Em vista do acima exposto, verifica-se que os códigos de todos os scripts são quase idênticos, sendo o código de comando a única diferença. Portanto, toda a parte comum foi organizada como um arquivo separado .mqh para ser incluído em todos os scripts de controle, ele prevê apenas funções mínimas de controle associadas à disponibilidade de negociação.
Todo o resto deve ser feito no terminal.
#property link "http://forextools.com.ua" #include <stderror.mqh> #include <WinUser32.mqh> #import "user32.dll" int RegisterWindowMessageA(string lpstring); int PostMessageA(int hWnd,int Msg,int wParam,int lParam); #import void start() { if ( !IsExpertEnabled() ) { MessageBox("Experts disabled. Action canceled.","SimpleTrader ERROR", MB_ICONERROR); return; } if ( !IsTradeAllowed() ) { MessageBox("Trade disabled. Action canceled.","SimpleTrader ERROR", MB_ICONERROR); return; } if ( IsTradeContextBusy() ) { MessageBox("Trade context is busy. Action canceled.","SimpleTrader ERROR", MB_ICONERROR); return; } GlobalVariableDel ( "#Trader-Chart" ); GlobalVariableDel ( "#Trader-Command" ); GlobalVariableDel ( "#Trader-Price" ); GlobalVariableDel ( "#Trader-Time" ); // Para permitir que vários EAs manipulem os scripts acionados, apenas sobre janelas PRINCIPAIS GlobalVariableSet ( "#Trader-Chart", WindowHandle( Symbol(), Period()) ); GlobalVariableSet ( "#Trader-Command", COMMAND_ID ); GlobalVariableSet ( "#Trader-Price", NormalizeDouble ( WindowPriceOnDropped(), Digits ) ); GlobalVariableSet ( "#Trader-Time", TimeCurrent() ); // Emulação do tick de entrada para iniciar o Expert Advisor int hwnd = WindowHandle(Symbol(), Period()); int MT4InternalMsg = RegisterWindowMessageA("MetaTrader4_Internal_Message"); PostMessageA(hwnd, MT4InternalMsg, 2, 1); }
O próprio código do script consiste em algumas linhas:
#property copyright " Abertura de posição comprada ou vendida de acordo com o acionamento do preço do nível Stop Loss" #include "#Trader-commands.mqh" int COMMAND_ID = COMMAND_OPEN; #include "#Trader-common.mqh"
#property copyright é utilizado para gerar o texto da descrição no terminal. Este texto para comandos simples parece ser óbvio, mas se você decidir adicionar os seus próprios comandos ao Expert Advisor, pode exigir uma boa descrição em conjunto com um nome significativo.
Esta linha é seguida por códigos de comando do arquivo geral. O código geral executável fornece alguns parágrafos acima como vem a seguir, depois estabelece um código de comando para um determinado script,
Aqui é onde nós paramos de trabalhar com os scripts de controle e vamos para a operação do Expert Advisor.
Lógica do Expert Advisor para Automação da Negociação Manual
Inicialmente eu queria apresentar o algoritmo de operação do Expert Advisor na forma de um fluxograma. Mas ficou tão simples e direto que o texto vai cumprir o objetivo.
Os parâmetros de entrada do Expert Advisor são tão minimalista como a lógica fundamental. O que é controlado por cada parâmetro será descrito mais tarde na medida que avançarmos com a explicação dos blocos correspondentes do código fonte do Expert Advisor.
#property copyright "Copyright © 2006-2013, Sergey Kravchuk. http://forextools.com.ua" #property link "http://forextools.com.ua" #include <stdlib.mqh> #include "scripts\#Trader-commands.mqh" extern int MaxAllowedRisk = 2; // Percentagem máxima admissível de perdas extern int OpenSlippage = 2; // Distância a partir do preço vigente para colocar uma ordem de abertura de posição extern int CloseSlippage = 10; // Máximo desvio permitido ao fechar uma ordem extern int ExecDelaySec = 10; // Atraso máximo permitido a partir do INÍCIO da execução do comando extern int ShowClosedCnt = 5; // Número de ordens a mercado fechadas para a exibição do histórico extern int TralStep = 5; // passo para mudança de preço do trailing extern color TralStartColor = BlueViolet; extern color Tral0LossStartColor = LimeGreen; extern int Tral0LossGap = 10; // Deslocamento a partir do preço de abertura para o ponto de empate no trailing // setas coloridas para abertura e fechamento de ordem extern color MarkBuyColor = Blue; extern color MarkSellColor = Red; extern color MarkModifyColor = Magenta; extern color MarkCloseColor = Gray; extern int MessageShowSec = 30; // Tempo de exibição em segundos da última mensagem na tela extern bool ShowComment = true; extern bool WriteGadgetFile = true;
O Expert Advisor primeiro recebe os parâmetros do terminal para cálculos dos preços em andamento (dependendo se ele está funcionando no visualizador ou numa conta ativa). Se houver um pedido aberto no símbolo do gráfico de trabalho, ele é imediatamente selecionado pelo operador OrderSelect.
// Obtém parâmetros dinâmicos Spread = MarketInfo ( Symbol(), MODE_SPREAD ); StopLevel = MarketInfo ( Symbol(), MODE_STOPLEVEL ); // atualização dos preços (em vez de Ask e Bid, o Testador de Estratégia usa Close[0]) if ( IsTesting() ) { CurBid = Close[0]; CurAsk = Close[0]+Spread*Point; } else { CurAsk = Ask; CurBid = Bid; } // Seleciona qualquer ordem aberta (para possíveis modificações), incluindo ordens Limitadas // Por exemplo, poderá definir o Take Profit SelectedOrder = 0; for ( i = 0; i < OrdersTotal() && SelectedOrder <= 0; i++ ) { OrderSelect ( i, SELECT_BY_POS, MODE_TRADES ); if ( OrderSymbol() == Symbol() && OrderMagicNumber() == MAGIC ) SelectedOrder = OrderTicket(); }
No caso de haver uma ordem aberta para o símbolo atual, nós puxamos o Trailing Stop. A adequação e o desempenho desta ação serão definidas pelo procedimento recebido de um único parâmetro - TralStep. Se não houver nenhuma ordem aberta, os parâmetros de trailing são resetados. Isso é necessário porque a ordem pode fechar em cima do desencadeamento do nível Stop e o Expert Advisor, em contraste com o fechamento manual, não saberá se esses parâmetros precisariam ser redefinidos.
// preço de desencadeamento do trailing existe enquanto houver uma ordem aberta!!! if ( SelectedOrder <= 0 ) { ZeroLossTral = false; HalfProfitTral = false; PrevPrice = 0; TralStart = 0; } // trailing (a verificação e execução - dentro do Trailing Stop) else TrailingStop ( TralStep );
Nós ainda verificamos se o comando de controle destina-se a nossa janela. Se este é um comando de outro script, o Expert Advisor vai simplesmente exibir informações atualizadas sobre a conta e ordens abertas. Se este é um comando importante, o Expert Advisor vai ler seus parâmetros e excluir imediatamente as variáveis globais de comando (por exemplo, para não abrir acidentalmente várias ordens).
// se o script é destinado para outra janela, apenas atualiza as informações. if ( GlobalVariableGet ( "#Trader-Chart" ) != WindowHandle( Symbol(), Period()) ) { ShowInfo(); return; } // se o destino for a janela correta, executa os comandos // Obtém o código e preço do comando a partir das variáveis globais e imediatamente são excluídas. if ( GlobalVariableCheck( "#Trader-Command" ) == false ) { CmdID = 0; CmdPrice = 0; ShowInfo(); return; } // Existe um comando, então nós o executamos CmdTime = GlobalVariableGet ( "#Trader-Time" ); CmdID = GlobalVariableGet ( "#Trader-Command" ); CmdPrice = NormalizeDouble ( GlobalVariableGet ( "#Trader-Price" ), PriceDigits ); GlobalVariableDel ( "#Trader-Command" ); GlobalVariableDel ( "#Trader-Price" ); GlobalVariableDel ( "#Trader-Time" ); // Se o comando foi gerado mais cedo do que o atraso de execução admissível, não faz nada! if ( CmdTime+ExecDelaySec*60 < TimeCurrent() ) { SetError("Igore command from " + TimeToStr(CmdTime,TIME_DATE+TIME_SECONDS) + " delayed > " + ExecDelaySec + "sec"); ShowInfo(); return; }
Isto é seguido pela execução do comando e exibição dos resultados da execução. O código fonte do Expert Advisor é fornecido juntamente com comentários, se necessário, certamente você não deve enfrentar qualquer dificuldade de ler e entender isto. No entanto, existem alguns pontos que necessitam de mais esclarecimentos.
Observe:
-
Não podemos negociar sem os níveis Stop.
Uma ordem é sempre aberta com um nível Stop presente. O tamanho do lote é selecionado tendo em conta o nível Stop para que as perdas (se acionadas) não excedam a porcentagem predefinida dos fundos disponíveis para negociação. Esta regra também é verificada quando modificar o nível Stop, do contrário, você não abrirá a um risco baixo e não poderá definir o nível Stop, o que fara você perder o resto do seu depósito. Esta regra indiretamente leva a outra.
-
Nós abrimos apenas ordens Limitada.
Alguns centros de negociação não permitem abrir ordens a mercado com Stop Loss e Take Profi predefinido, pelo fato de uma ordem ter chance abrir com um desvio, sendo teoricamente possível, numa operação de compra ou venda, que o seu nível de stop possa vir a ser mais elevado do que o preço de abertura. Esta situação é de fato muito provável num mercado volátil com um nível baixo de stop. Para evitar esta restrição, nós abriremos uma ordem limitada com um pequeno desvio em relação ao preço atual (desvio acima mencionado), o que nos permite colocar uma ordem exatamente onde ela é necessária, de modo que o nível Stop não exceda a percentagem de risco especificada. Se o mercado se move na nossa direção, a ordem será aberta em apenas alguns ticks. Se o mercado for contra nós, teremos a oportunidade de fechar a ordem limitada não utilizada, sem prejuízos ou movê-la para um lugar melhor.
Abrindo uma Ordem
Depois de analisar a situação atual e selecionar a direção de negociação, decidir sobre a posição do nível Stop para a ordem ser aberta e acionar o script #OPEN. A posição do Stop Loss é também utilizada para determinar a direção de negociação. O Stop Loss para uma ordem abaixo do preço de abertura, pelo acionamento do script, significa que você está indo comprar, da mesma forma que um Stop Loss acima do preço atual irá sugerir a abertura de uma ordem de venda. A única exceção a essa regra é um Stop Loss dentro do spread, como regra isto não será permitido, pois você não poderá definir um Stop Loss mais perto do que é especificado no parâmetro StopLevel.
Apesar de uma grande quantidade de texto descrevando as regras de abertura, o respectivo código é de apenas três linhas:
// Obtém parâmetros dinâmicos Spread = MarketInfo ( Symbol(), MODE_SPREAD ); StopLevel = MarketInfo ( Symbol(), MODE_STOPLEVEL ); // atualização dos preços (em vez de Ask e Bid, o Testador de Estratégia usa Close[0]) if ( IsTesting() ) { CurBid = Close[0]; CurAsk = Close[0]+Spread*Point; } else { CurAsk = Ask; CurBid = Bid; } … // Determina a direção de negociação if ( CurBid <= CmdPrice && CmdPrice <= CurAsk ) { SetError("Stop inside spread. Undefined trade direction."); ShowInfo(); return; } if ( CmdPrice < CurBid ) { Operation = OP_BUYSTOP; PriceForOrder = CurAsk+(StopLevel+OpenSlippage)*Point; MarkOpenColor = MarkBuyColor; } if ( CmdPrice > CurAsk ) { Operation = OP_SELLSTOP; PriceForOrder = CurBid-(StopLevel+OpenSlippage)*Point; MarkOpenColor = MarkSellColor; }
Ao abrir uma ordem, existe ainda um outro mecanismo que lhe permite acelerar o processo de negociação - a possibilidade de inverter a posição "automaticamente". Se você tem uma ordem de compra aberta e verifica que o mercado está descendendo, você poderá fechar a compra e abrir uma ordem de venda, você pode executar a ordem simplesmente acionando o script de abertura. Em caso de reversão da posição, o Expert Advisor irá analisar a situação e fechará a primeira ordem aberta (desde que esteja aberta) e então abre a posição contrária.
// Se esta é a abertura na direção oposta, fechamos a primeira ordem atual (se existir) if ( SelectedOrder > 0 ) { if ( ( Operation == OP_BUYSTOP && ( OrderType() == OP_BUY || OrderType() == OP_BUYSTOP ) ) || ( Operation == OP_SELLSTOP && ( OrderType() == OP_SELL || OrderType() == OP_SELLSTOP ) ) ) { SetError("Only one order per symbol is allowed"); ShowInfo(); return; } // Se as ordens são direcionadas diferentemente, feche a anterior { if ( OrderType() == OP_BUY || OrderType() == OP_SELL ) { // atualização com os preços atuais // no Testador Estratégia, Close[0] é usado em vez do Ask e Bid if ( IsTesting() ) { CurBid = Close[0]; CurAsk = Close[0]+Spread*Point; } else { CurAsk = Ask; CurBid = Bid; } if ( OrderType() == OP_BUY ) PriceForOrder = CurBid; else PriceForOrder = CurAsk; OK = OrderClose ( OrderTicket(), OrderLots(), PriceForOrder, CloseSlippage, MarkCloseColor ); } else { OK = OrderDelete ( OrderTicket(), MarkCloseColor ); // Linhas e setas das ordens Limitadas deletadas (para não sobrecarregar a tela com informações) for(i = ObjectsTotal()-1; i >= 0 ; i--) if ( StringFind(ObjectName(i),"#"+SelectedOrder) == 0 ) ObjectDelete(ObjectName(i)); } if ( OK == false) { SetLastError("Close on reverse"); return; } // falhou a exclusão - não faz nada } }
Gerenciamento de Dinheiro e Percentual de Risco Permitido
Depois de determinar a direção de negociação, precisamos determinar o volume de negociação. O lote para uma ordem ser aberta é calculado pelo Expert Advisor a fim de que o percentual permitido de perdas não seja excedido. O algoritmo de cálculo é muito simples: ele determina o valor de ponto para um lote padrão que é usado para calcular as perdas incorridas no nível Stop especificado pelo script. Seguindo a regra pro rata, o tamanho do lote é reduzido tanto quanto o valor pelo qual as perdas do lote padrão excederem a percentagem máxima permitida de risco, associado com os recursos disponíveis.
// Calcular o lote requerido com base nas perdas especificadas no nível Stop Loss = AccountBalance() * MaxAllowedRisk / 100.0; // Valor das perdas permitidas expresso como uma percentagem de balanço PriceInPoint = MathAbs ( PriceForOrder - CmdPrice ) / Point; SL1lot = PriceInPoint * TickValue; // Tamanho do nível Stop expresso em valor monetário para uma transação de lote único. Lot = Loss / SL1lot; // permitir risk / SL1lot Lot = NormalizeDouble ( MathFloor ( Lot / LotStep ) * LotStep, LotDigits );
Se o nível Stop está muito alto, então o percentual de risco é baixo, o tamanho do lote necessário pode parecer ser menor que o valor mínimo permitido. Será facilmente verificado, depois de constatada a impossibilidade de abertura e o valor máximo possível do Stop Loss.
if ( Lot < MinLot ) { OnePipCost = TickValue * MinLot; // Recalcular o valor de ponto ao lote mínimo possível SetError("Stoploss "+DoubleToStr(PriceInPoint,0) +" > max available "+DoubleToStr(MathAbs (Loss / OnePipCost),0)); ShowInfo(); return; }
Definindo o Stop Loss muito próximo, mesmo tendo especificado um percentual bastante elevado de risco, o lote excedendo ao máximo tamanho permitido, será dada uma mensagem de alerta relevante:
if ( MaxLot < Lot ) { OnePipCost = TickValue * MaxLot; // Recalcular o valor do ponto ao lote mínimo possível SetError("Stoploss "+DoubleToStr(PriceInPoint,0) +" < min available "+DoubleToStr(MathAbs (Loss / OnePipCost),0)); ShowInfo(); return; }
Modificação de Ordem
Se você precisa definir o Take Profit ou mover o Stop Loss para outro nível de preços, acionar o script #MODIFY para o ponto de preço adequado no gráfico. O Expert Advisor descobrirá exatamente o que tem de ser modificado (Stop Loss ou Take Profit) e altera a ordem em conformidade. Aqui, usamos a mesma técnica para abrir uma ordem: se o preço modificado é menor do que o preço atual de uma compra, isso significa que é uma modificação de Stop Loss. Modificação de preço mais elevado está associada ao Take Profit.
// Determinar o que precisa ser modificado if ( ( (OrderType() == OP_BUY || OrderType() == OP_BUYSTOP) && CmdPrice >= CurAsk ) || ( (OrderType() == OP_SELL || OrderType() == OP_SELLSTOP) && CmdPrice <= CurBid ) ) TP = CmdPrice; else // modificar oStop Loss { SL = CmdPrice;
Como as perdas são estritamente controladas, você não poderá definir o Stop Loss maior do que na abertura da ordem, assim serão evitados riscos excessivos.
// controle de Stop Loss e percentagem de risco! Loss = AccountBalance() * MaxAllowedRisk / 100.0; // Perdas definidas como uma percentagem do balanço OnePipCost = TickValue * OrderLots(); // Recalcular o valor de ponto ao lote da ordem if ( OrderType() == OP_BUY ) NewLoss = ( OrderOpenPrice() - SL ) / Point * OnePipCost; if ( OrderType() == OP_SELL ) NewLoss = ( SL - OrderOpenPrice() ) / Point * OnePipCost; if ( NewLoss > Loss ) { SetError("Stoploss "+DoubleToStr(NewLoss/OnePipCost,0) +" > max available "+DoubleToStr(Loss/OnePipCost,0)); ShowInfo(); return; } }
Fechando uma Ordem
Quando você decide fechar a ordem atual, acione o script #CLOSE em qualquer ponto no gráfico, uma vez que não tem qualquer importância no fechamento. Na sequência desta ação, a ordem será fechada.
Trailing Stop
Assim como o mecanismo de trailing Stop padrão, o algoritmo do trailing construído no Expert Advisor também coloca o preço na distância que você especificar (se o preço for na direção "certa"), mas ao contrário do mecanismo de padrão, temo um controle de operação mais flexível.
Primeiro de tudo, o EA permite que você defina o preço desejado para iniciar o trailing. Pode ser logo após a abertura de uma ordem, no acionamento do script #TRAL-START sobre o preço ao qual o trailing precisa ser ativado. O Expert Advisor vai "lembrar" que valor e, logo que quebrar o preço no nível correspondente, o mecanismo do Trailing Stop sera acionado, onde o Expert Advisor puxa o trailing stop depois que o preço for movimentado. Para evitar modificar a ordem muitas vezes, o Expert Advisor tem um passo singular no Trailing Stop através do parâmetro - TralStep. Um novo trailing stop somente será definido se o preço se mover na direção "certa", a uma distância de pontos no valor do TralStep.
A segunda diferença do trailing stop padrão é que você pode definir o tamanho do Trailing Stop simultaneamente como configuração do seu ponto inicial. O script # TRAL-START0LOSS irá indicar o ponto inicial do trailing e nos pontos de disparos moverá automaticamente o Stop Loss ao ponto de empate, numa distância de Tral0LossGap pontos a partir do preço de abertura da ordem. Outra modificação do mesmo script, o #TRAL-START50PROFIT moverá o nível de Stop no início do processo do trailing até a linha média entre o preço de desencadeamento e o preço de abertura da ordem, onde irá automaticamente salvar pelo menos 50% do lucro acumulado no início do trailing.
Configuração dos comandos do Trailing Stop transmitidos pelos parâmetros do Expert Advisor.
//——— TRALSTART // Definir o preço de desencadeamento do trailing // Antes do desencadeamento, TralStart < 0 como um sinal de que ele ainda está inativo if ( CmdID == COMMAND_TRALSTART && CmdPrice > 0) { ZeroLossTral = false; HalfProfitTral = false; TralStart = CmdPrice; PrevPrice = 0; ShowInfo(); return; } //——— TRALSTART0LOSS // Definir o preço de desencadeamento do trailing e mover simultaneamente o nível Stop para o ponto de empate if ( CmdID == COMMAND_TRALSTART0LOSS && CmdPrice > 0) { ZeroLossTral = true; HalfProfitTral = false; TralStart = CmdPrice; PrevPrice = 0; ShowInfo(); return; } //——— TRALSTART50PROFIT // Definir o preço de desencadeamento do trailing e mover simultaneamente o nível Stop para 50% do lucro auferido if ( CmdID == COMMAND_TRALSTART50PROFIT && CmdPrice > 0) { ZeroLossTral = false; HalfProfitTral = true; TralStart = CmdPrice; PrevPrice = 0; ShowInfo(); return; } //——— TRALSTOP // Zerar, que significa arrastar stops if ( CmdID == COMMAND_TRALSTOP ) { ZeroLossTral = false; HalfProfitTral = false; PrevPrice = 0; TralStart = 0; ShowInfo(); return; }
Este mecanismo permitirá a redução do estresse na negociação intraday e pode garantir operações sem perdas, se o preço atingir o ponto de disparo do trailing. Uma vez que todos os itens acima serão executados pelo Expert Advisor automaticamente, você não terá que monitorar constantemente os preços em tempo real, aguardando o Trailing Stop fazer por você.
Durante a operação do EA no modo trailing, a posição do Trailing Stop pode a qualquer momento ser modificada por um comando padrão, usando o script #MODIFY. Depois de mover o Stop um outro nível, o mecanismo de Trailing Stop estando ativo, manterá ainda mais essa distância. Uma vez que todas as coisas sao feitas no gráfico e visualmente podem ser acionadas, fica muito mais fácil e conveniente do que o mecanismo de trailing padrão, pois este requer valores em pontos. Assim como na modificação do Stop Loss padrão, o Trailing Stop também possibilita o controle das perdas permitidas, evitando perdas maiores do que o especificado:
void TrailingStop(int Step) { double OnePipCost, NewLoss, SL=0; if ( OrderSelect ( SelectedOrder, SELECT_BY_TICKET ) == false ) return; if ( OrderCloseTime() > 0 ) return; // A ordem já foi fechada - não existe trailing // verificar se os dados são válidos if ( TralStart <= 0 || Step < 1 ) return(-1); // Obter os dados no tamanho do nível Stop e percentual de controle do risco Loss = AccountBalance() * MaxAllowedRisk / 100.0; // perdas definidas como uma percentagem do balanço OnePipCost = TickValue * OrderLots(); // Recalcular o valor de ponto ao lote da ordem if ( OrderType() == OP_BUY && CurBid >= TralStart ) { if ( PrevPrice <= 0 ) { if ( ZeroLossTral ) SL = NormalizeDouble(OrderOpenPrice() + Tral0LossGap*Point, Digits); if ( HalfProfitTral ) SL = NormalizeDouble(OrderOpenPrice() + (CurBid - OrderOpenPrice())/2.0, Digits); else SL = NormalizeDouble(OrderStopLoss(), Digits); } else SL = NormalizeDouble(OrderStopLoss() + (CurBid - PrevPrice), Digits); if ( SL < OrderStopLoss() ) return; NewLoss = ( OrderOpenPrice() - SL ) / Point * OnePipCost; } if ( OrderType() == OP_SELL && CurAsk <= TralStart ) { if ( PrevPrice <= 0 ) { if ( ZeroLossTral ) SL = NormalizeDouble(OrderOpenPrice() - Tral0LossGap*Point, Digits); if ( HalfProfitTral ) SL = NormalizeDouble(OrderOpenPrice() - (OrderOpenPrice() - CurAsk)/2.0, Digits); else SL = NormalizeDouble(OrderStopLoss(), Digits); } else SL = NormalizeDouble(OrderStopLoss() - (PrevPrice - CurAsk), Digits); if ( SL > OrderStopLoss() ) return; NewLoss = ( SL - OrderOpenPrice() ) / Point * OnePipCost; } if ( SL <= 0 ) return; // o preço ainda não cruzou o nível de disparo do trailing if ( NewLoss > Loss ) { SetError("Trailing Stoploss "+DoubleToStr(NewLoss/OnePipCost,0) +" > max available "+DoubleToStr(Loss/OnePipCost,0)); ShowInfo(); return; } if ( ( OrderType() == OP_BUY && SL - OrderStopLoss() >= Step*Point ) || ( OrderType() == OP_SELL && OrderStopLoss() - SL >= Step*Point ) ) { TXT = "• Tralingstop order. Please wait..."; bool OK = OrderModify(OrderTicket(),OrderOpenPrice(),SL,OrderTakeProfit(),OrderExpiration(),Blue); if ( OK ) SetWarning("Traling stop moved to " + DoubleToStr(SL, Digits) +" at " + TimeToStr(TimeLocal(),TIME_SECONDS)); else SetLastError("Tralingstop"); } if ( PrevPrice <= 0 || OK ) { // Somente se nós movermos o trailing stop, armazena os preços do trailing stop no próximo tick if ( OrderType() == OP_BUY ) PrevPrice = CurBid; if ( OrderType() == OP_SELL ) PrevPrice = CurAsk; } }
Exibindo Informações Sobre a Situação Atual
No âmbito deste artigo, nós consideramos apenas as questões relacionadas com a negociação como tal. No decurso da operação do Expert Advisor, o código fornecido neste artigo simplesmente exibe um breve comentário que contém dados sobre o estado atual das ordens e da conta de negociação. Tudo certamente poderia ser feito de uma maneira mais fina e mais informativa, assim procurei fazer. Minha versão de trabalho do sistema transmite uma informação visual muito detalhada do funcionamento na janela widget padrão de sistema operacional Windows 7. Este será o foco do meu segundo artigo, onde eu pretendo falar sobre coisas que não estão diretamente relacionadas à negociação, mas o seu uso torna o processo de monitoramento da negociação mais conveniente. Vamos supor, você abriu uma ordem que calcula a posição Trailing Stop e agora está simplesmente esperando o desencadeamento. Enquanto espera, você não precisa manter sua janela aberta no terminal. Uma pequena janela Widget sempre permanece no topo monitorando constantemente a situação atual, enquanto você pode fazer outras coisas, verificando de vez em quando.
Mesmo sem a widget, o EA é totalmente funcional e pronto para o trabalho real. O que esteja faltando, pode ser facilmente adicionado ao código para exibir as informações atualizadas.
Uma coisa que vale a pena notar, quando se fala deste bloco do Expert Advisor, é o mecanismo subjacente à exibição de mensagens de erro e operação normal do robô. Todos os casos de exceção e cada mensagem de erro são armazenadas na variável string especial - LastMsgTxt. Esse texto é exibido na tela em segundos, tempo definido no parâmetro MessageShowSec.
Negociação Baseada em Sinal Externo
O Expert Advisor negocia com base em comandos externos, a fonte desses comandos não tem absolutamente nenhuma importância ao Expert Advisor. Tudo pode ser aplicado no caso do Expert Advisor ser controlado por uma pessoa, mas variáveis globais podem ser configuradas no terminal, não apenas por uma pessoa, isto pode ser feito por um indicador anexado na mesma janela. Vamos dar uma olhada como é implementado, usando o indicador RSI padrão como exemplo.
Vamos modificar o código fonte do cálculo do indicador, acrescentando um "bloco analítico", onde após todos os dados de buffer do indicador serem calculados, controlará o EA. Este exemplo implementa a seguinte regra: uma nova ordem abre se o RSI atingir o nível 52 no sentido descendente ou o nível 48 no sentido ascendente.
Vai nos mostrar que não precisamos nos preocupar em forçar o fechamento das ordens, devido a um mecanismo de bloqueio embutido que impede múltiplas aberturas e fechamento automático de ordens no caso de reversão da posição. O mecanismo do trailing automático garantirá um lucro na intersecção de nível 45 e 55, em referência a 50% de lucro. Este sistema certamente não pode ser chamado de rentável. Ele é usado aqui apenas para fins de demonstração, mostrando o que e como precisa ser feito no código do indicador para treiná-lo a controlar o funcionamento do Expert Advisor.
// adicionado pelo #Trader ====================================================================== double DefaultStop = 150 * Point; // deslocando o nível de Stop abrir uma ordem // A condição para Comprar if( RSIBuffer[3] <= 50 && RSIBuffer[2] <= 52 && RSIBuffer[1] > 52 ) { GlobalVariableSet ( "#Trader-Chart", WindowHandle( Symbol(), Period()) ); GlobalVariableSet ( "#Trader-Command", 1 ); GlobalVariableSet ( "#Trader-Price", NormalizeDouble ( Close[0] - DefaultStop, Digits ) ); GlobalVariableSet ( "#Trader-Time", TimeCurrent() ); } // A condição para Vender if( RSIBuffer[3] >= 50 && RSIBuffer[2] >= 48 && RSIBuffer[1] < 48 ) { GlobalVariableSet ( "#Trader-Chart", WindowHandle( Symbol(), Period()) ); GlobalVariableSet ( "#Trader-Command", 1 ); GlobalVariableSet ( "#Trader-Price", NormalizeDouble ( Close[0] + DefaultStop, Digits ) ); GlobalVariableSet ( "#Trader-Time", TimeCurrent() ); } // 50% - iniciar trailing if( ( RSIBuffer[2] >= 45 && RSIBuffer[1] < 45 ) || ( RSIBuffer[2] <= 55 && RSIBuffer[1] > 55 ) ) { GlobalVariableSet ( "#Trader-Chart", WindowHandle( Symbol(), Period()) ); GlobalVariableSet ( "#Trader-Command", 7 ); GlobalVariableSet ( "#Trader-Price", NormalizeDouble ( Close[0], Digits ) ); GlobalVariableSet ( "#Trader-Time", TimeCurrent() ); } // adicionado pelo #Trader ======================================================================
Importante: somente pode ser testado no modo de visualização e não pode ser otimizado.
Outra possibilidade interessante, quanto a negociação com base em sinais externos, é a possibilidade de implementar um negociação espelho em vários terminais, em diferentes contas de negociação. Questões de interação horizontal ao programa estão além do escopo desta série de artigos, no entanto, a idéia por trás de tal aplicação é bastante óbvia: ao manipular ou gerar o comando no script, um dos terminais que está envolvido na negociação deve passar os parâmetros obtidos a outro terminal, onde serão recebidos por um outro EA ou indicador. As mesmas variáveis globais de controle seriam criadas em outro terminal, o Expert Advisor correspondente a partir do segundo terminal iria executá-las da mesma forma que são executadas pelo EA no primeiro terminal.
Resumo
Vamos agora resumir os pontos-chave implementados na abordagem da automação de negociação manual:
- Componentes de comando e execução do sistema de negociação são divididos em duas partes: scripts de controle dos comandos e configuração dos seus parâmetros com base no qual o Expert Advisor opera. O sistema permite uma expansão facilmente, possibilitando adicionar novas funcionalidades, para isso precisamos adicionar um novo código de operação, um script que vai passar este código ao Expert Advisor e providenciar o tratamento adequado.
- Um mesmo comando é usado para a definição dos parâmetros na manipulação das ordens e determinando o tipo de ação a ser executada. O preço do nível Stop na abertura definirá a direção de negociação, nos casos em que é necessária uma modificação, determina-se o Stop Loss ou Take Profit.
- Os mecanismos responsáveis por abertura e modificação de ordens, bem como os procedimentos de gerenciamento de dinheiro, escritos no Expert Advisor, irão preservá-lo de perder mais do que o valor inicial determinado no risco, expresso em percentagem sobre o saldo disponível.
- Em vez do mecanismo de Trainling Stop padrão que corta o lucro, o Expert Advisor emprega um algoritmo que "deixa seus lucros correrem", em vez de fechar uma ordem para ganhar no nível Take Profit, ele arrasta os crescente lucros.
- O uso de variáveis globais do terminal padrão, no intercâmbio de dados entre scripts e o Expert Advisor, permite que você facilmente use um mesmo código para trabalhar em contas ativas, bem como quando se pratica no modo visualização do Testador de Estratégia.
- Comandos de negociação podem ser transmitidos ao Expert Advisor, não somente pelo script de comando, mas também por qualquer indicador cujo código-fonte possa ser modificado pela adição de um bloco, com o objetivo de criar comandos através das variáveis globais nos pontos de geração de sinal do indicador. Negociação com base em tais sinais do indicador podem ser testados no dispositivo de teste padrão do terminal. Isto pode ser muito útil na identificação de indicadores que redesenham, os indicadores quase rentáveis.
O arquivo anexo contém os códigos fonte do EA #Trader, os scripts de controle e o exemplo do indicador RSI, caracterizando o mecanismo interno responsável por transmitir os comandos de controle ao EA.
Traduzido do russo pela MetaQuotes Ltd.
Artigo original: https://www.mql5.com/ru/articles/1363
Padrões disponíveis ao negociar cestas de moedas
Interfaces Gráficas X: Caixa de Edição de Texto, Slider de Imagens e Controles Simples (build 5)
Exemplo de desenvolvimento de uma estratégia de spread nos futuros da MICEX-RTS
Como desenvolver e testar uma estratégia para Opções Binárias com o Testador de Estratégia do MetaTrader 4
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Você concorda com a política do site e com os termos de uso