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

#include <Trade\Trade.mqh> input double lotSize = 0.1; input int fastSmaPeriod = 20; //…

  1. User

    #include <Trade\Trade.mqh>

    input double lotSize = 0.1; 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 trailingStart = 30; // Distância em pontos para iniciar o trailing stop input double trailingStep = 10; // Passo do trailing stop em pontos

    bool orderOpened = false; ulong orderTicket = 0; CTrade trade;

    //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { return(INIT_SUCCEEDED); }

    //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { }

    //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { 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);
    double pointSize = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
    
    // Verificar se uma ordem aberta deve ser fechada ou ajustada
    if (PositionSelect(_Symbol))
    {
        long positionType = PositionGetInteger(POSITION_TYPE);
        double positionPriceOpen = PositionGetDouble(POSITION_PRICE_OPEN);
        double positionStopLoss = PositionGetDouble(POSITION_SL);
    
        // Calcular lucro atual em pontos
        double currentProfitPoints = (priceClose - positionPriceOpen) / pointSize;
        if (positionType == POSITION_TYPE_SELL)
            currentProfitPoints = (positionPriceOpen - priceClose) / pointSize;
    
        // Fechar ordem se as condições de mercado se inverterem
        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());
            }
        }
        else if (currentProfitPoints > trailingStart)
        {
            // Aplicar o trailing stop
            if (positionType == POSITION_TYPE_BUY)
            {
                double newStopLoss = priceClose - trailingStep * pointSize;
                if (newStopLoss > positionStopLoss)
                {
                    trade.PositionModify(PositionGetInteger(POSITION_TICKET), newStopLoss, 0);
                    Print("Trailing stop ajustado para compra: ", newStopLoss);
                }
            }
            else if (positionType == POSITION_TYPE_SELL)
            {
                double newStopLoss = priceClose + trailingStep * pointSize;
                if (newStopLoss < positionStopLoss)
                {
                    trade.PositionModify(PositionGetInteger(POSITION_TICKET), newStopLoss, 0);
                    Print("Trailing stop ajustado para venda: ", newStopLoss);
                }
            }
        }
    }
    else
    {
        // Configurações de ordens de compra e venda
        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());
            }
        }
    }
    

    }

    eu acho que esse trailing stop esta muito curso esta dando mais prejuizo doque o codigo sem trailing stop, oque voce me recomenda fazer?

  2. Assistant

    Se o trailing stop está resultando em mais prejuízos do que benefícios, você pode considerar algumas estratégias para ajustar a sua lógica de trailing stop:

    1. Aumentar o trailingStart:

      • Um valor maior para trailingStart significa que a posição só começará a ajustar o stop loss após um lucro maior acumulado. Isso pode reduzir a probabilidade de ser interrompido prematuramente por movimentos momentâneos do mercado.
    2. Aumentar o trailingStep:

      • Um trailingStep maior pode conferir à sua posição mais espaço para respirar, permitindo flutuações normais do mercado sem trigar o stop loss. Isso pode permitir que a posição continue a crescer antes de ser interrompida.
    3. Avaliar Volatilidade:

      • Calcule ou integre um indicador de volatilidade, como o ATR (Average True Range), para dinamicamente ajustar trailingStart e trailingStep de acordo com a volatilidade atual do mercado. Em mercados mais voláteis, um trailing stop mais amplo pode ser mais apropriado.
    4. Analisar Condições de Mercado:

      • Certifique-se de que as condições de mercado (como volume e volatilidade) em que sua estratégia está sendo executada são adequadas para a lógica do trailing stop. Mercados laterais ou altamente voláteis podem não ser adequados para estratégias com trailing stops apertados.
    5. Testar com Backtest:

      • Execute backtests para diferentes configurações de trailing stop para identificar combinações que maximizem os lucros e minimizem as perdas no seu contexto de negociação específico.
    6. Monitorar Resultados:

      • Observe como as mudanças impactam suas operações ao longo do tempo. O ajuste fino e contínuo das suas estratégias de trading pode ser necessário devido às dinâmicas sempre em mudança do mercado.

    Alterar esses parâmetros pode ajudar a alcançar um equilíbrio entre proteger os lucros e permitir que as negociações comuns evoluam favoravelmente. Como sempre, faça ajustes em ambientes de simulação com históricos de dados antes de aplicar em contas reais para evitar perdas indesejadas.

  3. User

    aumenar o trailing para quais configurações?

    #include <Trade\Trade.mqh>

    input double lotSize = 0.1; 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 trailingStart = 30; // Distância em pontos para iniciar o trailing stop input double trailingStep = 10; // Passo do trailing stop em pontos

    bool orderOpened = false; ulong orderTicket = 0; CTrade trade;

    //+------------------------------------------------------------------+ //| Expert initialization function | //+------------------------------------------------------------------+ int OnInit() { return(INIT_SUCCEEDED); }

    //+------------------------------------------------------------------+ //| Expert deinitialization function | //+------------------------------------------------------------------+ void OnDeinit(const int reason) { }

    //+------------------------------------------------------------------+ //| Expert tick function | //+------------------------------------------------------------------+ void OnTick() { 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);
    double pointSize = SymbolInfoDouble(_Symbol, SYMBOL_POINT);
    
    // Verificar se uma ordem aberta deve ser fechada ou ajustada
    if (PositionSelect(_Symbol))
    {
        long positionType = PositionGetInteger(POSITION_TYPE);
        double positionPriceOpen = PositionGetDouble(POSITION_PRICE_OPEN);
        double positionStopLoss = PositionGetDouble(POSITION_SL);
    
        // Calcular lucro atual em pontos
        double currentProfitPoints = (priceClose - positionPriceOpen) / pointSize;
        if (positionType == POSITION_TYPE_SELL)
            currentProfitPoints = (positionPriceOpen - priceClose) / pointSize;
    
        // Fechar ordem se as condições de mercado se inverterem
        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());
            }
        }
        else if (currentProfitPoints > trailingStart)
        {
            // Aplicar o trailing stop
            if (positionType == POSITION_TYPE_BUY)
            {
                double newStopLoss = priceClose - trailingStep * pointSize;
                if (newStopLoss > positionStopLoss)
                {
                    trade.PositionModify(PositionGetInteger(POSITION_TICKET), newStopLoss, 0);
                    Print("Trailing stop ajustado para compra: ", newStopLoss);
                }
            }
            else if (positionType == POSITION_TYPE_SELL)
            {
                double newStopLoss = priceClose + trailingStep * pointSize;
                if (newStopLoss < positionStopLoss)
                {
                    trade.PositionModify(PositionGetInteger(POSITION_TICKET), newStopLoss, 0);
                    Print("Trailing stop ajustado para venda: ", newStopLoss);
                }
            }
        }
    }
    else
    {
        // Configurações de ordens de compra e venda
        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());
            }
        }
    }
    

    }

  4. Assistant

    Para ajustar o trailing stop de maneira que ele tenha um impacto mais positivo em seu sistema de trading, você pode realizar algumas modificações e testes. Vamos começar por sugerir algumas configurações:

    1. Aumentar trailingStart:

      • Considere aumentar o valor de trailingStart para algo em torno de 50-100 pontos ou mais, dependendo da volatilidade do ativo que você está negociando. Isso permitirá que a posição tenha um espaço inicial maior antes de começar a proteger o lucro.
    2. Aumentar trailingStep:

      • Um valor maior para trailingStep pode ser algo como 20-30 pontos. Novamente, o ajuste deve considerar a volatilidade do ativo. Trailing steps maiores permitem que as posições se ajustem menos frequentemente, dando mais espaço para que o mercado se mova antes de ajustes sucessivos no stop loss.

    Exemplo de Modificação:

    input double trailingStart = 50; // Aumentado para iniciar o trailing stop
    input double trailingStep = 20;  // Aumentado para um ajuste mais espaçado
    

    Considerações Adicionais:

    • Analisando o Histórico: Utilize backtesting para verificar como essas novas configurações se comportariam no passado recente. Analise diferentes períodos e condições de mercado para coletar dados substanciais antes da implementação em operações reais.

    • Ajustes Dinâmicos: Com base em indicadores de volatilidade, como o ATR, ajustando trailingStart e trailingStep dinamicamente, você pode criar uma estratégia mais adaptativa às condições do mercado.

    • Feedback Visual: Implementar logs com estatísticas das ordens fechadas pode te ajudar a entender melhor o impacto dos parametros. Analise quantas vezes o trailing stop foi ajustado e como isso afetou a performance de cada posição.

    Essas sugestões são um ponto de partida e as melhores configurações podem variar bastante de acordo com os ativos que você está negociando. Portanto, é essencial realizar testes exaustivos para encontrar os parâmetros que otimizam sua estratégia de trading.