Tutoriais de programação - página 6
Você está perdendo oportunidades de negociação:
- Aplicativos de negociação gratuitos
- 8 000+ sinais para cópia
- Notícias econômicas para análise dos mercados financeiros
Registro
Login
Você concorda com a política do site e com os termos de uso
Se você não tem uma conta, por favor registre-se
Impressionante bot de negociação de quebra alta / baixa em mql5! | Parte 1
Impressionante bot de negociação de quebra alta / baixa em mql5! | Parte 1
Toby, neste vídeo, quero apresentar um novo projeto que envolve o uso de altos e baixos para criar uma estratégia de fuga lucrativa. A ideia principal é identificar os preços mais altos e mais baixos do símbolo atual e usar esses níveis para determinar possíveis pontos de ruptura. Vamos dar uma olhada no gráfico para entender como isso funciona.
Para começar, observamos as últimas n barras e identificamos os preços mais altos e mais baixos. Se o preço quebrar acima do nível alto, assumimos uma posição de compra. Por outro lado, se o preço cair abaixo do nível mínimo, assumimos uma posição de venda. É um conceito simples, mas vamos aprimorá-lo adicionando níveis de stop loss e take profit em pontos. Além disso, implementaremos filtros para refinar a estratégia e evitar negociações em todas as altas e baixas.
Vamos aguardar uma oportunidade de negociação para demonstrar o conceito. Aqui, temos uma posição de venda, pois o preço quebrou abaixo do nível mínimo e fechamos a negociação com lucro. Isso serve como alicerce básico para nossa estratégia e podemos melhorá-la ainda mais incorporando componentes adicionais.
Agora, vamos mudar para o Meta Editor e começar a codificar. Vamos criar um novo arquivo na pasta do YouTube e nomeá-lo como "Toby's Breakout EA". No arquivo, definiremos as entradas necessárias para nosso EA. Isso inclui o número mágico, tamanho do lote, número de barras a serem consideradas, stop loss e take profit. Definiremos os valores padrão apropriados e forneceremos comentários para explicar cada entrada.
Em seguida, passaremos para a função onInit, onde verificaremos as entradas do usuário para garantir que sejam válidas. Criaremos uma função separada chamada checkInputs para lidar com essa validação. Se alguma das entradas estiver incorreta, exibiremos uma mensagem de erro e impediremos a inicialização do EA.
Dentro da função onInit, também definiremos o número mágico do nosso objeto de negociação usando a entrada fornecida. Isso nos permitirá filtrar e gerenciar posições abertas por nosso EA posteriormente.
Agora, vamos examinar a função onTick. Começaremos salvando o tick atual e os valores do tick anterior. Isso nos ajudará a rastrear os movimentos de preços e determinar se cruzamos algum nível importante. Usaremos a função SymbolInfoTick para recuperar o tick atual e, se ocorrer algum erro, exibiremos uma mensagem de erro e interromperemos o EA.
Posteriormente, incluiremos três funções personalizadas: countOpenPositions, normalizePrice e closePositions. Essas funções nos ajudarão a gerenciar nossas posições, contar o número de posições abertas, normalizar preços e fechar posições quando necessário.
Voltando à função onTick, começaremos contando as posições abertas tanto para compra quanto para venda. Se ocorrer um erro durante esse processo, interromperemos o EA sem exibir uma mensagem de erro, pois já foi tratado na função personalizada. Em seguida, verificaremos se há alguma posição de compra aberta e se o nível alto não é zero. Isso garante que definimos o nível alto e que não há posições de compra existentes.
A partir daqui, podemos continuar codificando a lógica da estratégia de fuga. Implementaremos verificações semelhantes para as posições de venda e o nível baixo. Essas declarações if nos ajudarão a determinar se devemos assumir uma posição de compra ou venda com base na quebra dos respectivos níveis.
Assim que tivermos uma estrutura básica instalada, podemos aprimorar ainda mais a estratégia adicionando mais componentes e filtros. Isso pode incluir parâmetros e condições de entrada adicionais para refinar os sinais de negociação e melhorar o desempenho geral.
Isso cobre o processo de codificação inicial. Seguindo essas etapas, podemos criar um EA de rompimento com base em altos e baixos, que pode servir como ponto de partida para desenvolvimento e otimização adicionais.
O algoritmo:
O algoritmo verifica continuamente possíveis pontos de entrada e saída com base nos preços de compra e venda em relação aos níveis alto e baixo predefinidos. Ele abre posições quando as condições são atendidas e fecha posições quando os preços se movem na direção oposta.
Bot de negociação de rompimento alto/baixo mql5 | Parte 2
Bot de negociação de rompimento alto/baixo mql5 | Parte 2
Neste vídeo, continuamos trabalhando em nosso Audi preto com revestimento high-low. No seguimento da nossa sessão anterior, vamos agora incorporar a lógica de negociação e introduzir alguns componentes adicionais. Para começar, vamos calcular o stop loss para as nossas posições. Se a entrada de stop loss for zero, definimos a variável "SL" como zero, indicando que não há stop loss. Caso contrário, definimos o preço de oferta atual menos o stop loss de entrada multiplicado pelo valor dos pontos.
Em seguida, calculamos o take profit. Se a entrada de lucro for zero, definimos a variável "TP" como zero. Caso contrário, definimos o preço de venda atual mais o lucro de entrada multiplicado pelo valor dos pontos. Para garantir valores de preço consistentes, normalizamos o stop loss e obtemos lucro usando a função "preço normalizado".
Com a lógica de negociação estabelecida, usamos o objeto de negociação, que foi declarado anteriormente usando a classe cTrade, para abrir posições. Para uma posição de compra, usamos o símbolo atual, lotes de entrada para o tamanho do lote, preço de oferta atual para o preço, variável stop loss para stop loss e variável take profit para take profit. Da mesma forma, para uma posição de venda, usamos o preço de venda atual para o preço. Para diferenciar esta posição das outras, adicionamos um comentário indicando que ela pertence ao nosso consultor especialista "High-Low Record EA".
Depois de compilar o código, mudamos para o MetaTrader para teste. Montamos um teste visual, especificando o prazo e o período. Com as entradas padrão, executamos o teste e observamos os valores altos e baixos. Ao usar o modo "Open Price Only", podemos ver as posições sendo abertas quando o nível alto ou baixo é cruzado. Na próxima etapa, alteramos o modo de tick do EA para agir apenas em ticks abertos. Isso fornece um ambiente de teste mais confiável e rápido para criar sistemas estáveis.
Avançando, implementamos um filtro de índice para evitar a negociação em pontos extremos no início ou no final do período de retrospectiva. Introduzimos uma entrada chamada "Filtro de índice", que representa a porcentagem de barras dentro do período de lookback que deve ser filtrada. Por exemplo, se o período de lookback for de 50 barras e o filtro de índice for definido como 10, os pontos extremos nas primeiras cinco ou nas últimas cinco barras serão filtrados. Para visualizar esse intervalo, desenhamos um retângulo no gráfico. Adicionamos as variáveis globais necessárias, definimos seus valores iniciais e fazemos alterações na função "OnTick" para calcular os índices alto e baixo usando as funções "I Mais Alto" e "I Mais Baixo".
Além disso, atualizamos a função "CheckInputs" para incluir a entrada "Index Filter" e validar seu valor. Também criamos uma nova função chamada "CheckIndexFilter" que verifica se um ponto extremo deve ser filtrado com base no índice e nas configurações do filtro. Para concluir a implementação, compilamos o código e procedemos a um teste visual. Verificamos se as posições são abertas apenas quando os pontos extremos estão dentro do intervalo definido, conforme filtro de índice. No segmento a seguir, planejamos modificar o modo de tick do EA para melhor atender às nossas necessidades. Mudaremos para o modo de tick aberto, permitindo que o EA opere exclusivamente em ticks abertos, aumentando a confiabilidade e a eficiência do sistema.
Depois de modificar o modo de tick para o modo de tick aberto, prosseguimos com outras melhorias em nosso EA. Uma das melhorias que faremos é a adição de um filtro de tempo. Para implementar o filtro de tempo, introduzimos duas novas entradas: "Start Hour" e "End Hour". Essas entradas nos permitem especificar o intervalo de tempo durante o qual a negociação deve ser permitida. Por exemplo, se definirmos a hora inicial para 8 e a hora final para 18, o EA só abrirá posições entre 8h e 18h. Para incorporar o filtro de tempo, atualizamos a função "CheckInputs" para validar as novas entradas e garantir que a hora inicial seja menor que a hora final. Também modificamos a função "OnTick" para verificar a hora atual em relação ao intervalo especificado antes de abrir posições.
Com o filtro de tempo instalado, compilamos o código e executamos um teste visual para verificar se as posições são abertas apenas dentro do intervalo de tempo especificado. Em seguida, passamos para outro aprimoramento: adicionar um filtro de dispersão. O filtro de spread nos permite definir um spread máximo permitido, além do qual o EA se absterá de abrir posições. Para implementar o filtro de spread, introduzimos uma nova entrada chamada "Max Spread". Na função "OnTick", incluímos uma verificação para garantir que o spread atual esteja dentro do intervalo permitido antes de abrir posições.
Também atualizamos a função "CheckInputs" para validar a entrada "Max Spread" e garantir que seja um valor positivo. Uma vez implementado o filtro de spread, compilamos o código e realizamos um teste visual para confirmar que as posições só são abertas quando o spread está abaixo do máximo especificado. Por fim, apresentamos um recurso para rastrear e exibir o número de posições abertas no gráfico. Criamos uma nova variável global chamada "Position Count" e a inicializamos com zero. Na função "OnTick", incrementamos a contagem de posições cada vez que uma posição é aberta.
Para exibir a contagem de posições no gráfico, utilizamos a função "ObjectSetText" para criar um objeto de texto que mostra a contagem atual. Atualizamos o objeto de texto com o último valor de contagem em cada tick. Depois que o código é compilado, executamos um teste visual para observar a contagem de posições exibida no gráfico e garantir que reflita com precisão o número de posições abertas.
Com essas melhorias implementadas, melhoramos significativamente a funcionalidade e o desempenho de nosso EA. O filtro de tempo, o filtro de spread e a exibição da contagem de posição fornecem maior controle e visibilidade sobre o processo de negociação.
No próximo vídeo, exploraremos otimizações adicionais e técnicas de ajuste fino para aprimorar ainda mais o desempenho do nosso EA.
Incrível alta / baixa breakout trading bot mql5 | Parte 3
Incrível alta / baixa breakout trading bot mql5 | Parte 3
No vídeo de hoje, Toby continua o desenvolvimento do EA high-low breakout para MK5. Ele apresenta dois novos componentes à estratégia e também realiza vários backtests no final.
Toby começa compilando o EA para garantir que esteja em condições de funcionamento. Ele então adiciona uma entrada para um trailing stop loss para aumentar a eficácia da estratégia como um sistema de fuga e acompanhamento de tendências. A entrada é uma variável booleana que pode ser ativada ou desativada. Toby também cria uma função chamada "updateStopLoss" para calcular e atualizar os valores de stop loss para cada posição.
Para implementar o trailing stop loss, Toby copia a função "updatePosition" de outro EA e a modifica de acordo. Ele adiciona um parâmetro para a distância do stop loss e ajusta o cálculo do novo valor do stop loss com base nessa entrada. Ele também incorpora uma função chamada "normalizedPrice" para garantir que o valor do stop loss seja normalizado. Depois de fazer essas alterações, Toby compila o código novamente para garantir que não haja erros.
Em seguida, Toby passa para a função "OnTick", onde integra a função "updateStopLoss". Ele adiciona uma instrução if para verificar se o trailing stop loss está ativo e, se estiver, chama a função "updateStopLoss" para acompanhar os valores do stop loss. Ele também garante que a função seja aplicada às posições de compra e venda.
Depois de compilar o código, Toby adiciona o próximo componente, um filtro de tamanho, à estratégia. O filtro de tamanho permite filtrar canais onde os valores alto e baixo estão muito distantes, indicando um intervalo maior. Toby adiciona uma entrada para o filtro de tamanho em pontos e ajusta o código de acordo para verificar se o tamanho do canal excede o limite especificado. Ele também incorpora o filtro de tamanho na visualização das linhas altas e baixas.
Toby então faz um teste visual usando o testador de estratégia para confirmar se o trailing stop loss e o filtro de tamanho estão funcionando corretamente. Ele observa o comportamento do stop loss e as mudanças de cor nas linhas com base na condição do filtro de tamanho.
Na parte final do vídeo, Toby realiza backtests para avaliar o desempenho do EA nos últimos 10 anos. Ele define os critérios de otimização como o fator de recuperação e usa um símbolo e período de tempo específicos. Toby planeja usar os anos restantes como um teste fora da amostra.
Toby faz várias melhorias no EA de rompimento alto-baixo, incluindo a adição de um trailing stop loss e um filtro de tamanho. Ele também demonstra como realizar backtests para avaliar o desempenho do EA.
Vamos codificar o EA padrão candlestick definitivo em mql5! | Parte 1
Vamos codificar o EA padrão candlestick definitivo em mql5! | Parte 1
Olá, aqui é Toby, e neste vídeo, estou iniciando um novo projeto de codificação EA em meu canal. Estaremos nos concentrando nos padrões Candlestick e criando um EA que pode negociar vários padrões, como Doji, Morning Star, Rising Star e muitos outros. O EA também terá um painel para exibir diferentes condições. Já realizei alguns testes preliminares com o EA e os resultados foram bastante interessantes, especialmente em diferentes símbolos. Acredito que essa abordagem pode levar a uma estratégia altamente eficaz. Vamos mergulhar!
Antes de começarmos a codificar o EA, vamos discutir a ideia geral da estratégia. É crucial entender o que pretendemos criar à medida que progredimos. Para ilustrar o conceito, criei um diagrama simples. Nosso EA trabalhará exclusivamente com o preço de abertura de cada barra. Por exemplo, vamos considerar a barra atual (índice 0) e a barra anterior (índice 1). Queremos criar um EA que possa negociar vários padrões de gráficos ou padrões de Candlestick, como Doji, Morning Star, Evening Star, Rising Star e muitos mais.
Para conseguir isso, vamos definir diferentes condições. Por exemplo, podemos definir uma condição em que o preço alto da barra 2 deve ser maior que o preço mais alto da barra 1. Outra condição pode ser que o preço de abertura da barra 3 seja menor que o preço de fechamento da barra 3, indicando uma vela de alta. Ao combinar essas condições, podemos acionar uma negociação de compra na abertura da próxima barra. Podemos aplicar condições semelhantes ao contrário para sinais de venda.
Além disso, quero considerar não apenas os preços de abertura, alta, baixa e fechamento de cada castiçal, mas também outros fatores, como o tamanho do intervalo ou o tamanho do corpo. Por exemplo, podemos calcular o tamanho do corpo dividindo-o pelo alcance total do castiçal. Este cálculo pode nos ajudar a identificar as barras Doji. Podemos até definir valores específicos, como exigir um tamanho corporal maior que 50 pontos. Com essas opções, podemos criar e testar vários padrões usando um único EA. Promete ser uma viagem emocionante!
Agora, vamos passar para o MetaEditor e começar a codificar. Mas antes de começarmos, gostaria do seu feedback. Se você acha esses vídeos úteis e gostaria de dormir bem esta noite, deixe um like. Além disso, estou pensando em alternar entre o modo escuro e o fundo branco padrão. Vou criar uma enquete para você votar na sua preferência. Deixe-me saber nos comentários se você consegue ler tudo corretamente no modo escuro.
Tudo bem, vamos começar a codificação! No MetaEditor, criarei um novo EA na minha pasta do YouTube. Vou chamá-lo de 'Padrão de Vela EA'. Começaremos com um modelo limpo, removendo comentários desnecessários e organizando a estrutura do código. Depois de compilar e garantir que não haja erros, seguiremos para as próximas etapas.
Definiremos alguns parâmetros-chave na seção de entradas, como o número mágico, que deve ser um identificador exclusivo para este EA para evitar conflitos com outros EAs em execução na mesma instância do MetaTrader. Vamos atribuir um número aleatório a ele.
Isso abrange a configuração inicial e os parâmetros de entrada. Agora estamos prontos para passar para a próxima parte. Fique atento!
Padrão de castiçal EA em mql5! | Parte 2
Padrão de castiçal EA em mql5! | Parte 2
No vídeo de hoje, eu sou Toby, e continuaremos codificando nosso Expert Advisor (EA) padrão Candlestick simples no MetaTrader 5. Agora estamos na segunda parte desta série de codificação, então se você perdeu a primeira parte onde eu explicou a ideia da estratégia com mais detalhes, você pode encontrar o link para esse vídeo aqui. Antes de começarmos a codificar, quero compartilhar os resultados de uma pesquisa recente que realizei no YouTube sobre o tema de cor preferido para gravar vídeos. De 140 votos, a maioria das pessoas (90) preferiu o fundo escuro, enquanto 50 pessoas preferiram o fundo branco. Pessoalmente, acho o fundo escuro mais fácil para os olhos e também o uso para gravar meus próprios EAs.
Outra coisa que gostaria de mencionar é que recentemente configurei o Visual Studio Code para MQL5. Se você estiver interessado em usar o Visual Studio Code para seus projetos de codificação, deixe-me saber nos comentários e farei um vídeo sobre isso.
Agora, vamos voltar a codificar nosso EA. No vídeo anterior, paramos nas entradas para a primeira condição. Agora criaremos outra condição e adicionaremos uma entrada para a condição dois. Copiaremos a seção da condição um e a renomearemos como condição dois, fazendo as alterações necessárias nas variáveis de entrada. Por enquanto, vamos simplificar com apenas duas condições, mas podemos adicionar mais no futuro. Depois de fazer essas alterações, compilaremos o código para garantir que não haja erros ou avisos.
Alguns visualizadores solicitaram um aumento no tamanho da fonte para melhor legibilidade. Embora eu prefira ver mais código na tela, entendo a necessidade de tamanhos de fonte maiores. No entanto, por enquanto, ficaremos com o tamanho da fonte atual. Se necessário, posso fazer ajustes no futuro.
Em seguida, vincularemos as entradas ao nosso array de condições, que criamos na seção de variáveis globais. Criaremos uma função personalizada chamada "setInputs" para fazer isso. Esta função será chamada antes de verificar as entradas. Depois de escrever o código para a função setInputs, vamos compilar o código novamente para verificar se está correto.
Seguindo em frente, verificaremos as entradas para garantir que elas atendam aos critérios exigidos. Usaremos uma instrução if para cada entrada para realizar as verificações necessárias. Se alguma entrada for considerada inválida, exibiremos um alerta para o usuário e retornaremos false da função checkInputs. Começaremos verificando o número mágico, garantindo que não seja menor ou igual a zero. Em seguida, verificaremos o tamanho do lote, o stop loss e obteremos entradas de lucro. Além disso, precisaremos adicionar uma verificação para o array de condição, que abordaremos mais tarde.
Para tornar o código mais modular, usaremos uma função setInputs para definir o número mágico para nosso objeto de negociação. Isso será benéfico ao procurar posições ou lidar com operações relacionadas ao comércio. Depois de fazer essa alteração, compilaremos o código novamente para confirmar sua precisão.
Agora, vamos para a função onTick, onde ocorrem as principais operações do EA. Em primeiro lugar, verificaremos se o tick atual é um tick de barra aberta usando nossa função isNewBar. Se retornar falso, indicando que não é um tick de barra aberta, simplesmente retornaremos e esperaremos pelo próximo tick.
A seguir, obteremos o tick do símbolo atual. Isso fornecerá acesso a lances, pedidos e outras informações relacionadas a ticks. Usaremos a função SymbolInfoTick e armazenaremos o resultado em uma variável. Se esta operação falhar, exibiremos uma mensagem indicando a falha e retornaremos da função onTick.
Em seguida, contaremos as posições abertas usando nossa função countOpenPositions. Isso nos dará o número de posições abertas de compra e venda no momento atual. Se esta operação falhar, exibiremos uma mensagem de erro indicando a falha e retornaremos da função onTick.
Depois de obter a contagem de posições abertas, verificaremos se existem posições abertas. Se houver, exibiremos uma mensagem indicando o número de posições em aberto. Caso contrário, prosseguiremos para a próxima etapa.
Agora, percorreremos cada posição aberta usando um loop for. Dentro do loop, recuperaremos as informações de posição usando a função PositionGetTicket. Armazenaremos o número do ticket em uma variável e exibiremos uma mensagem com o número do ticket para fins de depuração.
A seguir, verificaremos o tipo da posição (compra ou venda) utilizando a função PositionGetInteger e a propriedade POSITION_TYPE. Se a posição for uma posição de compra, executaremos o código necessário para posições de compra. Da mesma forma, se a posição for uma posição de venda, executaremos o código para posições de venda.
Para posições de compra, verificaremos se o preço de compra atual é inferior ao nível de stop loss da posição. Se for, exibiremos uma mensagem indicando que o nível de stop loss foi atingido e fecharemos a posição usando a função PositionClose.
Da mesma forma, para posições de venda, verificaremos se o preço de venda atual é superior ao nível de stop loss da posição. Se for, exibiremos uma mensagem indicando que o nível de stop loss foi atingido e fecharemos a posição.
Depois de fechar as posições necessárias, passamos para a próxima etapa, que é verificar nossas condições para determinar se devemos abrir uma nova posição. Usaremos a função checkConditions para essa finalidade. Se a função checkConditions retornar true, indicando que todas as condições foram atendidas, executaremos o código necessário para abrir uma nova posição. Caso contrário, continuaremos para o próximo tick.
No código para abrir uma nova posição, definiremos o volume, stop loss, take profit e outros parâmetros necessários. Usaremos a função OrderSend para enviar a solicitação de negociação e abrir a posição. Se a solicitação de negociação for bem-sucedida, exibiremos uma mensagem indicando a abertura da posição com sucesso. Caso contrário, exibiremos uma mensagem de erro.
Por fim, compilaremos o código para garantir que não haja erros ou avisos e, se tudo der certo, estaremos prontos para testar nosso EA em uma demonstração ou conta ativa.
Isso conclui este vídeo. Na próxima parte, continuaremos construindo nosso EA adicionando recursos adicionais e refinando nossa estratégia. Se você tiver alguma dúvida ou sugestão, por favor, deixe-os nos comentários abaixo. Obrigado por assistir, e vejo vocês no próximo vídeo!
Incrível padrão de castiçal EA em mql5! | Parte 3
Incrível padrão de castiçal EA em mql5! | Parte 3
Neste vídeo, Toby se apresenta e anuncia que o foco será continuar a desenvolver o Expert Advisor (EA) do padrão Candlestick no MetaTrader5. O objetivo é escrever a lógica central necessária para conduzir o primeiro backtest e obter um resultado. Toby incentiva os espectadores a conferir as partes anteriores da série, caso ainda não o tenham feito.
Toby abre o Meta Editor e começa a codificar de onde parou no vídeo anterior. Ele explica que eles já implementaram o código para abrir posições de compra e venda, mas agora precisam adicionar as verificações de condição. Para fazer isso, Toby planeja criar uma função personalizada que pode ser chamada para verificar as condições para negociações de compra e venda.
Antes de iniciar o processo de codificação, Toby deseja garantir que não haja erros no código existente. Ele compila o código para verificar erros ou avisos.
Em seguida, Toby passa a escrever a lógica para a função personalizada chamada "verificar condições". Esta função irá iterar através de cada condição usando um loop for. Dentro do loop, eles chamarão outra função personalizada chamada "verificar uma condição" para avaliar cada condição individual.
Toby cria a função "verificar uma condição", que recebe parâmetros para a negociação de compra/venda e o índice da condição a ser verificada. Dentro desta função, várias verificações são realizadas, como determinar se a condição está ativa. Se uma condição estiver inativa, a função retornará true, indicando que não é relevante.
Para verificar as condições, Toby precisa obter os dados da barra. Ele declara uma variável do tipo mql rates, que é uma estrutura predefinida contendo os preços de abertura, alta, baixa e fechamento. Eles definem a matriz de taxas como série e usam a função de taxa de cópia para recuperar os dados necessários para as condições.
Depois de obter os dados da barra com sucesso, Toby passa a definir os valores para as variáveis A e B, que serão usadas para comparar e avaliar as condições. Os valores são determinados com base no modo da condição, como aberto, alto, baixo, fechado, faixa, corpo, proporção ou valor. Os valores são atribuídos de acordo, levando em consideração se é uma negociação de compra ou venda.
Depois que os valores são definidos, Toby compila o código para verificar se há erros ou erros.
Toby repete o processo para as condições do modo B, fazendo os ajustes necessários nas variáveis e nos casos.
Por fim, Toby conclui o vídeo garantindo que não haja erros no código e enfatizando a importância de entender a lógica do código.
Codifique um critério personalizado em mql5
Codifique um critério personalizado em mql5
Olá, aqui é Toby. Neste vídeo, demonstrarei como codificar um critério personalizado para a otimização do seu Expert Advisor em MQL5. Usaremos o suporte Hilo EA como exemplo. O objetivo é criar um critério customizado que considere tanto o fator de lucro quanto o número de negociações na classificação dos resultados da otimização.
Para começar, abra seu EA no ambiente de codificação (como o Visual Studio Code) e salve-o com um novo nome. Em seguida, adicione uma função predefinida chamada "OnTester" ao seu EA. Essa função calculará os critérios personalizados e retornará seu valor. Você pode usar a função "TestStatistics" para obter o número de negócios e o fator de lucro. Multiplique esses dois valores para calcular os critérios personalizados.
Compile o código para garantir que não haja erros. Agora, mude para o MetaTrader e faça uma otimização. Selecione seu EA e escolha "Custom Max" como o critério de pesquisa ideal para usar seus critérios personalizados. Inicie a otimização e aguarde os resultados. Você verá que os critérios personalizados são calculados com base no número de negociações multiplicado pelo fator de lucro.
Se você deseja ajustar o peso do fator de lucro, pode usar a função "MathPower" em seu código. Por exemplo, você pode elevar o fator de lucro à potência de 4 para dar mais peso a ele. Recompile e execute a otimização novamente para ver a classificação atualizada.
Além disso, você pode adicionar uma instrução if ao código para excluir combinações com menos de 100 negócios. Se o número de negócios for inferior a 100, você pode retornar um valor de zero. Isso garante que apenas combinações com um número suficiente de negociações sejam consideradas.
Seguindo essas etapas, você pode criar seus próprios critérios personalizados para classificar e selecionar os melhores resultados de otimização para seu Expert Advisor. Lembre-se de salvar seu EA modificado com um novo nome antes de fazer qualquer alteração. Se você achou este vídeo útil, deixe um like e sinta-se à vontade para compartilhar suas solicitações ou ideias para vídeos futuros nos comentários. Obrigado, e até o próximo vídeo!
Resultados surpreendentes! Padrão de castiçal EA em mql5! | Parte 4
Resultados surpreendentes! Padrão de castiçal EA em mql5! | Parte 4
Olá, sou Toby. No vídeo de hoje, continuaremos codificando o Expert Advisor (EA) do padrão Candlestick. Temos alguns objetivos específicos para este vídeo. Primeiro, adicionaremos um painel ao EA, que exibirá várias condições e seus correspondentes sinais de compra/venda. Também realizaremos verificações de entrada adicionais para garantir a funcionalidade do EA. Por fim, conduziremos alguns backtests e compartilharemos alguns resultados interessantes com você. Então vamos começar.
Antes de prosseguirmos, se você ainda não assistiu às partes anteriores desta série de codificação de padrões de Candlestick, recomendo vê-las primeiro. Você pode encontrar os links na descrição.
Neste vídeo, começaremos criando um painel gráfico para nosso EA. O painel conterá linhas representando diferentes condições, com cruzes indicando sinais de compra e venda. Se as condições forem atendidas, o EA fará negócios na direção especificada. Além disso, implementaremos verificações de entrada para facilitar a otimização no testador de estratégia.
Para começar a codificar o painel, vamos abrir o MetaEditor e navegar até a pasta include. Dentro da pasta include, criaremos uma nova pasta chamada YouTube. Dentro da pasta YouTube, criaremos o arquivo do painel gráfico. Vamos limpar o conteúdo padrão do arquivo e incluir os arquivos necessários para o nosso painel.
A seguir, definiremos os rótulos necessários para o nosso painel. Cada rótulo representará um elemento específico, como número, condição, compra, venda etc. Também criaremos matrizes de rótulos para exibir várias linhas para cada condição.
Depois de definir os rótulos, passaremos a codificar a classe Panel. Essa classe herdará da classe CAppDialog, concedendo-nos acesso a seus membros. Criaremos uma seção privada para os rótulos do painel e alguns métodos, incluindo um construtor, destruidor, onInit, atualização e bannerChartEvent.
O construtor inicializará o painel, enquanto o destruidor cuidará de sua limpeza. O método onInit será chamado a partir da função onInit do EA e criará o painel. O método de atualização será invocado a cada tick para atualizar o conteúdo do painel. Por fim, o método bannerChartEvent tratará dos eventos relacionados ao painel.
Dentro do método createPanel, criaremos o painel real com os parâmetros desejados, como ID do gráfico, nome, subjanela e coordenadas. Garantiremos que o painel seja criado com sucesso e retornaremos verdadeiro se for, ou falso caso contrário.
Assim que a classe do painel for codificada, nós a incluiremos em nosso arquivo de consultor especialista. Vamos criar uma instância do objeto painel e chamar seu método onInit após definir o número mágico. Se a criação do painel falhar, retornaremos uma mensagem de erro apropriada.
É isso para esta parte de nossa série de codificação de padrão de castiçal. No próximo vídeo, continuaremos adicionando funcionalidades ao nosso EA e realizaremos mais testes. Fique atento para resultados mais interessantes.
Bot de negociação estocástica em mql5! | Parte 1
Bot de negociação estocástica em mql5! | Parte 1
Neste vídeo, demonstrarei como codificar um EA estocástico simples no MetaTrader 5. No final do vídeo, também realizaremos backtesting para avaliar o desempenho da estratégia nos últimos 10 anos.
Vamos começar entendendo a ideia geral da estratégia. Usaremos o indicador estocástico, que é amplamente conhecido. O EA executará uma negociação de compra quando o estocástico cruzar o nível inferior e uma negociação de venda quando cruzar o nível superior. Ao olhar para o gráfico, é essencial lembrar que nosso cérebro tende a se concentrar nos negócios lucrativos, por isso é crucial codificar e testar a estratégia para avaliar sua eficácia.
Agora, vamos mudar para o Visual Studio Code para começar a codificar o EA. Vamos criar um novo arquivo na pasta do YouTube usando o MetaEditor padrão e nomeá-lo como "EA estocástico". Em seguida, abriremos o arquivo no Visual Studio Code e faremos alguns ajustes de formatação para melhorar a legibilidade.
Organizaremos o código em seções e começaremos com as inclusões. Precisamos incluir apenas um arquivo, "trades.mqh", que contém a classe CTrade. Depois disso, definiremos as entradas para nosso EA. Teremos uma seção geral para entradas como número mágico e tamanho do lote, seguida por uma seção de negociação para stop loss, take profit e fechamento de negociações em um sinal oposto. Em seguida, teremos uma seção de entrada específica para o indicador estocástico, incluindo o período K e o nível superior.
Depois que as entradas forem definidas, passaremos para a seção de variáveis globais, onde declararemos as variáveis para o identificador do indicador estocástico, buffer, tick atual e objeto de negociação. Após as variáveis globais, vamos implementar a função onInit. Começaremos verificando as entradas do usuário usando a função checkInputs, que garantirá que os valores de entrada estejam dentro do intervalo permitido. Se alguma entrada estiver incorreta, retornaremos "Parâmetros de inicialização incorretos".
Em seguida, definiremos o número mágico para o objeto de negociação usando o valor de entrada fornecido pelo usuário. Em seguida, criaremos o identificador do indicador usando a função estocástica integrada, especificando o símbolo, período, período K, período D (definido como 1 para nenhuma linha de sinal), valor de desaceleração, método MA (SMA) e campo de preço (baixo alto). Verificaremos se a criação do identificador do indicador foi bem-sucedida. Se retornar um identificador inválido, exibiremos uma mensagem de alerta e retornaremos "Init failed". Por fim, definiremos o buffer usando a função arraySetAsSeries para indicar que é uma série temporal.
A seguir, definiremos a função checkInputs, que verificará a validade de cada entrada. Verificaremos se o número mágico e o tamanho do lote estão dentro do intervalo permitido e retornaremos falso se não estiverem. Além disso, podemos adicionar outras verificações, como garantir que o tamanho do lote não seja maior que 10. Com a função onInit e a função checkInputs concluídas, agora podemos compilar o código e prosseguir para as próximas etapas do vídeo.
A função foi projetada para executar várias etapas. Primeiramente, ele recupera o tick atual e o armazena na variável global "CT". Em seguida, procede-se à obtenção dos valores do indicador utilizando a função "CopyBuffer". A função verifica se há erros e, se for bem-sucedida, armazena os valores no buffer "Principal". Se houver algum erro, imprime uma mensagem e sai da função.O próximo passo envolve contar o número de posições abertas. Isso é feito usando a função "CountOpenPositions", e a contagem é armazenada em duas variáveis inteiras, "CountBuy" e "CountSell". Se houver erro na contagem das posições, uma mensagem é impressa e a função é encerrada.
A função então verifica uma negociação de compra ou venda. Se não houver posição de compra aberta (CountBuy é zero), ele verifica os valores do indicador para determinar se uma negociação de compra deve ser aberta. As condições para abrir uma negociação de compra são que o valor do indicador atual esteja abaixo de um nível inferior especificado e o valor do indicador anterior esteja acima do nível inferior. Se essas condições forem atendidas, uma mensagem indicando a abertura de uma posição de compra é impressa. Da mesma forma, a função verifica uma negociação de venda se não houver posição de venda aberta (CountSell é zero). As condições para abrir uma negociação de venda são que o valor do indicador esteja acima de um nível superior especificado e o valor do indicador anterior esteja abaixo do nível superior. Se essas condições forem atendidas, uma mensagem indicando a abertura de uma posição de venda é impressa.
Depois que a lógica de negociação é implementada, a função fecha todas as posições de venda se o parâmetro de entrada "ClosedSignal" for definido como verdadeiro. Ele usa a função "ClosePositions" com o valor do parâmetro de 2 para fechar todas as posições de venda. Se houver erro no fechamento das posições, a função sai e imprime uma mensagem. Em seguida, a função calcula os valores de stop loss e take profit com base nos parâmetros de entrada. Se o valor de stop loss de entrada for zero, o stop loss é definido como zero; caso contrário, é calculado com base no preço do tick atual e no valor de stop loss de entrada. O mesmo processo é seguido para calcular o valor de take profit.
Antes de abrir uma posição, a função normaliza os preços de stop loss e take profit usando a função "NormalizePrice". Se houver um erro na normalização, a função é encerrada. Finalmente, a função abre uma posição usando o método "PositionOpen" do objeto de negociação. A posição é aberta com base no tipo (compra ou venda), volume, preço, stop loss e take profit. Um comentário de pedido também está incluído.
A função é compilada para garantir que não haja erros e, em seguida, pode ser testada no MetaTrader usando dados históricos para ver se as aberturas e fechamentos de negociação desejados ocorrem de acordo com as condições especificadas. Depois de abrir uma posição, a função verifica se há erros usando a função "GetLastError". Se houver um erro, ele imprime uma mensagem e sai.
Finalmente, a função atualiza as variáveis globais "LastTick" e "LastSignal" com o tick atual e o tipo de sinal (compra ou venda) respectivamente. Isso é feito para acompanhar o último tick processado e sinalizar para cálculos futuros.
Esta função recupera o tick atual, obtém valores de indicadores, conta o número de posições abertas, verifica oportunidades de negociação, abre posições com base em condições especificadas, fecha posições de venda, se necessário, calcula stop loss e valores de lucro, normaliza os preços, abre posições , lida com erros e atualiza variáveis globais.
Para usar esta função em um ambiente MetaTrader 5, você precisaria integrá-la a um consultor especialista ou script e personalizar os parâmetros de entrada e os valores dos indicadores de acordo com sua estratégia de negociação. Além disso, você pode precisar implementar outras funções para gerenciar posições, lidar com erros e realizar outras operações de negociação.
Observe que a explicação fornecida é um entendimento geral com base nas informações fornecidas e a implementação real pode variar dependendo da plataforma de negociação específica e da linguagem de programação usada.
EA estocástico para MetaTrader 5 | Parte 2
EA estocástico para MetaTrader 5 | Parte 2
Neste vídeo, Toby se apresenta como o anfitrião e menciona que eles discutirão um filtro simples para melhorar as estratégias de negociação usando o indicador estocástico. Toby menciona que o filtro pode ser aplicado não apenas ao indicador estocástico, mas também a outros indicadores.
Toby explica que na primeira parte do tutorial de codificação, eles cobriram a lógica central do EA (Expert Advisor) e do indicador. Nesta parte, eles planejam adicionar diferentes sinais de entrada e um filtro para aprimorar a estratégia. Antes de mergulhar na codificação, Toby enfatiza a importância de entender o objetivo. Eles explicam os componentes que desejam adicionar ao EA, incluindo um segundo tipo de sinal de entrada baseado na saída das zonas inferior e superior do indicador e a opção de inverter os sinais.
Toby então sugere mudar para o Visual Studio Code, um editor que eles recomendam para codificação MQL5. Eles mencionam que o código em que trabalharão é o EA criado na primeira parte. Depois de compilar para garantir que está funcionando corretamente, eles prosseguem com a codificação.
A primeira etapa é adicionar uma entrada para o modo de sinal usando uma enumeração (enumeração) para os diferentes modos. Eles criam a enumeração chamada "modo de sinal" com opções como "saída cruzada normal", "entrada cruzada normal", "saída cruzada invertida" e "entrada cruzada invertida". Toby explica o significado de cada opção e como isso afeta a estratégia de negociação.
Depois de adicionar a enumeração, Toby a adiciona como uma entrada no código e atribui a opção padrão como "saída cruzada normal". Eles também se certificam de compilar o código para verificar se há erros.
Em seguida, Toby planeja usar o modo de sinal na função OnTick() para verificar novos sinais. Para simplificar o código e evitar instruções if complexas, Toby decide escrever uma função separada chamada "sinal de verificação" para lidar com a lógica do sinal. Eles explicam que esta função retornará um valor booleano indicando se uma negociação deve ser aberta ou não.
Toby cria a função "sinal de verificação", que recebe dois parâmetros: um parâmetro booleano para especificar se está verificando um sinal de compra ou venda e um parâmetro inteiro para a contagem de posições abertas. Eles adicionam um comentário explicando o propósito da função e os parâmetros. Eles também adicionam uma verificação para retornar false se uma posição já estiver aberta.
Em seguida, Toby adiciona código para verificar os cruzamentos com base no modo de sinal selecionado. Eles criam variáveis booleanas para cada opção de cruzamento, como "cruzamento de saída superior", "cruzamento de entrada superior", "cruzamento de saída inferior" e "cruzamento de entrada inferior". Eles explicam a lógica por trás de cada condição de cruzamento, referenciando os valores dos buffers do indicador estocástico.
Depois de adicionar as verificações cruzadas, Toby compila o código para garantir que não haja erros. Eles também adicionam a instrução if ausente e corrigem os erros de compilação.
Com a função "sinal de verificação" e verificações cruzadas, Toby retorna à função OnTick() e substitui as instruções if existentes para verificar as posições de compra e venda com chamadas para a função "sinal de verificação". Eles passam os parâmetros apropriados e a contagem de posições abertas para a função e verificam se ela retorna true antes de abrir uma negociação.
Depois de compilar o código novamente, Toby muda para o MetaTrader para testar a lógica do EA. Eles selecionam o EA, escolhem o modo somente preço aberto e ativam o modo visual para teste. Eles configuram os parâmetros de entrada para cada modo de sinal e executam o teste visual. Toby explica que é importante testar o EA completamente para garantir que ele se comporte conforme o esperado.
Toby conclui que todos os modos de sinal estão funcionando corretamente com base nos resultados do teste visual. Eles sugerem adicionar um filtro na próxima parte do tutorial.
Atualmente, recuperamos os valores "um" e "dois" para verificar um sinal. No entanto, quero modificar isso para que comecemos no índice 0 com nosso buffer. Além disso, devemos recuperar três valores para o sinal de verificação. Se nosso filtro de verificação de barras limpas estiver ativo, podemos precisar de valores adicionais. Para implementar essas mudanças, precisamos modificar o código.
Primeiro, vamos rolar até onde recuperamos os valores do indicador. Na função "desmarcar", onde temos a linha "obter valores do indicador", precisamos fazer algumas alterações. O primeiro parâmetro representa o número do buffer do indicador. Estamos interessados apenas na linha principal, que está no índice 0. Portanto, permanece o mesmo. No entanto, a posição inicial está atualmente definida como índice 1 e recuperamos dois valores. Queremos alterar a posição inicial para o índice 0 e recuperar pelo menos três valores. Portanto, modificamos o código para começar no índice 0 e recuperamos três valores: zero, um e dois.
Se nosso filtro de verificação de barras limpas estiver ativo, precisamos recuperar valores de indicadores adicionais para verificar o filtro. Precisamos recuperar "três" mais nosso valor de barras transparentes de entrada. Por exemplo, se o valor das barras transparentes de entrada for definido como 5, precisamos de um total de oito valores. Portanto, modificamos o código de acordo para recuperar valores começando do índice 0 até o número necessário de valores.
Depois de fazer essas alterações, precisamos armazenar os valores recuperados no buffer denominado "Principal". Além disso, devemos verificar se a função foi bem-sucedida em recuperar os valores solicitados, que são três mais o valor das barras transparentes de entrada. Modificamos o código para incluir esta verificação.
Em seguida, precisamos atualizar o código onde verificamos o sinal. Em vez de acessar o buffer Main no índice 0, agora precisamos acessá-lo nos índices 1 e 2 para a verificação de cruzamento. Substituímos todas as instâncias do índice 0 por 1 e do índice 1 por 2.
Agora temos os valores corretos do indicador e podemos prosseguir para o loop for. Devemos compilar o código para garantir que não haja erros.
No loop for, queremos verificar nosso filtro de barras limpas começando no índice 3. Esta é a posição após a verificação do cruzamento do sinal. Continuamos esse loop até que nosso contador esteja abaixo de três mais o valor das barras claras. Por exemplo, se o valor das barras claras for definido como 5, o contador será 8. Isso significa que verificamos até o índice 7, o último valor em nosso loop. O objetivo desse loop é garantir que não haja cruzamentos da linha superior dentro dessas barras. Atualizamos o código para refletir essas alterações.
Dentro do loop for, primeiro verificamos o nível superior. Comparamos o valor no buffer Main[i-1] com o nível superior de entrada. Se for maior e o valor no buffer Main[i] for menor ou igual ao nível superior de entrada, temos um crossover. Também verificamos a condição oposta para um cruzamento na outra direção. Modificamos o código de acordo.
Após o loop for, adicionamos outra instrução if-else. Se a reversão das barras limpas de entrada for verdadeira, retornaremos verdadeiro porque queremos um cruzamento quando o filtro for invertido. Caso contrário, retornamos false.
Por fim, adicionamos uma instrução if-else semelhante para a verificação de nível inferior. Copiamos a instrução if existente e fazemos as alterações necessárias para a verificação de nível inferior.
Depois de fazer essas alterações, compilamos o código novamente para garantir que não haja erros. Agora, podemos usar a função check clear bars em nossa função OnTick.
Na função OnTick, adicionamos a função check clear bars na instrução if onde verificamos o sinal.
Vamos continuar com o processo de otimização. Selecionamos o símbolo Euro/Dólar e o período de tempo a partir de 2019. Usaremos apenas o preço de abertura e o algoritmo genérico rápido. Nosso objetivo de otimização é encontrar os melhores parâmetros para nosso filtro clearbars.
Antes de iniciar a otimização, vamos definir os parâmetros que queremos otimizar. Nesse caso, otimizaremos o período de lookback do filtro clearbars, que determina o número de barras a serem consideradas para o filtro. Vamos testar valores variando de 5 a 20, incrementando em 5. Além disso, vamos otimizar os limiares de nível superior e inferior para o filtro, testando valores de 50 a 150, incrementando em 25.
Agora, vamos executar a otimização e analisar os resultados. Observaremos o lucro líquido, o total de negociações e o fator de lucro para avaliar o desempenho de cada combinação de parâmetros. Com base nessas métricas, podemos identificar os melhores valores de parâmetros que geram o maior lucro.
Depois de executar a otimização, podemos examinar os resultados e identificar os valores dos parâmetros com melhor desempenho. Podemos descobrir que um período de retrospectiva de 10, limite de nível superior de 100 e limite de nível inferior de 75 forneceram o maior lucro líquido e fator de lucro.
Depois de identificarmos os valores de parâmetros ideais, podemos usá-los para testar nossa estratégia em um conjunto de dados maior ou implantá-la em uma conta de negociação real.
Lembre-se de que os resultados da otimização são baseados em dados históricos e podem não garantir o desempenho futuro. É importante monitorar e avaliar continuamente o desempenho da estratégia e ajustar os parâmetros conforme necessário.
Com os parâmetros otimizados, podemos refinar ainda mais nossa estratégia e explorar outras possibilidades de melhoria. Podemos considerar a adição de filtros ou condições adicionais para aumentar a eficácia da estratégia.
Concluindo, o processo de otimização nos ajuda a encontrar os melhores valores de parâmetros para nosso filtro clearbars, melhorando o desempenho da estratégia e potencialmente aumentando a lucratividade. É uma ferramenta valiosa no desenvolvimento e refinamento de estratégias de negociação.