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

//+------------------------------------------------------------------+ // GannEA.mq5 //…

  1. User

    //+------------------------------------------------------------------+ //| GannEA.mq5 | //| Example of Gann Strategy in MQL5 | //+------------------------------------------------------------------+ #property strict

    // Input parameters input int TimeFrame = PERIOD_H1; // Timeframe para o cálculo (1H) input double AngleSlope = 1.0; // Inclinação do ângulo 1x1 (1:1)

    // Variáveis globais double gannAngle; // Valor do ângulo de Gann (1x1) datetime lastTime; // Último tempo de execução do EA

    // Função para calcular o ângulo de Gann double CalculateGannAngle(double referencePrice, datetime referenceTime, datetime currentTime) { // A inclinação é baseada na relação 1x1 (1 preço: 1 tempo) double timeDifference = (currentTime - referenceTime) / 60.0; // Diferença de tempo em minutos double priceDifference = referencePrice - SymbolInfoDouble(Symbol(), SYMBOL_ASK); // Diferença de preço

    // A linha de Gann será calculada como a diferença entre preço e tempo
    return referencePrice - (timeDifference * AngleSlope);
    

    }

    // Função de inicialização int OnInit() { lastTime = Time[0]; // Pega o tempo da última vela return INIT_SUCCEEDED; }

    // Função principal de execução do EA void OnTick() { // Verificar se houve mudança de vela if (Time[0] != lastTime) { lastTime = Time[0]; // Atualiza o tempo da vela

        // Pega o preço de fechamento e o tempo de referência para o cálculo
        double referencePrice = Close[1];  // Acesso ao preço de fechamento da vela anterior
        datetime referenceTime = Time[1];  // Acesso ao tempo da vela anterior
    
        // Calcular o ângulo de Gann para o próximo preço
        gannAngle = CalculateGannAngle(referencePrice, referenceTime, Time[0]);
    
        // Verificar as condições de compra ou venda
        double askPrice = SymbolInfoDouble(Symbol(), SYMBOL_ASK);  // Preço de compra
        double bidPrice = SymbolInfoDouble(Symbol(), SYMBOL_BID);  // Preço de venda
    
        if (askPrice > gannAngle)  // Condição de compra: preço acima do ângulo
        {
            // Verifica se já existe uma ordem aberta, se não, abre uma compra
            if (PositionsTotal() == 0)
            {
                // Abrir ordem de compra
                MqlTradeRequest request = {};
                MqlTradeResult result = {};
                
                request.action = TRADE_ACTION_DEAL;
                request.symbol = Symbol();
                request.volume = 0.1;
                request.type = ORDER_TYPE_BUY;
                request.price = askPrice;
                request.sl = 0;
                request.tp = 0;
                request.deviation = 10;
                
                if (OrderSend(request, result))
                {
                    Print("Compra executada com sucesso.");
                }
                else
                {
                    Print("Erro ao executar compra: ", result.comment);
                }
            }
        }
        else if (bidPrice < gannAngle)  // Condição de venda: preço abaixo do ângulo
        {
            // Verifica se já existe uma ordem aberta, se não, abre uma venda
            if (PositionsTotal() == 0)
            {
                // Abrir ordem de venda
                MqlTradeRequest request = {};
                MqlTradeResult result = {};
                
                request.action = TRADE_ACTION_DEAL;
                request.symbol = Symbol();
                request.volume = 0.1;
                request.type = ORDER_TYPE_SELL;
                request.price = bidPrice;
                request.sl = 0;
                request.tp = 0;
                request.deviation = 10;
                
                if (OrderSend(request, result))
                {
                    Print("Venda executada com sucesso.");
                }
                else
                {
                    Print("Erro ao executar venda: ", result.comment);
                }
            }
        }
    }
    

    } //+------------------------------------------------------------------+

    corrija os erros:

    'Time' - undeclared identifier Gann_Teste_001.mq5 29 16 '[' - array required Gann_Teste_001.mq5 29 20 'Time' - undeclared identifier Gann_Teste_001.mq5 37 9 '[' - array required Gann_Teste_001.mq5 37 13 'Time' - undeclared identifier Gann_Teste_001.mq5 39 20 '[' - array required Gann_Teste_001.mq5 39 24 'Close' - undeclared identifier Gann_Teste_001.mq5 42 33 '[' - array required Gann_Teste_001.mq5 42 38 'Time' - undeclared identifier Gann_Teste_001.mq5 43 34 '[' - array required Gann_Teste_001.mq5 43 38 'Time' - undeclared identifier Gann_Teste_001.mq5 46 71 '[' - array required Gann_Teste_001.mq5 46 75

  2. Assistant

    Os erros apresentados estão relacionados ao acesso a arrays de tempos e preços no código MQL5. Estes arrays, como Time[] e Close[], estão disponíveis apenas nas funções que lidam com séries de tempo, como OnCalculate. No contexto do Expert Advisor (EA), que é executado no gráfico, eles não estão disponíveis diretamente. Em vez disso, você deve usar funções específicas para obter essas informações, como iTime, iClose, etc. Vou corrigir seu código com as mudanças necessárias:

    //+------------------------------------------------------------------+
    //|                                                        GannEA.mq5 |
    //|                        Example of Gann Strategy in MQL5          |
    //+------------------------------------------------------------------+
    #property strict
    
    // Input parameters
    input int TimeFrame = PERIOD_H1;  // Timeframe para o cálculo (1H)
    input double AngleSlope = 1.0;    // Inclinação do ângulo 1x1 (1:1)
    
    // Variáveis globais
    double gannAngle;  // Valor do ângulo de Gann (1x1)
    datetime lastTime;  // Último tempo de execução do EA
    
    // Função para calcular o ângulo de Gann
    double CalculateGannAngle(double referencePrice, datetime referenceTime, datetime currentTime)
    {
        // A inclinação é baseada na relação 1x1 (1 preço: 1 tempo)
        double timeDifference = (currentTime - referenceTime) / 60.0;  // Diferença de tempo em minutos
        double priceDifference = referencePrice - SymbolInfoDouble(Symbol(), SYMBOL_ASK);  // Diferença de preço
        
        // A linha de Gann será calculada como a diferença entre preço e tempo
        return referencePrice - (timeDifference * AngleSlope);
    }
    
    // Função de inicialização
    int OnInit()
    {
        lastTime = iTime(Symbol(), TimeFrame, 0);  // Pega o tempo da última vela
        return INIT_SUCCEEDED;
    }
    
    // Função principal de execução do EA
    void OnTick()
    {
        // Verificar se houve mudança de vela
        datetime currentTime = iTime(Symbol(), TimeFrame, 0);
        if (currentTime != lastTime)
        {
            lastTime = currentTime;  // Atualiza o tempo da vela
    
            // Pega o preço de fechamento e o tempo de referência para o cálculo
            double referencePrice = iClose(Symbol(), TimeFrame, 1);  // Acesso ao preço de fechamento da vela anterior
            datetime referenceTime = iTime(Symbol(), TimeFrame, 1);  // Acesso ao tempo da vela anterior
    
            // Calcular o ângulo de Gann para o próximo preço
            gannAngle = CalculateGannAngle(referencePrice, referenceTime, currentTime);
    
            // Verificar as condições de compra ou venda
            double askPrice = SymbolInfoDouble(Symbol(), SYMBOL_ASK);  // Preço de compra
            double bidPrice = SymbolInfoDouble(Symbol(), SYMBOL_BID);  // Preço de venda
    
            if (askPrice > gannAngle)  // Condição de compra: preço acima do ângulo
            {
                // Verifica se já existe uma ordem aberta, se não, abre uma compra
                if (PositionsTotal() == 0)
                {
                    // Abrir ordem de compra
                    MqlTradeRequest request = {};
                    MqlTradeResult result = {};
                    
                    request.action = TRADE_ACTION_DEAL;
                    request.symbol = Symbol();
                    request.volume = 0.1;
                    request.type = ORDER_TYPE_BUY;
                    request.price = askPrice;
                    request.sl = 0;
                    request.tp = 0;
                    request.deviation = 10;
                    
                    if (OrderSend(request, result))
                    {
                        Print("Compra executada com sucesso.");
                    }
                    else
                    {
                        Print("Erro ao executar compra: ", result.comment);
                    }
                }
            }
            else if (bidPrice < gannAngle)  // Condição de venda: preço abaixo do ângulo
            {
                // Verifica se já existe uma ordem aberta, se não, abre uma venda
                if (PositionsTotal() == 0)
                {
                    // Abrir ordem de venda
                    MqlTradeRequest request = {};
                    MqlTradeResult result = {};
                    
                    request.action = TRADE_ACTION_DEAL;
                    request.symbol = Symbol();
                    request.volume = 0.1;
                    request.type = ORDER_TYPE_SELL;
                    request.price = bidPrice;
                    request.sl = 0;
                    request.tp = 0;
                    request.deviation = 10;
                    
                    if (OrderSend(request, result))
                    {
                        Print("Venda executada com sucesso.");
                    }
                    else
                    {
                        Print("Erro ao executar venda: ", result.comment);
                    }
                }
            }
        }
    }
    //+------------------------------------------------------------------+
    

    Agora o código usa iTime() e iClose() para acessar o tempo e o preço de fechamento da vela anterior, tornando o script compatível com o ambiente EA no gráfico.

  3. User

    //+------------------------------------------------------------------+ //| GannEA.mq5 | //| Example of Gann Strategy in MQL5 | //+------------------------------------------------------------------+ #property strict

    // Input parameters input int TimeFrame = PERIOD_H1; // Timeframe para o cálculo (1H) input double AngleSlope = 1.0; // Inclinação do ângulo 1x1 (1:1)

    // Variáveis globais double gannAngle; // Valor do ângulo de Gann (1x1) datetime lastTime; // Último tempo de execução do EA

    // Função para calcular o ângulo de Gann double CalculateGannAngle(double referencePrice, datetime referenceTime, datetime currentTime) { // A inclinação é baseada na relação 1x1 (1 preço: 1 tempo) double timeDifference = (currentTime - referenceTime) / 60.0; // Diferença de tempo em minutos double priceDifference = referencePrice - SymbolInfoDouble(Symbol(), SYMBOL_ASK); // Diferença de preço

    // A linha de Gann será calculada como a diferença entre preço e tempo
    return referencePrice - (timeDifference * AngleSlope);
    

    }

    // Função de inicialização int OnInit() { lastTime = iTime(Symbol(), TimeFrame, 0); // Pega o tempo da última vela return INIT_SUCCEEDED; }

    // Função principal de execução do EA void OnTick() { // Verificar se houve mudança de vela datetime currentTime = iTime(Symbol(), TimeFrame, 0); if (currentTime != lastTime) { lastTime = currentTime; // Atualiza o tempo da vela

        // Pega o preço de fechamento e o tempo de referência para o cálculo
        double referencePrice = iClose(Symbol(), TimeFrame, 1);  // Acesso ao preço de fechamento da vela anterior
        datetime referenceTime = iTime(Symbol(), TimeFrame, 1);  // Acesso ao tempo da vela anterior
    
        // Calcular o ângulo de Gann para o próximo preço
        gannAngle = CalculateGannAngle(referencePrice, referenceTime, currentTime);
    
        // Verificar as condições de compra ou venda
        double askPrice = SymbolInfoDouble(Symbol(), SYMBOL_ASK);  // Preço de compra
        double bidPrice = SymbolInfoDouble(Symbol(), SYMBOL_BID);  // Preço de venda
    
        if (askPrice > gannAngle)  // Condição de compra: preço acima do ângulo
        {
            // Verifica se já existe uma ordem aberta, se não, abre uma compra
            if (PositionsTotal() == 0)
            {
                // Abrir ordem de compra
                MqlTradeRequest request = {};
                MqlTradeResult result = {};
                
                request.action = TRADE_ACTION_DEAL;
                request.symbol = Symbol();
                request.volume = 0.1;
                request.type = ORDER_TYPE_BUY;
                request.price = askPrice;
                request.sl = 0;
                request.tp = 0;
                request.deviation = 10;
                
                if (OrderSend(request, result))
                {
                    Print("Compra executada com sucesso.");
                }
                else
                {
                    Print("Erro ao executar compra: ", result.comment);
                }
            }
        }
        else if (bidPrice < gannAngle)  // Condição de venda: preço abaixo do ângulo
        {
            // Verifica se já existe uma ordem aberta, se não, abre uma venda
            if (PositionsTotal() == 0)
            {
                // Abrir ordem de venda
                MqlTradeRequest request = {};
                MqlTradeResult result = {};
                
                request.action = TRADE_ACTION_DEAL;
                request.symbol = Symbol();
                request.volume = 0.1;
                request.type = ORDER_TYPE_SELL;
                request.price = bidPrice;
                request.sl = 0;
                request.tp = 0;
                request.deviation = 10;
                
                if (OrderSend(request, result))
                {
                    Print("Venda executada com sucesso.");
                }
                else
                {
                    Print("Erro ao executar venda: ", result.comment);
                }
            }
        }
    }
    

    } //+------------------------------------------------------------------+

    erros:

    'Gann_Teste_001.mq5' 1 'TimeFrame' - cannot convert enum Gann_Teste_001.mq5 29 32 built-in: datetime iTime(const string,ENUM_TIMEFRAMES,int) Gann_Teste_001.mq5 29 32 'TimeFrame' - cannot convert enum Gann_Teste_001.mq5 37 44 built-in: datetime iTime(const string,ENUM_TIMEFRAMES,int) Gann_Teste_001.mq5 37 44 'TimeFrame' - cannot convert enum Gann_Teste_001.mq5 43 50 built-in: double iClose(const string,ENUM_TIMEFRAMES,int) Gann_Teste_001.mq5 43 50 'TimeFrame' - cannot convert enum Gann_Teste_001.mq5 44 50 built-in: datetime iTime(const string,ENUM_TIMEFRAMES,int) Gann_Teste_001.mq5 44 50 4 errors, 0 warnings 5 1

  4. Assistant

    Os erros apresentados indicam que o compilador não está aceitando TimeFrame diretamente como argumento, pois o tipo ENUM_TIMEFRAMES precisa ser explicitamente convertido para int quando passado para funções que esperam esse tipo. Isso pode ser feito utilizando um casting explícito. Vamos corrigir os erros:

    //+------------------------------------------------------------------+
    //|                                                        GannEA.mq5 |
    //|                        Example of Gann Strategy in MQL5          |
    //+------------------------------------------------------------------+
    #property strict
    
    // Input parameters
    input int TimeFrame = PERIOD_H1;  // Timeframe para o cálculo (1H)
    input double AngleSlope = 1.0;    // Inclinação do ângulo 1x1 (1:1)
    
    // Variáveis globais
    double gannAngle;  // Valor do ângulo de Gann (1x1)
    datetime lastTime;  // Último tempo de execução do EA
    
    // Função para calcular o ângulo de Gann
    double CalculateGannAngle(double referencePrice, datetime referenceTime, datetime currentTime)
    {
        // A inclinação é baseada na relação 1x1 (1 preço: 1 tempo)
        double timeDifference = (currentTime - referenceTime) / 60.0;  // Diferença de tempo em minutos
        double priceDifference = referencePrice - SymbolInfoDouble(Symbol(), SYMBOL_ASK);  // Diferença de preço
        
        // A linha de Gann será calculada como a diferença entre preço e tempo
        return referencePrice - (timeDifference * AngleSlope);
    }
    
    // Função de inicialização
    int OnInit()
    {
        lastTime = iTime(Symbol(), (ENUM_TIMEFRAMES)TimeFrame, 0);  // Pega o tempo da última vela
        return INIT_SUCCEEDED;
    }
    
    // Função principal de execução do EA
    void OnTick()
    {
        // Verificar se houve mudança de vela
        datetime currentTime = iTime(Symbol(), (ENUM_TIMEFRAMES)TimeFrame, 0);
        if (currentTime != lastTime)
        {
            lastTime = currentTime;  // Atualiza o tempo da vela
    
            // Pega o preço de fechamento e o tempo de referência para o cálculo
            double referencePrice = iClose(Symbol(), (ENUM_TIMEFRAMES)TimeFrame, 1);  // Acesso ao preço de fechamento da vela anterior
            datetime referenceTime = iTime(Symbol(), (ENUM_TIMEFRAMES)TimeFrame, 1);  // Acesso ao tempo da vela anterior
    
            // Calcular o ângulo de Gann para o próximo preço
            gannAngle = CalculateGannAngle(referencePrice, referenceTime, currentTime);
    
            // Verificar as condições de compra ou venda
            double askPrice = SymbolInfoDouble(Symbol(), SYMBOL_ASK);  // Preço de compra
            double bidPrice = SymbolInfoDouble(Symbol(), SYMBOL_BID);  // Preço de venda
    
            if (askPrice > gannAngle)  // Condição de compra: preço acima do ângulo
            {
                // Verifica se já existe uma ordem aberta, se não, abre uma compra
                if (PositionsTotal() == 0)
                {
                    // Abrir ordem de compra
                    MqlTradeRequest request = {};
                    MqlTradeResult result = {};
                    
                    request.action = TRADE_ACTION_DEAL;
                    request.symbol = Symbol();
                    request.volume = 0.1;
                    request.type = ORDER_TYPE_BUY;
                    request.price = askPrice;
                    request.sl = 0;
                    request.tp = 0;
                    request.deviation = 10;
                    
                    if (OrderSend(request, result))
                    {
                        Print("Compra executada com sucesso.");
                    }
                    else
                    {
                        Print("Erro ao executar compra: ", result.comment);
                    }
                }
            }
            else if (bidPrice < gannAngle)  // Condição de venda: preço abaixo do ângulo
            {
                // Verifica se já existe uma ordem aberta, se não, abre uma venda
                if (PositionsTotal() == 0)
                {
                    // Abrir ordem de venda
                    MqlTradeRequest request = {};
                    MqlTradeResult result = {};
                    
                    request.action = TRADE_ACTION_DEAL;
                    request.symbol = Symbol();
                    request.volume = 0.1;
                    request.type = ORDER_TYPE_SELL;
                    request.price = bidPrice;
                    request.sl = 0;
                    request.tp = 0;
                    request.deviation = 10;
                    
                    if (OrderSend(request, result))
                    {
                        Print("Venda executada com sucesso.");
                    }
                    else
                    {
                        Print("Erro ao executar venda: ", result.comment);
                    }
                }
            }
        }
    }
    //+------------------------------------------------------------------+
    

    Nessa correção, fiz o casting explícito de TimeFrame para o tipo ENUM_TIMEFRAMES ao chamar iTime e iClose. Isso deve resolver os erros de compilação que foram reportados.

  5. User

    nao esta abrindo ordens

  6. Assistant

    Se o seu Expert Advisor não está abrindo ordens, existem várias razões possíveis para isso. Vamos revisar o código e destacar algumas potenciais áreas de problema junto com algumas sugestões de depuração:

    1. Verificar Cálculo Gann: Certifique-se de que o cálculo do ângulo de Gann está produzindo valores que fazem sentido no contexto do seu mercado e estratégias.

    2. Condições de Entrada: Verifique se as condições para abertura de ordens (preço ask acima do gannAngle e preço bid abaixo do gannAngle) estão sendo atendidas.

    3. Log de Depuração: Adicione logs ao código para entender melhor o que está acontecendo.

    4. Configurações da Conta: Verifique se sua conta de trading permite a abertura de posições e se tem fundos suficientes.

    5. Permissões de Automated Trading: Confirme que a negociação automatizada está habilitada no terminal e no EA.

    6. Malha de Ordens: Assegure que não há nenhum filtro adicional ou malha que está impedindo a execução de ordens.

    Vamos adicionar logs para verificação:

    //+------------------------------------------------------------------+
    //|                                                        GannEA.mq5 |
    //|                        Example of Gann Strategy in MQL5          |
    //+------------------------------------------------------------------+
    #property strict
    
    // Input parameters
    input int TimeFrame = PERIOD_H1;  // Timeframe para o cálculo (1H)
    input double AngleSlope = 1.0;    // Inclinação do ângulo 1x1 (1:1)
    
    // Variáveis globais
    double gannAngle;  // Valor do ângulo de Gann (1x1)
    datetime lastTime;  // Último tempo de execução do EA
    
    // Função para calcular o ângulo de Gann
    double CalculateGannAngle(double referencePrice, datetime referenceTime, datetime currentTime)
    {
        // A inclinação é baseada na relação 1x1 (1 preço: 1 tempo)
        double timeDifference = (currentTime - referenceTime) / 60.0;  // Diferença de tempo em minutos
        double priceDifference = referencePrice - SymbolInfoDouble(Symbol(), SYMBOL_ASK);  // Diferença de preço
        
        // A linha de Gann será calculada como a diferença entre preço e tempo
        return referencePrice - (timeDifference * AngleSlope);
    }
    
    // Função de inicialização
    int OnInit()
    {
        lastTime = iTime(Symbol(), (ENUM_TIMEFRAMES)TimeFrame, 0);  // Pega o tempo da última vela
        return INIT_SUCCEEDED;
    }
    
    // Função principal de execução do EA
    void OnTick()
    {
        // Verificar se houve mudança de vela
        datetime currentTime = iTime(Symbol(), (ENUM_TIMEFRAMES)TimeFrame, 0);
        if (currentTime != lastTime)
        {
            lastTime = currentTime;  // Atualiza o tempo da vela
    
            // Pega o preço de fechamento e o tempo de referência para o cálculo
            double referencePrice = iClose(Symbol(), (ENUM_TIMEFRAMES)TimeFrame, 1);  // Acesso ao preço de fechamento da vela anterior
            datetime referenceTime = iTime(Symbol(), (ENUM_TIMEFRAMES)TimeFrame, 1);  // Acesso ao tempo da vela anterior
    
            // Calcular o ângulo de Gann para o próximo preço
            gannAngle = CalculateGannAngle(referencePrice, referenceTime, currentTime);
    
            // Verificar as condições de compra ou venda
            double askPrice = SymbolInfoDouble(Symbol(), SYMBOL_ASK);  // Preço de compra
            double bidPrice = SymbolInfoDouble(Symbol(), SYMBOL_BID);  // Preço de venda
    
            Print("Ask Price: ", askPrice, " | Bid Price: ", bidPrice, " | Gann Angle: ", gannAngle);
    
            if (askPrice > gannAngle)  // Condição de compra: preço acima do ângulo
            {
                Print("Condição de compra atendida.");
                // Verifica se já existe uma ordem aberta, se não, abre uma compra
                if (PositionsTotal() == 0)
                {
                    Print("Nenhuma posição aberta. Tentando comprar.");
                    // Abrir ordem de compra
                    MqlTradeRequest request = {};
                    MqlTradeResult result = {};
                    
                    request.action = TRADE_ACTION_DEAL;
                    request.symbol = Symbol();
                    request.volume = 0.1;
                    request.type = ORDER_TYPE_BUY;
                    request.price = askPrice;
                    request.sl = 0;
                    request.tp = 0;
                    request.deviation = 10;
                    
                    if (OrderSend(request, result))
                    {
                        Print("Compra executada com sucesso.");
                    }
                    else
                    {
                        Print("Erro ao executar compra: ", result.comment);
                    }
                }
                else
                {
                    Print("Já existe uma posição aberta. Nenhuma compra será feita.");
                }
            }
            else if (bidPrice < gannAngle)  // Condição de venda: preço abaixo do ângulo
            {
                Print("Condição de venda atendida.");
                // Verifica se já existe uma ordem aberta, se não, abre uma venda
                if (PositionsTotal() == 0)
                {
                    Print("Nenhuma posição aberta. Tentando vender.");
                    // Abrir ordem de venda
                    MqlTradeRequest request = {};
                    MqlTradeResult result = {};
                    
                    request.action = TRADE_ACTION_DEAL;
                    request.symbol = Symbol();
                    request.volume = 0.1;
                    request.type = ORDER_TYPE_SELL;
                    request.price = bidPrice;
                    request.sl = 0;
                    request.tp = 0;
                    request.deviation = 10;
                    
                    if (OrderSend(request, result))
                    {
                        Print("Venda executada com sucesso.");
                    }
                    else
                    {
                        Print("Erro ao executar venda: ", result.comment);
                    }
                }
                else
                {
                    Print("Já existe uma posição aberta. Nenhuma venda será feita.");
                }
            }
        }
    }
    //+------------------------------------------------------------------+
    

    Passos Adicionais:

    • Verifique o Log: Use o log do terminal para verificar se as mensagens estão sendo exibidas, o que pode ajudar a identificar onde o problema está ocorrendo.

    • Volume: Verifique o volume de negociação especificado (0.1). Certifique-se de que ele está dentro dos limites permitidos pela sua conta de negociação.

    • Verifique Restrições: Algumas corretoras ou contas podem ter restrições sobre o número de ordens ou lotes mínimos e máximos.

    • Permissões de Negociação: Confirme se a negociação automatizada está ativada no MetaTrader (botão "Auto Trading" deve estar verde).

    • Teste em Ambiente Simulado: Você pode querer testar o EA em modo de Estratégia no MetaTrader para entender melhor seu comportamento e identificar possíveis problemas.

  7. User

    o codigo atual nao esta abrindo ordens abaixo é o codigo original :

    //+------------------------------------------------------------------+ //| GannEA.mq5 | //| Example of Gann Strategy in MQL5 | //+------------------------------------------------------------------+ #property strict

    // Input parameters input int TimeFrame = PERIOD_H1; // Timeframe para o cálculo (1H) input double AngleSlope = 1.0; // Inclinação do ângulo 1x1 (1:1)

    // Variáveis globais double gannAngle; // Valor do ângulo de Gann (1x1) datetime lastTime; // Último tempo de execução do EA

    // Função para calcular o ângulo de Gann double CalculateGannAngle(double referencePrice, datetime referenceTime, datetime currentTime) { // A inclinação é baseada na relação 1x1 (1 preço: 1 tempo) double timeDifference = (currentTime - referenceTime) / PeriodSeconds(); // Diferença de tempo em segundos double priceDifference = referencePrice - Ask; // Diferença de preço

    // A linha de Gann será calculada como a diferença entre preço e tempo
    return referencePrice - (timeDifference * AngleSlope);
    

    }

    // Função de inicialização int OnInit() { lastTime = Time[0]; // Pega o tempo da última vela return INIT_SUCCEEDED; }

    // Função principal de execução do EA void OnTick() { // Verificar se houve mudança de vela if (Time[0] != lastTime) { lastTime = Time[0]; // Atualiza o tempo da vela

        // Pega o preço de fechamento e o tempo de referência para o cálculo
        double referencePrice = Close[1];
        datetime referenceTime = Time[1];
    
        // Calcular o ângulo de Gann para o próximo preço
        gannAngle = CalculateGannAngle(referencePrice, referenceTime, Time[0]);
        
        // Verificar as condições de compra ou venda
        if (Ask > gannAngle)  // Condição de compra: preço acima do ângulo
        {
            // Verifica se já existe uma ordem aberta, se não, abre uma compra
            if (PositionsTotal() == 0)
            {
                // Abrir ordem de compra
                OrderSend(Symbol(), OP_BUY, 0.1, Ask, 2, 0, 0, "Gann Buy", 0, 0, clrGreen);
            }
        }
        else if (Ask < gannAngle)  // Condição de venda: preço abaixo do ângulo
        {
            // Verifica se já existe uma ordem aberta, se não, abre uma venda
            if (PositionsTotal() == 0)
            {
                // Abrir ordem de venda
                OrderSend(Symbol(), OP_SELL, 0.1, Bid, 2, 0, 0, "Gann Sell", 0, 0, clrRed);
            }
        }
    }
    

    }

    //+------------------------------------------------------------------+

  8. Assistant

    O código que você forneceu está usando funções e constantes do MQL4 (OrderSend, Close[1], Ask, Bid, etc.), mas você está tentando compilar isso no MQL5, que possui diferenças significativas na API de negociação e nas funções de acesso aos dados de mercado.

    Vamos converter esse estilo de MQL4 para MQL5, assim como corrigir quaisquer problemas para garantir que o Expert Advisor possa abrir ordens corretamente em MQL5:

    //+------------------------------------------------------------------+
    //|                                                        GannEA.mq5 |
    //|                        Example of Gann Strategy in MQL5          |
    //+------------------------------------------------------------------+
    #property strict
    
    // Input parameters
    input ENUM_TIMEFRAMES TimeFrame = PERIOD_H1;  // Timeframe para o cálculo (1H)
    input double AngleSlope = 1.0;    // Inclinação do ângulo 1x1 (1:1)
    
    // Variáveis globais
    double gannAngle;  // Valor do ângulo de Gann (1x1)
    datetime lastTime;  // Último tempo de execução do EA
    
    // Função para calcular o ângulo de Gann
    double CalculateGannAngle(double referencePrice, datetime referenceTime, datetime currentTime)
    {
        // A inclinação é baseada na relação 1x1 (1 preço: 1 tempo)
        double timeDifference = (currentTime - referenceTime) / PeriodSeconds();  // Diferença de tempo em segundos
        double priceDifference = referencePrice - SymbolInfoDouble(Symbol(), SYMBOL_ASK);  // Diferença de preço
        
        // A linha de Gann será calculada como a diferença entre preço e tempo
        return referencePrice - (timeDifference * AngleSlope);
    }
    
    // Função de inicialização
    int OnInit()
    {
        lastTime = iTime(Symbol(), TimeFrame, 0);  // Pega o tempo da última vela
        return INIT_SUCCEEDED;
    }
    
    // Função principal de execução do EA
    void OnTick()
    {
        // Verificar se houve mudança de vela
        datetime currentTime = iTime(Symbol(), TimeFrame, 0);
        if (currentTime != lastTime)
        {
            lastTime = currentTime;  // Atualiza o tempo da vela
    
            // Pega o preço de fechamento e o tempo de referência para o cálculo
            double referencePrice = iClose(Symbol(), TimeFrame, 1);
            datetime referenceTime = iTime(Symbol(), TimeFrame, 1);
    
            // Calcular o ângulo de Gann para o próximo preço
            gannAngle = CalculateGannAngle(referencePrice, referenceTime, currentTime);
            
            // Verificar as condições de compra ou venda
            double askPrice = SymbolInfoDouble(Symbol(), SYMBOL_ASK);
            double bidPrice = SymbolInfoDouble(Symbol(), SYMBOL_BID);
    
            if (askPrice > gannAngle)  // Condição de compra: preço acima do ângulo
            {
                // Verifica se já existe uma ordem aberta, se não, abre uma compra
                if (PositionsTotal() == 0)
                {
                    // Abrir ordem de compra
                    MqlTradeRequest request = {};
                    MqlTradeResult result = {};
                    
                    request.action = TRADE_ACTION_DEAL;
                    request.symbol = Symbol();
                    request.volume = 0.1;
                    request.type = ORDER_TYPE_BUY;
                    request.price = askPrice;
                    request.deviation = 2;
                    request.sl = 0;
                    request.tp = 0;
                    request.comment = "Gann Buy";
    
                    if (OrderSend(request, result))
                    {
                        Print("Compra executada com sucesso.");
                    }
                    else
                    {
                        Print("Erro ao executar compra: ", result.comment);
                    }
                }
            }
            else if (bidPrice < gannAngle)  // Condição de venda: preço abaixo do ângulo
            {
                // Verifica se já existe uma ordem aberta, se não, abre uma venda
                if (PositionsTotal() == 0)
                {
                    // Abrir ordem de venda
                    MqlTradeRequest request = {};
                    MqlTradeResult result = {};
                    
                    request.action = TRADE_ACTION_DEAL;
                    request.symbol = Symbol();
                    request.volume = 0.1;
                    request.type = ORDER_TYPE_SELL;
                    request.price = bidPrice;
                    request.deviation = 2;
                    request.sl = 0;
                    request.tp = 0;
                    request.comment = "Gann Sell";
    
                    if (OrderSend(request, result))
                    {
                        Print("Venda executada com sucesso.");
                    }
                    else
                    {
                        Print("Erro ao executar venda: ", result.comment);
                    }
                }
            }
        }
    }
    //+------------------------------------------------------------------+
    

    Observações

    • Uso de iTime e iClose: No MQL5, usa-se iTime e iClose para acessar a data/hora e preço de fechamento de uma vela em um frame específico.

    • OrderSend para MQL5: O MQL5 utiliza a estrutura MqlTradeRequest e MqlTradeResult para enviar ordens de mercado. Isso é diferente do OrderSend usado no MQL4.

    • Condições de Abertura de Ordem: Certifique-se de que há apenas uma posição aberta para evitar múltiplas ordens de compra ou venda.

    Se o EA ainda não abrir ordens, verifique no "Journal" do MetaTrader 5 qualquer mensagem de erro ou restrições da corretora.

  9. User

    //+------------------------------------------------------------------+ //| GannEA.mq5 | //| Example of Gann Strategy in MQL5 | //+------------------------------------------------------------------+ #property strict

    // Input parameters input ENUM_TIMEFRAMES TimeFrame = PERIOD_H1; // Timeframe para o cálculo (1H) input double AngleSlope = 1.0; // Inclinação do ângulo 1x1 (1:1)

    // Variáveis globais double gannAngle; // Valor do ângulo de Gann (1x1) datetime lastTime; // Último tempo de execução do EA

    // Função para calcular o ângulo de Gann double CalculateGannAngle(double referencePrice, datetime referenceTime, datetime currentTime) { // A inclinação é baseada na relação 1x1 (1 preço: 1 tempo) double timeDifference = (currentTime - referenceTime) / PeriodSeconds(); // Diferença de tempo em segundos double priceDifference = referencePrice - SymbolInfoDouble(Symbol(), SYMBOL_ASK); // Diferença de preço

    // A linha de Gann será calculada como a diferença entre preço e tempo
    return referencePrice - (timeDifference * AngleSlope);
    

    }

    // Função de inicialização int OnInit() { lastTime = iTime(Symbol(), TimeFrame, 0); // Pega o tempo da última vela return INIT_SUCCEEDED; }

    // Função principal de execução do EA void OnTick() { // Verificar se houve mudança de vela datetime currentTime = iTime(Symbol(), TimeFrame, 0); if (currentTime != lastTime) { lastTime = currentTime; // Atualiza o tempo da vela

        // Pega o preço de fechamento e o tempo de referência para o cálculo
        double referencePrice = iClose(Symbol(), TimeFrame, 1);
        datetime referenceTime = iTime(Symbol(), TimeFrame, 1);
    
        // Calcular o ângulo de Gann para o próximo preço
        gannAngle = CalculateGannAngle(referencePrice, referenceTime, currentTime);
        
        // Verificar as condições de compra ou venda
        double askPrice = SymbolInfoDouble(Symbol(), SYMBOL_ASK);
        double bidPrice = SymbolInfoDouble(Symbol(), SYMBOL_BID);
    
        if (askPrice > gannAngle)  // Condição de compra: preço acima do ângulo
        {
            // Verifica se já existe uma ordem aberta, se não, abre uma compra
            if (PositionsTotal() == 0)
            {
                // Abrir ordem de compra
                MqlTradeRequest request = {};
                MqlTradeResult result = {};
                
                request.action = TRADE_ACTION_DEAL;
                request.symbol = Symbol();
                request.volume = 0.1;
                request.type = ORDER_TYPE_BUY;
                request.price = askPrice;
                request.deviation = 2;
                request.sl = 0;
                request.tp = 0;
                request.comment = "Gann Buy";
    
                if (OrderSend(request, result))
                {
                    Print("Compra executada com sucesso.");
                }
                else
                {
                    Print("Erro ao executar compra: ", result.comment);
                }
            }
        }
        else if (bidPrice < gannAngle)  // Condição de venda: preço abaixo do ângulo
        {
            // Verifica se já existe uma ordem aberta, se não, abre uma venda
            if (PositionsTotal() == 0)
            {
                // Abrir ordem de venda
                MqlTradeRequest request = {};
                MqlTradeResult result = {};
                
                request.action = TRADE_ACTION_DEAL;
                request.symbol = Symbol();
                request.volume = 0.1;
                request.type = ORDER_TYPE_SELL;
                request.price = bidPrice;
                request.deviation = 2;
                request.sl = 0;
                request.tp = 0;
                request.comment = "Gann Sell";
    
                if (OrderSend(request, result))
                {
                    Print("Venda executada com sucesso.");
                }
                else
                {
                    Print("Erro ao executar venda: ", result.comment);
                }
            }
        }
    }
    

    } //+------------------------------------------------------------------+

    nao esta abrindo ordens!

  10. Assistant

    Se o Expert Advisor escrito em MQL5 não está abrindo ordens, é importante verificar algumas áreas comuns que podem causar isso. Vou fornecer uma versão revisada do seu código com alguns ajustes, acompanhar com logs adicionais para ajudar na depuração e sugerir algumas verificações a serem feitas:

    //+------------------------------------------------------------------+
    //|                                                        GannEA.mq5 |
    //|                        Example of Gann Strategy in MQL5          |
    //+------------------------------------------------------------------+
    #property strict
    
    // Input parameters
    input ENUM_TIMEFRAMES TimeFrame = PERIOD_H1;  // Timeframe para o cálculo (1H)
    input double AngleSlope = 1.0;                // Inclinação do ângulo 1x1 (1:1)
    
    // Variáveis globais
    double gannAngle;      // Valor do ângulo de Gann (1x1)
    datetime lastTime;     // Último tempo de execução do EA
    
    // Função para calcular o ângulo de Gann
    double CalculateGannAngle(double referencePrice, datetime referenceTime, datetime currentTime)
    {
        double timeDifference = (currentTime - referenceTime) / PeriodSeconds();  // Diferença de tempo em segundos
        double priceDifference = referencePrice - SymbolInfoDouble(Symbol(), SYMBOL_ASK);  // Diferença de preço
        return referencePrice - (timeDifference * AngleSlope);
    }
    
    // Função de inicialização
    int OnInit()
    {
        lastTime = iTime(Symbol(), TimeFrame, 0);  // Pega o tempo da última vela
        return INIT_SUCCEEDED;
    }
    
    // Função principal de execução do EA
    void OnTick()
    {
        datetime currentTime = iTime(Symbol(), TimeFrame, 0);
        if (currentTime != lastTime)
        {
            lastTime = currentTime;
    
            double referencePrice = iClose(Symbol(), TimeFrame, 1);
            datetime referenceTime = iTime(Symbol(), TimeFrame, 1);
            gannAngle = CalculateGannAngle(referencePrice, referenceTime, currentTime);
    
            double askPrice = SymbolInfoDouble(Symbol(), SYMBOL_ASK);
            double bidPrice = SymbolInfoDouble(Symbol(), SYMBOL_BID);
    
            Print("Ask Price: ", askPrice, " | Bid Price: ", bidPrice, " | Gann Angle: ", gannAngle);
    
            if (askPrice > gannAngle)
            {
                // Condição de compra
                if (PositionsTotal() == 0)
                {
                    Print("Tentando abrir uma posição de compra.");
    
                    MqlTradeRequest request = {};
                    MqlTradeResult result = {};
    
                    request.action = TRADE_ACTION_DEAL;
                    request.symbol = Symbol();
                    request.volume = 0.1;
                    request.type = ORDER_TYPE_BUY;
                    request.price = askPrice;
                    request.deviation = 10;  // Aumente se necessário
                    request.sl = 0;
                    request.tp = 0;
                    request.comment = "Gann Buy";
                    
                    if (!OrderSend(request, result) || result.retcode != 10009)
                    {
                        Print("Erro ao executar compra: ", result.comment, " | Código de Retorno: ", result.retcode);
                    }
                    else
                    {
                        Print("Compra executada com sucesso.");
                    }
                }
            }
            else if (bidPrice < gannAngle)
            {
                // Condição de venda
                if (PositionsTotal() == 0)
                {
                    Print("Tentando abrir uma posição de venda.");
    
                    MqlTradeRequest request = {};
                    MqlTradeResult result = {};
    
                    request.action = TRADE_ACTION_DEAL;
                    request.symbol = Symbol();
                    request.volume = 0.1;
                    request.type = ORDER_TYPE_SELL;
                    request.price = bidPrice;
                    request.deviation = 10;  // Aumente se necessário
                    request.sl = 0;
                    request.tp = 0;
                    request.comment = "Gann Sell";
                    
                    if (!OrderSend(request, result) || result.retcode != 10009)
                    {
                        Print("Erro ao executar venda: ", result.comment, " | Código de Retorno: ", result.retcode);
                    }
                    else
                    {
                        Print("Venda executada com sucesso.");
                    }
                }
            }
        }
    }
    //+------------------------------------------------------------------+
    
    

    Observações e Dicas de Depuração:

    1. Código de Retorno: Adicionei verificações ao retorno de OrderSend(). Os pedidos de compra e venda devem retornar result.retcode == 10009 (TRADE_RETCODE_DONE) para indicar sucesso.

    2. Logs Complementares: Adicionei logs antes das tentativas de abertura de ordens para verificar quais condições estão sendo atendidas e o que está impedindo a execução de ordens.

    3. Verificações Prévias: Certifique-se de que:

      • A negociação automatizada está ativada (verifique se o botão de "Auto Trading" está verde).
      • A conta tem fundos suficientes e a corretora permite negociações no símbolo específico.
    4. Deviacção: Ajuste o valor de request.deviation se você ver que frequentemente há erros devido a mudanças de preço entre a solicitação e a execução.

    5. Modo Visual de Teste: Execute o EA em modo de teste de estratégia visual para ver seu comportamento em tempo real e identificar possíveis problemas de lógica ou execução.

    6. Limitações de Volume: Confira as restrições de lote mínimo e máximo da sua conta e corretora.

    Testar em ambiente controlado (estratégia tester) pode ajudar bastante na identificação dos problemas.