Finalmente, disponibilizei uma demonstração da codificação de um indicador no Metatrader5 (linguagem MQL5). Resolvi dividir, em pelo menos, duas partes. Na primeira, tratei sobre a estrutura básica e a lógica fundamental para criação de um indicador.
No vídeo seguinte, pretendo demonstrar a codificação de um indicador VWAP e, se possível, finalizarei demonstrando como criar um indicador que ajuste as cores do candlestick de acordo com alguns critérios da análise técnica – será referência para nosso EA.
Caso você não tenha experiência com programação, recomendo a leitura do artigo sobre algoritmos:
Na explicação da média móvel, estava com pressa para finalizar (antes de minha câmera digital encerrar o vídeo) e não expliquei corretamente o cálculo da média móvel. Mas, resumindo:
1. Somando preço de fechamentos das últimas 20 barras (period):
for (int j=0; j<period; j++) media+=close[i-j];
Este código faria algo como
media=media+close[i-0];
media=media+close[i-1];
...
media=media+close[i-period];
2. A média é o valor da soma dividido pelo período:
media=media/period;
Procurei ser o mais objetivo possível, cobrindo os pontos principais para codificação.
Vi, em outros vídeos, uma demonstração de codificação voltada para “traders” e não, necessariamente, para programadores…
Infelizmente, não acredito que isto seja possível.
Quem não abstrair a lógica de programação, fatalmente terá uma capacidade de codificação muito limitada. Desenhar linhas, por si só, não serve para nada. Portanto, não desprezem os aspectos técnicos demonstrados.
Para auxiliar no entendimento, recomendo assistir o seguinte vídeo:
“O vídeo anterior foi produzido pela equipe da DeltaTrader e é bastante didático. Aliás, foi por onde me orientei para começar.“
Sei que não é tão simples como muitos gostariam, mas sejam pacientes. Ao abstrair a base de codificação, os próximos passos se tornam cada vez mais fáceis.
Aproveitando que tenho compartilhado informações sobre a codificação de robôs no Metatrader5 (ainda em “indicadores“) e algumas dúvidas ou curiosidades estão surgindo, resolvi demonstrar o código que utilizo para identificar os últimos negócios ou nova barra.
A função isNewBar foi definida, inicialmente, para permitir a identificação de uma nova barra – o meu objetivo era abrir os cálculos a cada nova barra.
Parecia simples, bastava comparar “last_time!=lastbar_time” (ou seja, comparar valor atual com o anterior e retornar true quando os valores não forem iguais).
bool isNewBar(const datetime lastbar_time, const int prev_calc) {
...
if (last_time==0 || init_time==0 || last_time!=lastbar_time) {
last_time=lastbar_time;
init_time=init_auxtime;
if (last_time==0) return(false);
return(true);
}
...
return(false);
}
“O valor de lastbar_time é o horário da barra atual (baseado na abertura, e fornecido pela variável time[i]) – mudará apenas na próxima barra. E last_time é o último horário capturado.“
Funciona perfeitamente para a primeira execução do indicador, quando prev_calculated for 0 (com dados históricos). Porém, a lógica não pode ser a mesma quando o indicador estiver analisando os negócios em tempo real.
Suponhamos que você queira trocar a cor do candle quando o preço de abertura for igual ao preço de fechamento (para fechar posição)…
Com os dados históricos (prev_calculated 0), a barra não é processada ticket a ticket. Então, se compararmos open com close assim que a função isNewBar retornar true, teremos a certeza de que open[i] representa o primeiro negócio e close[i] o último (no intervalo de tempo representado pela barra).
Pois é, mas o comportamento não será o mesmo quando prev_calculated for maior que 0 (em tempo real). Neste caso, assim que a próxima barra for desenhada, para o primeiro ticket, teremos open igual a close. Ou seja, a comparação será SEMPRE verdadeira logo que surgir a próxima barra.
Por esta razão, inclui o controle de tempo decorrido (time_match):
...
datetime init_auxtime=TimeCurrent();
...
// 5 minutos
limit_time=300;
time_match=(limit_time-(init_auxtime-init_time));
...
if (last_time==0 || init_time==0 || last_time!=lastbar_time) {
last_time=lastbar_time;
init_time=init_auxtime;
if (last_time==0) return(false);
}
if (prev_aux==0) return(true);
else if (time_match<=1) {
if (time_match<=0) {
last_time=lastbar_time;
init_time=init_auxtime;
return(false);
}
return(true);
}
...
Esta é uma das várias pegadinhas deste tipo de programação! 😉
Confiram, logo a seguir, a função completa:
...
int time_punish=0;
...
bool isNewBar(const datetime lastbar_time, const int prev_calc)
{
//--- memorize the time of opening of the last bar in the static variable
static datetime last_time=0;
static datetime init_time=0;
datetime init_auxtime=TimeCurrent();
int limit_time=0,prev_aux=prev_calc;
long time_match=0;
limit_time=300;
time_match=(limit_time-(init_auxtime-init_time));
if (time_match<0) time_match=0;
string label_name1="Seconds", label_text="Seconds... "+(string) (long)time_match;
ObjectDelete(0, label_name1);
ObjectCreate(0, label_name1, OBJ_LABEL, 0, 0, 0);
//ObjectSetInteger(0,label_name1,OBJPROP_XDISTANCE,960);
ObjectSetInteger(0,label_name1,OBJPROP_XDISTANCE,ChartGetInteger(0,CHART_WIDTH_IN_PIXELS,0)-100);
ObjectSetInteger(0,label_name1,OBJPROP_YDISTANCE,30);
ObjectSetInteger(0,label_name1,OBJPROP_COLOR,YellowGreen);
ObjectSetString(0,label_name1,OBJPROP_TEXT,label_text);
//--- if it is the first call of the function or new bar
if (last_time!=lastbar_time && trade_open>0) bars_trade++;
if (last_time==0 || init_time==0 || last_time!=lastbar_time) {
if (init_auxtime>=init_time+limit_time && init_time>0) prev_aux=0;
time_punish=1;
last_time=lastbar_time;
init_time=init_auxtime;
if (last_time==0) return(false);
}
//--- allow after 5 minutes - 1s
if (time_match>2 && time_match<250) time_punish=0;
if (prev_aux==0) return(true);
else if (time_match<=1) {
if (time_match<=0) {
last_time=lastbar_time;
init_time=init_auxtime;
time_punish=1;
return(false);
}
if (time_punish==0) return(true);
}
//--- if we passed to this line, then the bar is not new; return false
return(false);
}
"A primeira definição, com a criação de um objeto do tipo LABEL, exibirá o contador decrescente (time_match) dos segundos decorridos (300s ou 5min)"
O código responsável pelos cálculos fica limitado pela função isNewBar:
if (isNewBar(time[i], last)==true) {
...
// codificação para mudança de cor do candlestick
if (open[i]==close[i]) buf_color_line[i]=0;
...
}
Apesar das “pequenas turbulências” no cenário político-econômico (em torno da proposta para a reforma da previdência), o resultado do mês foi excelente – provavelmente o melhor do ano (contamos com rendimentos “generosos”). Pela primeira vez conferimos o índice IBov romper os 100.000 pts. O clima de tensão atual fez com que o índice recuasse, mas existe a influência do ímpeto de realização de lucros também. Sem muitas delongas, vamos aos resultados.
Estamos entrando no último mês para a entrega para declaração anual do Imposto de Renda (IRPF), terei bastante trabalho para os próximos dias. Sendo assim, desta vez, serei mais direto. Para quem investe em renda variável, recomendo a contratação de alguma calculadora de IR, como o IRPFBolsa – lhe asseguro, quanto mais adiar, maior será seu arrependimento no futuro (é muito trabalhoso, risos).
Apesar de pequenas turbulências, o otimismo no mercado de capitais prevalece. Se avaliarmos o período de 6 meses, estamos com uma vantagem de 16.790,90 pts.
Fonte: Google
Um “pequeno atrito” entre o Presidente da Câmara e representantes do atual governo geraram incertezas momentâneas para o mercado. Seja como for, acredito que um movimento corretivo era esperado.
Como de costume, confiram os principais números e acontecimentos que sacudiram o país e o mundo (do redator chefe da Modal):
Para quem tem interesse em aperfeiçoar o conhecimento sobre o mercado financeiro, surgiu uma oportunidade bastante interessante: a BTG Pactual abriu inscrições (até 7 de abril) para um curso de graduação – será ministrado pelos sócios do Banco.
Recebi proventos de BBAS3, EGIE3, ITSA3, ITUB3, WEGE3, BRCR11 (9,95%), FCFL11 (0,555%), PQDP11 (0,495%), KNRI11 (0,484%), RNGO11 (0,585%), SAAG11 (0,740%), GGRC11 (0,634%), MXRF11 (0,629%), KNCR11 (0,515%), HGRE11 (0,493%), FLMA11 (0,374%), HGBS11 (0,560%) e FIGS11 (1,358%). O mês foi simplesmente impressionante (risos). Finalizada a negociação com a Brookfield, o fundo BRCR11 distribuiu o rendimento de 9,95% (R$ 10,57 por cota) – portanto, não foi um evento recorrente, mas a previsão é que o fundo apresente uma performance melhor no ano (até pela diminuição da vacância). De maneira geral, o rendimento da carteira permanece excelente, sendo reforçado (e que reforço) com o pagamento de dividendos e JCP de BBAS3, EGIE, ITSA3, ITUB3 e WEGE3.
“O rendimento da carteira quebrou qualquer expectativa para o ano. É óbvio que foi um resultado atípico e acho pouco provável que os próximos meses superem. E agora… Entendem porque a atuação como holder é praticamente obrigatória.“
Com o rendimento da própria carteira, somado ao capital que me prontifico separar para investir mensalmente, comprei mais ações (ou cotas) de BBAS3, ITSA3, ITUB3, WEGE3, FLRY3, BBSE3, HYPE3, EGIE3, ODPV3, BRCR11 e KNRI11. Os menores aportes foi para ODPV3, BBAS3 e BRCR11, e os maiores para ITUB3, WEGE3 e KNRI11 (de maneira geral, foram bem equilibrados). Como o rendimento foi bastante expressivo, decidi “distribuir melhor” os aportes.
Confiram a distribuição dos ativos, segundo o portal CEI (NÃO inclui o Fundo DI):
“A proporção em ações continua bastante expressiva em decorrência da forte valorização do índice Ibov“
A composição atual ficou assim (gráfico do IrpfBolsa):
“Vale lembrar que o gráfico acima representa uma distribuição baseada no custo de aquisição, não no valor de mercado“
O resultado mensal foi MUITO surpreendente. Fiquei extremamente satisfeito, pois minha capacidade de aporte foi maior. É preciso saber aproveitar bem estes momentos, pois não são frequentes.
O robô de trade abriu o mês com vários gains, mas, infelizmente, finalizou com prejuízo de R$20. Já estou na 22 revisão do código e o índice de acerto está melhorando bastante – ainda não coloquei em produção a última revisão.
De maneira geral, estou bastante satisfeito. Vale lembrar que, no curto prazo, oscilações são naturais e esperadas (com movimentos de repique, por exemplo). Dentro de qualquer tendência, os papeis não se movimentam em linha reta.
Estou apenas demonstrando o potencial de crescimento, isto não é recomendação de investimento.
A dica desta vez é voltada para usuários de Linux. Se não for o seu caso, este artigo não será de grande serventia.
De qualquer forma, para quem estiver interessado na utilização de um robô na “conta quente”, recomendo fazer isto em uma instalação Windows ( para execução nativa).
Sei que o intervalo de tempo entre um vídeo e outro está longo, mas não estou com muita disponibilidade de tempo livre e, infelizmente, no final de semana passado o HD (disco rígido) principal do meu computador danificou definitivamente. Logo, precisei refazer a instalação do sistema operacional e recuperar o backup de minhas aplicações e projetos. Isto sem falar que ainda estou codificando e otimizando meu robô de trade.
Antes de tratar sobre a codificação de indicadores ou robôs propriamente, começaremos falando sobre lógica de programação (algoritmos). Para quem pretende criar seu próprio indicador ou EA no Metatrader, este conhecimento é fundamental.
Para melhor compreensão, é importante entender primeiro o conceito de entrada (INPUT) e saída (OUTPUT).
Entrada: Recebimento de dados para processamento (associação direta, leitura de um arquivo ou dados fornecidos pelo teclado)
Saída: Resultado final do processamento (escrita em disco ou exibição em tela).
Com este entendimento, fica mais simples compreender o que é um algoritmo e como escrever o nosso próprio código.
Um algoritmo nada mais é que uma sequência lógica de instruções (código) que determinam como dados recebidos (entrada) serão tratados pelo computador.
Resumindo, o algoritmo é uma sequência lógica de instruções que utilizaremos para solucionar determinado problema. A sequência lógica pode ser apresentado em diagrama (fluxograma) ou por um bloco de código (prévia para codificação).
Como o nosso objetivo principal é a codificação de indicadores ou assistentes especializados (robôs), o foco deste artigo será voltado aos blocos de código. A figura anterior (fluxograma), foi utilizada como reforço para demonstrar como funciona a lógica de programação.
Porém, é através do algoritmo que aprendemos a programar… 😉
O primeiro passo, será identificar as “variáveis” necessárias para nosso programa.
As variáveis representam áreas de memória que identificam um dado específico (onde guardaremos o dado recebido para posterior referência – seja por arquivo, teclado ou associação direta).
Por exemplo (associação direta – atribuindo valores):
Foram utilizadas 4 variáveis para guardar o valor do “último negócio” realizado no MT5, onde candle_abertura representa o preço de abertura da barra e candle_maior a máxima da barra. As demais variáveis são autoexplicativas.
“Aliás, sempre utilize nomes sugestivos para associar rapidamente a finalidade da variável“
O exemplo anterior foi de variáveis simples, mas podemos trabalhar com vetores (array) para armazenar múltiplos valores na mesma variável – permite ter acesso a informações passadas a qualquer momento (histórico).
Caso precisássemos armazenar os preços negociados nas últimas 100 barras, por exemplo:
“O valor que aparece entre colchetes (“n”) é um índice que identificará cada barra. Como, no MQL5, o primeiro índice começa em 0, o último (em 100 barras) será 99.“
Também precisamos identificar o tipo de dado: 1. lógico: boleano (verdadeiro ou falso) 2. data_hora: formato data e hora 3. numérico: inteiro ou flutuante 4. textual: caractere ou string
Neste artigo, para receber dados por teclado, convencionaremos que a instrução será “leia“. E, para exibir os dados, convencionaremos “exiba“.
Entendida a declaração das variáveis, podemos começar a definir a lógica de processamento – “99% do sucesso de todo código (instruções) depende desta definição (onde as comparações serão feitas)”.
Estruturas condicionais:
São blocos de código onde validaremos se o conteúdo das variáveis atendem nossas necessidades: “se condição_verdadeira; faça“
– Qual seria o algoritmo necessário para descobrir se um candle é de alta ou baixa?
secandle_alta == verdadeiro; então exiba“fechamento ”+candle_fechamento+“ de alta” senao exiba“fechamento ”+candle_fechamento+“ de baixa” fim-se
Caso pareça muito confuso, respire fundo e leia novamente!
Não é obrigatório dominar tudo que foi demonstrado, mas saiba que é o básico para que possamos otimizar o código para as nossas necessidades. Do contrário, a contratação de um programador será a única alternativa.
Em relação a programação, o que fiz, no exemplo anterior, pode gerar alertas de compilação ou resultado inesperado em algumas linguagens de programação. Percebam que, na exibição, fiz uma soma entre strings com um valor flutuante (são tipos diferentes).
Logo, o ideal é realizar a conversão para um tipo comum. Neste caso, o mais lógico, no momento da soma, seria converter candle_fechamento para string.
Este processo de conversão é conhecido como casting:
exiba“fechamento ”+(string) candle_fechamento+“ de alta”
“A partir deste momento, a instrução exiba entenderá que está somando (concatenando) strings. Em algumas linguagens (não é o caso da MQL), ‘a+1’ é igual ‘b’!”
“Vale lembrar que tenho colocado verdadeiro ou falso em negrito porque representa um valor reservado para identificar o resultado lógico da variável boleana. Não se preocupe muito com isto agora, mas é fundamental que você saiba interpretar os exemplos dados (como está sendo processado).“
É evidente que muitas vezes faremos mais de uma comparação na mesma expressão, obrigando que duas ou mais condições sejam atendidas (AND) ou apenas uma (OR).
-É aqui que entra a interpretação da tabela verdade:
se (a > b AND b > c): será processado quando ambas forem verdadeiras se (a>b OR b>c): será processado se qualquer uma das condições for verdadeira.
Confiram uma videoaula específica sobre estruturas condicionais:
Estruturas de repetição (loop):
Uma estrutura de repetição é basicamente um bloco de instrução em que uma determinada operação deverá ser executada repetidas vezes até atingir o resultado esperado.
“Poderíamos utilizar um loop para descobrir qual é o maior preço de fechamento das últimas 100 barras, por exemplo.”
inteiro i=0 flutuante maior_preco=0.0 flutuante candle_fechamento[] ... para (de i=0 até 99); faça leia candle_fechamento[i] se (candle_fechamento[i] > maior_preco); então maior_preco = candle_fechamento[i] fim-se fim-para
exiba maior_preco
A variável maior_preco foi inicializada em 0 (menor preço possível) e será substituída no primeiro preço acima de 0. Nas comparações seguintes, ela será atualizada cada vez que o valor de candle_fechamento[i] for maior que o conteúdo de maior_preco.
Se não utilizássemos uma estrutura de repetição (loop) teríamos que escrever cada comparação individualmente – em muitos casos, seria inviável.
se (candle_fechamento[0] > maior_preco); então maior_preco = candle_fechamento[0] fim-se
se (candle_fechamento[1] > maior_preco); então … se (candle_fechamento[99] > maior_preco); então maior_preco = candle_fechamento[99] fim-se
Mais uma videoaula específica sobre estruturas de repetição (bastante didático):
“Cuidado para não tornar os laços infinitos (no exemplo anterior, o limite foi fixado em 99 – repetição de 100x), pois, caso fique infinito, o processamento não terminará e causará o travamento da aplicação.”
Para finalizar, também podemos trabalhar com reaproveitamento de código e melhor organização estrutural disponibilizando funções.
Chamadas de funções:
Quando precisarmos executar uma mesma operação várias vezes em diferentes partes do código, ao invés de repetir o mesmo bloco de código várias vezes, podemos separar o código responsável por este processamento e chamá-lo sempre que for necessário (com uma única chamada, informando os dados necessários).
flutuante função calc_media (flutuante maxima, flutuante minima); início flutuante resultado = (maxima + minima)/2 retorne resultado fim-função … flutuante maxima=0.0, minima=0.0, media=0.0 leia maxima leia minima media=calc_media(maxima,minima)
exiba media
Percebam que cada função representa um bloco de código separado. Caso o processamento da função, ao final do seu processamento, ofereça algum retorno (resultado final), deveremos configurar o tipo de dado que será retornado (no exemplo foi flutuante).
Confiram uma videoaula específica sobre funções (bastante didático):
No MQL5, a posição da função, em relação a sua chamada, não importará. Não é algo muito comum porque a interpretação do código é sequencial e o compilador, teoricamente, precisa conhecer a função antes de uma chamada no bloco de código principal.
Espero que o conteúdo lhe auxilie no aprendizado!
– Quem não se familiarizar com lógica de programação, precisa contratar um programador para MQL5 – sua curva de aprendizado pode ser longa.
– Outra opção é buscar soluções comerciais onde você apenas alimenta as opções do robô de acordo com o tipo de lógica já programada – aqui Brasil, a Smartbot oferece este serviço.
