Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-08-06· OpenAIAi2 WildChat-4.8M (AI2)

preciso que esse robo tenha opção de configurar stoploss pode ele vais er usado para…

  1. User

    preciso que esse robo tenha opção de configurar stoploss pode ele vais er usado para mesaproprietria valor padrao sera de 6500.0, nao altere nada no codigo apenas adicione aopção do stoploss pois é um exigencia das mesas proprietaria ter stoploss na operção

    #include <Trade\Trade.mqh>

    input double lotSize = 0.01; input int fastSmaPeriod = 20; // Período para a média móvel rápida input int slowSmaPeriod = 200; // Período para a média móvel lenta

    // Variáveis globais para controle de ordens bool orderOpened = false; ulong orderTicket = 0; CTrade trade;

    //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { // Configurações do EA return(INIT_SUCCEEDED); }

    //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { // Função de finalização }

    //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { // Arrays para armazenar valores das SMAs double fastSma[1], slowSma[1];

    // Obtenha valor do SMA rápido int fastSmaHandle = iMA(_Symbol, PERIOD_H1, fastSmaPeriod, 0, MODE_SMA, PRICE_CLOSE); if (CopyBuffer(fastSmaHandle, 0, 0, 1, fastSma) <= 0) { Print("Erro ao copiar buffer do SMA rápido: ", GetLastError()); return; }

    // Obtenha valor do SMA lento int slowSmaHandle = iMA(_Symbol, PERIOD_H1, slowSmaPeriod, 0, MODE_SMA, PRICE_CLOSE); if (CopyBuffer(slowSmaHandle, 0, 0, 1, slowSma) <= 0) { Print("Erro ao copiar buffer do SMA lento: ", GetLastError()); return; }

    double priceClose = iClose(_Symbol, PERIOD_H1, 0);

    // Verificar se uma ordem aberta deve ser fechada if (orderOpened) { if (PositionSelect(_Symbol)) { long positionType = PositionGetInteger(POSITION_TYPE);

        // Feche ordens com base nas condições opostas
        if ((positionType == POSITION_TYPE_BUY && fastSma[0] < slowSma[0]) ||
            (positionType == POSITION_TYPE_SELL && fastSma[0] > slowSma[0]))
        {
            if (trade.PositionClose(_Symbol))
            {
                Print("Ordem existente fechada.");
                orderOpened = false;
                orderTicket = 0;
            }
            else
            {
                Print("Erro ao fechar ordem: ", trade.ResultRetcode(), " - ", GetLastError());
            }
        }
    }
    

    }

    // Configurações de ordens de compra e venda if (!orderOpened) { if (fastSma[0] > slowSma[0] && priceClose > fastSma[0]) { if (trade.Buy(lotSize, _Symbol)) { orderTicket = trade.ResultOrder(); orderOpened = true; Print("Ordem de compra aberta! Ticket: ", orderTicket); } else { Print("Erro ao abrir ordem de compra: ", trade.ResultRetcode(), " - ", GetLastError()); } } else if (fastSma[0] < slowSma[0] && priceClose < fastSma[0]) { if (trade.Sell(lotSize, _Symbol)) { orderTicket = trade.ResultOrder(); orderOpened = true; Print("Ordem de venda aberta! Ticket: ", orderTicket); } else { Print("Erro ao abrir ordem de venda: ", trade.ResultRetcode(), " - ", GetLastError()); } } } }

  2. Assistant

    Para adicionar a configuração de Stop Loss conforme as exigências das mesas proprietárias, podemos incluir essa funcionalidade no código. Vou adicionar o parâmetro input para o Stop Loss e ajustar a abertura das ordens de compra e venda para utilizar esse valor. Além disso, vamos calcular e aplicar o Stop Loss ao abrir cada ordem:

    #include <Trade\Trade.mqh>
    
    input double lotSize = 0.01;
    input int fastSmaPeriod = 20; // Período para a média móvel rápida
    input int slowSmaPeriod = 200; // Período para a média móvel lenta
    input double stopLoss = 6500.0; // Valor padrão para o Stop Loss
    
    // Variáveis globais para controle de ordens
    bool orderOpened = false;
    ulong orderTicket = 0;
    CTrade trade;
    double pointValue;
    
    //+------------------------------------------------------------------+
    //| Expert initialization function |
    //+------------------------------------------------------------------+
    int OnInit()
    {
        // Configurações do EA
        pointValue = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
        return(INIT_SUCCEEDED);
    }
    
    //+------------------------------------------------------------------+
    //| Expert deinitialization function |
    //+------------------------------------------------------------------+
    void OnDeinit(const int reason)
    {
        // Função de finalização
    }
    
    //+------------------------------------------------------------------+
    //| Expert tick function |
    //+------------------------------------------------------------------+
    void OnTick()
    {
        // Arrays para armazenar valores das SMAs
        double fastSma[1], slowSma[1];
    
        // Obtenha valor do SMA rápido
        int fastSmaHandle = iMA(_Symbol, PERIOD_H1, fastSmaPeriod, 0, MODE_SMA, PRICE_CLOSE);
        if (CopyBuffer(fastSmaHandle, 0, 0, 1, fastSma) <= 0)
        {
            Print("Erro ao copiar buffer do SMA rápido: ", GetLastError());
            return;
        }
    
        // Obtenha valor do SMA lento
        int slowSmaHandle = iMA(_Symbol, PERIOD_H1, slowSmaPeriod, 0, MODE_SMA, PRICE_CLOSE);
        if (CopyBuffer(slowSmaHandle, 0, 0, 1, slowSma) <= 0)
        {
            Print("Erro ao copiar buffer do SMA lento: ", GetLastError());
            return;
        }
    
        double priceClose = iClose(_Symbol, PERIOD_H1, 0);
    
        // Verificar se uma ordem aberta deve ser fechada
        if (orderOpened)
        {
            if (PositionSelect(_Symbol))
            {
                long positionType = PositionGetInteger(POSITION_TYPE);
    
                // Feche ordens com base nas condições opostas
                if ((positionType == POSITION_TYPE_BUY && fastSma[0] < slowSma[0]) ||
                    (positionType == POSITION_TYPE_SELL && fastSma[0] > slowSma[0]))
                {
                    if (trade.PositionClose(_Symbol))
                    {
                        Print("Ordem existente fechada.");
                        orderOpened = false;
                        orderTicket = 0;
                    }
                    else
                    {
                        Print("Erro ao fechar ordem: ", trade.ResultRetcode(), " - ", GetLastError());
                    }
                }
            }
        }
    
        // Configurações de ordens de compra e venda
        if (!orderOpened)
        {
            double sl = 0;
            if (fastSma[0] > slowSma[0] && priceClose > fastSma[0])
            {
                // Calcula o preço de Stop Loss para ordem de compra
                sl = NormalizeDouble(priceClose - stopLoss * pointValue, _Digits);
                if (trade.Buy(lotSize, _Symbol, 0, sl))
                {
                    orderTicket = trade.ResultOrder();
                    orderOpened = true;
                    Print("Ordem de compra aberta! Ticket: ", orderTicket);
                }
                else
                {
                    Print("Erro ao abrir ordem de compra: ", trade.ResultRetcode(), " - ", GetLastError());
                }
            }
            else if (fastSma[0] < slowSma[0] && priceClose < fastSma[0])
            {
                // Calcula o preço de Stop Loss para ordem de venda
                sl = NormalizeDouble(priceClose + stopLoss * pointValue, _Digits);
                if (trade.Sell(lotSize, _Symbol, 0, sl))
                {
                    orderTicket = trade.ResultOrder();
                    orderOpened = true;
                    Print("Ordem de venda aberta! Ticket: ", orderTicket);
                }
                else
                {
                    Print("Erro ao abrir ordem de venda: ", trade.ResultRetcode(), " - ", GetLastError());
                }
            }
        }
    }
    

    Neste código, adicionei uma configuração do valor de Stop Loss com o parâmetro input double stopLoss = 6500.0;. Quando as ordens são abertas, o Stop Loss é calculado com base no preço de fechamento atual ajustado pelo valor definido, utilizando pointValue e NormalizeDouble para garantir precisão. O Stop Loss é então aplicado durante a abertura da ordem.

  3. User

    #include <Trade\Trade.mqh>

    input double lotSize = 0.01; input int fastSmaPeriod = 20; // Período para a média móvel rápida input int slowSmaPeriod = 200; // Período para a média móvel lenta input double stopLoss = 6500.0; // Valor padrão para o Stop Loss

    // Variáveis globais para controle de ordens bool orderOpened = false; ulong orderTicket = 0; CTrade trade; double pointValue;

    //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { // Configurações do EA pointValue = SymbolInfoDouble(_Symbol, SYMBOL_POINT); return(INIT_SUCCEEDED); }

    //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { // Função de finalização }

    //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { // Arrays para armazenar valores das SMAs double fastSma[1], slowSma[1];

    // Obtenha valor do SMA rápido
    int fastSmaHandle = iMA(_Symbol, PERIOD_H1, fastSmaPeriod, 0, MODE_SMA, PRICE_CLOSE);
    if (CopyBuffer(fastSmaHandle, 0, 0, 1, fastSma) <= 0)
    {
        Print("Erro ao copiar buffer do SMA rápido: ", GetLastError());
        return;
    }
    
    // Obtenha valor do SMA lento
    int slowSmaHandle = iMA(_Symbol, PERIOD_H1, slowSmaPeriod, 0, MODE_SMA, PRICE_CLOSE);
    if (CopyBuffer(slowSmaHandle, 0, 0, 1, slowSma) <= 0)
    {
        Print("Erro ao copiar buffer do SMA lento: ", GetLastError());
        return;
    }
    
    double priceClose = iClose(_Symbol, PERIOD_H1, 0);
    
    // Verificar se uma ordem aberta deve ser fechada
    if (orderOpened)
    {
        if (PositionSelect(_Symbol))
        {
            long positionType = PositionGetInteger(POSITION_TYPE);
    
            // Feche ordens com base nas condições opostas
            if ((positionType == POSITION_TYPE_BUY && fastSma[0] < slowSma[0]) ||
                (positionType == POSITION_TYPE_SELL && fastSma[0] > slowSma[0]))
            {
                if (trade.PositionClose(_Symbol))
                {
                    Print("Ordem existente fechada.");
                    orderOpened = false;
                    orderTicket = 0;
                }
                else
                {
                    Print("Erro ao fechar ordem: ", trade.ResultRetcode(), " - ", GetLastError());
                }
            }
        }
    }
    
    // Configurações de ordens de compra e venda
    if (!orderOpened)
    {
        double sl = 0;
        if (fastSma[0] > slowSma[0] && priceClose > fastSma[0])
        {
            // Calcula o preço de Stop Loss para ordem de compra
            sl = NormalizeDouble(priceClose - stopLoss * pointValue, _Digits);
            if (trade.Buy(lotSize, _Symbol, 0, sl))
            {
                orderTicket = trade.ResultOrder();
                orderOpened = true;
                Print("Ordem de compra aberta! Ticket: ", orderTicket);
            }
            else
            {
                Print("Erro ao abrir ordem de compra: ", trade.ResultRetcode(), " - ", GetLastError());
            }
        }
        else if (fastSma[0] < slowSma[0] && priceClose < fastSma[0])
        {
            // Calcula o preço de Stop Loss para ordem de venda
            sl = NormalizeDouble(priceClose + stopLoss * pointValue, _Digits);
            if (trade.Sell(lotSize, _Symbol, 0, sl))
            {
                orderTicket = trade.ResultOrder();
                orderOpened = true;
                Print("Ordem de venda aberta! Ticket: ", orderTicket);
            }
            else
            {
                Print("Erro ao abrir ordem de venda: ", trade.ResultRetcode(), " - ", GetLastError());
            }
        }
    }
    

    }

    parou de abrir ordens depois de adicionar o stoploss

  4. Assistant

    O problema pode estar relacionado à forma como o Stop Loss está sendo calculado e aplicado na configuração de ordens. Vamos verificar algumas possibilidades de ajustes e garantir que o Stop Loss seja configurado corretamente.

    1. Verifique as condições de mercado: Garanta que haja movimento suficiente no mercado que satisfaça as condições de cruzamento das médias móveis.

    2. Confirme o valor do Stop Loss: Certifique-se de que o valor do stopLoss que você está usando seja apropriado para o ativo que está sendo negociado.

    3. Ajuste o cálculo do Stop Loss: Vamos revisar o código e ajustar como o Stop Loss é calculado e aplicado. É importante lembrar que o preço do Stop Loss deve estar do lado correto do preço atual (abaixo para compras e acima para vendas).

    Aqui está uma versão ajustada do código:

    #include <Trade\Trade.mqh>
    
    input double lotSize = 0.01;
    input int fastSmaPeriod = 20; // Período para a média móvel rápida
    input int slowSmaPeriod = 200; // Período para a média móvel lenta
    input double stopLoss = 6500.0; // Valor padrão para o Stop Loss
    
    // Variáveis globais para controle de ordens
    bool orderOpened = false;
    ulong orderTicket = 0;
    CTrade trade;
    double pointValue; 
    
    //+------------------------------------------------------------------+
    //| Expert initialization function |
    //+------------------------------------------------------------------+
    int OnInit()
    {
        // Configurações do EA
        pointValue = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
        return(INIT_SUCCEEDED);
    }
    
    //+------------------------------------------------------------------+
    //| Expert deinitialization function |
    //+------------------------------------------------------------------+
    void OnDeinit(const int reason)
    {
        // Função de finalização
    }
    
    //+------------------------------------------------------------------+
    //| Expert tick function |
    //+------------------------------------------------------------------+
    void OnTick()
    {
        // Arrays para armazenar valores das SMAs
        double fastSma[1], slowSma[1];
    
        // Obtenha valor do SMA rápido
        int fastSmaHandle = iMA(_Symbol, PERIOD_H1, fastSmaPeriod, 0, MODE_SMA, PRICE_CLOSE);
        if (CopyBuffer(fastSmaHandle, 0, 0, 1, fastSma) <= 0)
        {
            Print("Erro ao copiar buffer do SMA rápido: ", GetLastError());
            return;
        }
    
        // Obtenha valor do SMA lento
        int slowSmaHandle = iMA(_Symbol, PERIOD_H1, slowSmaPeriod, 0, MODE_SMA, PRICE_CLOSE);
        if (CopyBuffer(slowSmaHandle, 0, 0, 1, slowSma) <= 0)
        {
            Print("Erro ao copiar buffer do SMA lento: ", GetLastError());
            return;
        }
    
        double priceClose = iClose(_Symbol, PERIOD_H1, 0);
    
        // Verificar se uma ordem aberta deve ser fechada
        if (orderOpened)
        {
            if (PositionSelect(_Symbol))
            {
                long positionType = PositionGetInteger(POSITION_TYPE);
    
                // Feche ordens com base nas condições opostas
                if ((positionType == POSITION_TYPE_BUY && fastSma[0] < slowSma[0]) ||
                    (positionType == POSITION_TYPE_SELL && fastSma[0] > slowSma[0]))
                {
                    if (trade.PositionClose(_Symbol))
                    {
                        Print("Ordem existente fechada.");
                        orderOpened = false;
                        orderTicket = 0;
                    }
                    else
                    {
                        Print("Erro ao fechar ordem: ", trade.ResultRetcode(), " - ", GetLastError());
                    }
                }
            }
        }
    
        // Configurações de ordens de compra e venda
        if (!orderOpened)
        {
            double sl = 0;
            if (fastSma[0] > slowSma[0] && priceClose > fastSma[0])
            {
                // Calcula o preço de Stop Loss para ordem de compra
                sl = NormalizeDouble(priceClose - stopLoss * pointValue, _Digits);
                if (sl < priceClose) // Garante que o SL está abaixo do preço atual
                {
                    if (trade.Buy(lotSize, _Symbol, 0, sl))
                    {
                        orderTicket = trade.ResultOrder();
                        orderOpened = true;
                        Print("Ordem de compra aberta! Ticket: ", orderTicket);
                    }
                    else
                    {
                        Print("Erro ao abrir ordem de compra: ", trade.ResultRetcode(), " - ", GetLastError());
                    }
                }
            }
            else if (fastSma[0] < slowSma[0] && priceClose < fastSma[0])
            {
                // Calcula o preço de Stop Loss para ordem de venda
                sl = NormalizeDouble(priceClose + stopLoss * pointValue, _Digits);
                if (sl > priceClose) // Garante que o SL está acima do preço atual
                {
                    if (trade.Sell(lotSize, _Symbol, 0, sl))
                    {
                        orderTicket = trade.ResultOrder();
                        orderOpened = true;
                        Print("Ordem de venda aberta! Ticket: ", orderTicket);
                    }
                    else
                    {
                        Print("Erro ao abrir ordem de venda: ", trade.ResultRetcode(), " - ", GetLastError());
                    }
                }
            }
        }
    }
    

    Verificações adicionais:

    • Certifique-se de que stopLoss tem um valor apropriado, e que 6500.0 faz sentido no contexto de ponto (por exemplo, se a calculadora de pip determinar um SL de 65 pips e a contagem de dígitos está correta).
    • Ajuste seus logs e depurações para garantir que as condições de sinal se encontrem e os valores do stop sejam calculados como esperado.
    • Tenha certeza que os servidores da corretora não estão rejeitando as ordens devido a SL inaplicáveis (muito próximos do preço atual).