Tudo sobre Programação, com código fonte exemplo - página 5

Novo comentário
 

Fórum de negociação, sistemas de negociação automatizados e testes de estratégias de negociação

Abrir condição no fechamento de uma vela

Evandro Teixeira, 2016.06.22 17:02

Olá Bruno,

aqui no fórum tem um artigo sobre isso.

   static datetime Old_Time;
   datetime New_Time[1];
   bool IsNewBar=false;

// copying the last bar time to the element New_Time[0]
   int copiedTIME=CopyTime(_Symbol,_Period,0,1,New_Time);
   if(copiedTIME>0) // ok, the data has been copied successfully
     {
      if(Old_Time!=New_Time[0]) // if old time isn't equal to new bar time
        {
                IsNewBar=true;   // if it isn't a first call, the new bar has appeared
                if(MQL5InfoInteger(MQL5_DEBUGGING)) Print("We have new bar here ",New_Time[0]," old time was ",Old_Time);
                Old_Time=New_Time[0];            // saving bar time
        }
     }
   else
     {
        Print("Error in copying historical times data, error =",GetLastError());
        ResetLastError();
        return;
     }

//---
   if(PositionSelect(Symbol()))
     {
      if(IsNewBar)
        {
            Print("New Bar"); // closePosition();
        }
     }

 

https://www.mql5.com/en/articles/100 

 

Abraço. 


 

Fórum de negociação, sistemas de negociação automatizados e testes de estratégias de negociação

Arrastar a média do robô de Média Móvel

Evandro Goncalves, 2019.05.09 09:24

Bom dia, Denis Nikolaev.


Segue o código completo:

#include <Trade\Trade.mqh>
CTrade trade;

input int                     ma_periodo = 20;//Período da Média
input int                     ma_desloc = 0;//Deslocamento da Média
input ENUM_MA_METHOD          ma_metodo = MODE_SMA;//Método Média Móvel
input ENUM_APPLIED_PRICE      ma_preco = PRICE_CLOSE;//Preço para Média
input ulong                   magicNum = 123456;//Magic Number
input ulong                   desvPts = 50;//Desvio em Pontos
input ENUM_ORDER_TYPE_FILLING preenchimento = ORDER_FILLING_RETURN;//Preenchimento da Ordem

input double                  lote = 5.0;//Volume
input double                  stopLoss = 5;//Stop Loss
input double                  takeProfit = 20;//Take Profit
input double                  gatilhoBE = 2;//Gatilho BreakEven
input double                  gatilhoTS = 6;//Gatilho TrailingStop
input double                  stepTS = 2;//Step TrailingStop

input int                     horaInicioAbertura = 10;//Hora de Inicio de Abertura de Posições
input int                     minutoInicioAbertura = 30;//Minuto de Inicio de Abertura de Pisoções
input int                     horaFimAbertura = 16;//Hora de Encerramento de Abertura de Posições
input int                     minutoFimAbertura = 45;//Minuto de Encerramento de Abertura de Posições
input int                     horaInicioFechamento = 17;//Hora de Inicio de Fechamento de Posições
input int                     minutoInicioFechamento = 20;//Minuto de Inicio de Fechamento de Posições

double                        PRC;//Preço normalizado
double                        STL;//StopLoss normalizado
double                        TKP;//TakeProfit normalizado

double                        smaArray[];
int                           smaHandle;

bool                          posAberta;
bool                          ordPendente;
bool                          beAtivo;

MqlTick                       ultimoTick;
MqlRates                      rates[];
MqlDateTime                   horaAtual;

int OnInit()
  {
      smaHandle = iMA(_Symbol, _Period, ma_periodo, ma_desloc, ma_metodo, ma_preco);
      if(smaHandle==INVALID_HANDLE)
         {
            Print("Erro ao criar média móvel - erro", GetLastError());
            return(INIT_FAILED);
         }
      ArraySetAsSeries(smaArray, true);
      ArraySetAsSeries(rates, true);     
      
      trade.SetTypeFilling(preenchimento);
      trade.SetDeviationInPoints(desvPts);
      trade.SetExpertMagicNumber(magicNum);
      
      if(horaInicioAbertura > horaFimAbertura || horaFimAbertura > horaInicioFechamento)
         {  
            Alert("Inconsistência de Horários de Negociação!");
            return(INIT_FAILED);
         }
      if(horaInicioAbertura == horaFimAbertura && minutoInicioAbertura >= minutoFimAbertura)
         {
            Alert("Inconsistência de Horários de Negociação!");
            return(INIT_FAILED);
         }
      if(horaFimAbertura == horaInicioFechamento && minutoFimAbertura >= minutoInicioFechamento)
         {
            Alert("Inconsistência de Horários de Negociação!");
            return(INIT_FAILED);
         }
      
      return(INIT_SUCCEEDED);
  }
void OnTick()
  {               
      if(!SymbolInfoTick(Symbol(),ultimoTick))
         {
            Alert("Erro ao obter informações de Preços: ", GetLastError());
            return;
         }
         
      if(CopyRates(_Symbol, _Period, 0, 3, rates)<0)
         {
            Alert("Erro ao obter as informações de MqlRates: ", GetLastError());
            return;
         }
      
      if(CopyBuffer(smaHandle, 0, 0, 3, smaArray)<0)
         {
            Alert("Erro ao copiar dados da média móvel: ", GetLastError());
            return;
         }
         
      posAberta = false;
      for(int i = PositionsTotal()-1; i>=0; i--)
         {
            string symbol = PositionGetSymbol(i);
            ulong magic = PositionGetInteger(POSITION_MAGIC);
            if(symbol == _Symbol && magic == magicNum)
               {  
                  posAberta = true;
                  break;
               }
         }
         
      ordPendente = false;
      for(int i = OrdersTotal()-1; i>=0; i--)
         {
            ulong ticket = OrderGetTicket(i);
            string symbol = OrderGetString(ORDER_SYMBOL);
            ulong magic = OrderGetInteger(ORDER_MAGIC);
            if(symbol == _Symbol && magic == magicNum)
               {
                  ordPendente = true;
                  break;
               }
         }
      
      if(!posAberta)
         {
            beAtivo = false;
         }
         
      if(posAberta && !beAtivo)
         {
            BreakEven(ultimoTick.last);
         }
         
      if(posAberta && beAtivo)
         {
            TrailingStop(ultimoTick.last);
         }
      
      if(HoraFechamento())
         {
            Comment("Horário de Fechamento de Posições!");
            FechaPosicao();
         }
      else if(HoraNegociacao())
         {
            Comment("Dentro do Horário de Negociação!");
         }
      else
         {
            Comment("Fora do Horário de Negociação!");
         }
            
      if(ultimoTick.last>smaArray[0] && rates[1].close>rates[1].open && !posAberta && !ordPendente && HoraNegociacao())
         {
            PRC = NormalizeDouble(ultimoTick.ask, _Digits);
            STL = NormalizeDouble(PRC - stopLoss, _Digits);
            TKP = NormalizeDouble(PRC + takeProfit, _Digits);
            if(trade.Buy(lote, _Symbol, PRC, STL, TKP, ""))
               {
                  Print("Ordem de Compra - sem falha. ResultRetcode: ", trade.ResultRetcode(), ", RetcodeDescription: ", trade.ResultRetcodeDescription());
               }
            else
               {
                  Print("Ordem de Compra - com falha. ResultRetcode: ", trade.ResultRetcode(), ", RetcodeDescription: ", trade.ResultRetcodeDescription());
               }
         }
      else if(ultimoTick.last<smaArray[0] && rates[1].close<rates[1].open && !posAberta && !ordPendente && HoraNegociacao())
         {
            PRC = NormalizeDouble(ultimoTick.bid, _Digits);
            STL = NormalizeDouble(PRC + stopLoss, _Digits);
            TKP = NormalizeDouble(PRC - takeProfit, _Digits);
            if(trade.Sell(lote, _Symbol, PRC, STL, TKP, ""))
               {
                  Print("Ordem de Venda - sem falha. ResultRetcode: ", trade.ResultRetcode(), ", RetcodeDescription: ", trade.ResultRetcodeDescription());
               }
            else
               {
                  Print("Ordem de Venda - com falha. ResultRetcode: ", trade.ResultRetcode(), ", RetcodeDescription: ", trade.ResultRetcodeDescription());
               }
         }   
  }
//---
//---
bool HoraFechamento()
   {
      TimeToStruct(TimeCurrent(), horaAtual);
      if(horaAtual.hour >= horaInicioFechamento)
         {
            if(horaAtual.hour == horaInicioFechamento)
               {
                  if(horaAtual.min >= minutoInicioFechamento)
                     {
                        return true;
                     }
                  else
                     {
                        return false;
                     }
               }
            return true;
         }
      return false;
   }
//---
//---
bool HoraNegociacao()
   {
      TimeToStruct(TimeCurrent(), horaAtual);
      if(horaAtual.hour >= horaInicioAbertura && horaAtual.hour <= horaFimAbertura)
         {
            if(horaAtual.hour == horaInicioAbertura)
               {
                  if(horaAtual.min >= minutoInicioAbertura)
                     {
                        return true;
                     }
                  else
                     {
                        return false;
                     }
               }
            if(horaAtual.hour == horaFimAbertura)
               {
                  if(horaAtual.min <= minutoFimAbertura)
                     {
                        return true;
                     }
                  else
                     {
                        return false;
                     }
               }
            return true;
         }
      return false;
   }
//---
//---
void FechaPosicao()
   {
      for(int i = PositionsTotal()-1; i>=0; i--)
         {
            string symbol = PositionGetSymbol(i);
            ulong magic = PositionGetInteger(POSITION_MAGIC);
            if(symbol == _Symbol && magic == magicNum)
               {
                  ulong PositionTicket = PositionGetInteger(POSITION_TICKET);
                  if(trade.PositionClose(PositionTicket, desvPts))
                     {
                        Print("Posição Fechada - sem falha. ResultRetcode: ", trade.ResultRetcode(), ", RetcodeDescription: ", trade.ResultRetcodeDescription());
                     }
                  else
                     {
                        Print("Posição Fechada - com falha. ResultRetcode: ", trade.ResultRetcode(), ", RetcodeDescription: ", trade.ResultRetcodeDescription());
                     }
               }
         }
   }
//---
//---
void TrailingStop(double preco)
   {
      for(int i = PositionsTotal()-1; i>=0; i--)
         {
            string symbol = PositionGetSymbol(i);
            ulong magic = PositionGetInteger(POSITION_MAGIC);
            if(symbol == _Symbol && magic==magicNum)
               {
                  ulong PositionTicket = PositionGetInteger(POSITION_TICKET);
                  double StopLossCorrente = PositionGetDouble(POSITION_SL);
                  double TakeProfitCorrente = PositionGetDouble(POSITION_TP);
                  if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
                     {
                        if(preco >= (StopLossCorrente + gatilhoTS) )
                           {
                              double novoSL = NormalizeDouble(StopLossCorrente + stepTS, _Digits);
                              if(trade.PositionModify(PositionTicket, novoSL, TakeProfitCorrente))
                                 {
                                    Print("TrailingStop - sem falha. ResultRetcode: ", trade.ResultRetcode(), ", RetcodeDescription: ", trade.ResultRetcodeDescription());
                                 }
                              else
                                 {
                                    Print("TrailingStop - com falha. ResultRetcode: ", trade.ResultRetcode(), ", RetcodeDescription: ", trade.ResultRetcodeDescription());
                                 }
                           }
                     }
                  else if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
                     {
                        if(preco <= (StopLossCorrente - gatilhoTS) )
                           {
                              double novoSL = NormalizeDouble(StopLossCorrente - stepTS, _Digits);
                              if(trade.PositionModify(PositionTicket, novoSL, TakeProfitCorrente))
                                 {
                                    Print("TrailingStop - sem falha. ResultRetcode: ", trade.ResultRetcode(), ", RetcodeDescription: ", trade.ResultRetcodeDescription());
                                 }
                              else
                                 {
                                    Print("TrailingStop - com falha. ResultRetcode: ", trade.ResultRetcode(), ", RetcodeDescription: ", trade.ResultRetcodeDescription());
                                 }
                           }
                     }
               }
         }
   }
//---
//---

void BreakEven(double preco)
   {
      for(int i = PositionsTotal()-1; i>=0; i--)
         {
            string symbol = PositionGetSymbol(i);
            ulong magic = PositionGetInteger(POSITION_MAGIC);
            if(symbol == _Symbol && magic == magicNum)
               {
                  ulong PositionTicket = PositionGetInteger(POSITION_TICKET);
                  double PrecoEntrada = PositionGetDouble(POSITION_PRICE_OPEN);
                  double TakeProfitCorrente = PositionGetDouble(POSITION_TP);
                  if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_BUY)
                     {
                        if( preco >= (PrecoEntrada + gatilhoBE) )
                           {
                              if(trade.PositionModify(PositionTicket, PrecoEntrada, TakeProfitCorrente))
                                 {
                                    Print("BreakEven - sem falha. ResultRetcode: ", trade.ResultRetcode(), ", RetcodeDescription: ", trade.ResultRetcodeDescription());
                                    beAtivo = true;
                                 }
                              else
                                 {
                                    Print("BreakEven - com falha. ResultRetcode: ", trade.ResultRetcode(), ", RetcodeDescription: ", trade.ResultRetcodeDescription());
                                 }
                           }                           
                     }
                  else if(PositionGetInteger(POSITION_TYPE) == POSITION_TYPE_SELL)
                     {
                        if( preco <= (PrecoEntrada - gatilhoBE) )
                           {
                              if(trade.PositionModify(PositionTicket, PrecoEntrada, TakeProfitCorrente))
                                 {
                                    Print("BreakEven - sem falha. ResultRetcode: ", trade.ResultRetcode(), ", RetcodeDescription: ", trade.ResultRetcodeDescription());
                                    beAtivo = true;
                                 }
                              else
                                 {
                                    Print("BreakEven - com falha. ResultRetcode: ", trade.ResultRetcode(), ", RetcodeDescription: ", trade.ResultRetcodeDescription());
                                 }
                           }
                     }
               }
         }
   }

 

Fórum de negociação, sistemas de negociação automatizados e testes de estratégias de negociação

ORDER_TYPE_BUY_STOP - [Invalide Price] error

fukudahs, 2019.05.11 17:37

Estou tentando enviar uma orem de Buy Stop, mas só retorna erro de [Invalid Price]. O preço do mercado está a 1.24797 e o preço da ordem de Buy Stop que quero colocar é a 1.24867, ou seja, de fato acima do preço de mercado.

Poderiam me ajudar a resolver este erro?


         Print("Stop Buy: " + (OPLAST + StopGain));

         Print("Normalized Stop Buy: "+ NormalizeDouble((OPLAST + StopGain),_Digits)); 

         Print("Ask: "+ Ask);

         //Envia ordem de Buy Stop. O preço do mercado esta a 1.24797 e o preco do Buy Stop que quero colocar eh a 1.24867, ou seja, de fato acima do preco de mercado.

         request.action = TRADE_ACTION_PENDING;

         request.type = ORDER_TYPE_BUY_STOP;          //ordem de buy stop

         request.symbol = _Symbol;

         request.volume = 2;

         request.type_filling = ORDER_FILLING_RETURN;    //compra e deixa o resto aberto

         request.price = NormalizeDouble((OPLAST + StopGain),_Digits);  //O preco da ordem de buy stop a 1.24867

         request.deviation = 5;                        // desvio permitido do preço

         OrderSend(request,result);                      //envio da ordem




 
Rogerio Figurelli:
Olá Flávio, obrigado pelo contraponto, sempre bem-vindo, mas note que o objetivo desse tópico é reunir dúvidas com códigos fontes e não qualquer dúvida geral. 
A ideia é justamente reforçar a relevância de quem publica seus códigos fonte, de forma colaborativa e corajosa, no meu entender, ao invés de ficar em perguntas apenas onde os colaboradores e moderadores precisam "decifrar" o que foi feito por "engenharia reversa virtual".
Sds.,
Rogério Figurelli

Vpocê esquece que o sistema de Busca do site MQL5 é uma porcaria..., e como o título da Thread é genérico, este tópico é inútil...

Só buscando via Google/Bing/etc vc acha algo, SE, e somente SE, você colocar algum título de relevância no sub-t'poico, mas o site do MQL5 só põe TAGs <P> nos títulos, o que não ajuda muito, pois o SEO é pobre...

Te digo, é trabalho em vão...

Mas, ok...

Cada um é cada um...

;)

 
Flavio Jarabeck:

Vpocê esquece que o sistema de Busca do site MQL5 é uma porcaria..., e como o título da Thread é genérico, este tópico é inútil...

Só buscando via Google/Bing/etc vc acha algo, SE, e somente SE, você colocar algum título de relevância no sub-t'poico, mas o site do MQL5 só põe TAGs <P> nos títulos, o que não ajuda muito, pois o SEO é pobre...

Te digo, é trabalho em vão...

Mas, ok...

Cada um é cada um...

;)

Olá Flavio Jarabeck, obrigado novamente pelo contraponto, mas não entendo por que você está tão incomodado com essa thread.

Na minha opinião, sua crítica é muito subjetiva e pouco objetiva. Eu poderia criticar você também, por usar o logotipo da sua empresa no seu avatar do fórum, o que não é uma prática permitida pelas regras, mas vejo vários outros usuários aqui fazendo o mesmo, e portanto tenho que ser objetivo, pois não me parece justo fazer isso, embora não concorde com esse tipo de publicidade em fórums.

Como já comentei, o objetivo dessa thread não é ser um sistema de busca ou até mesmo complementar algum existente, mas coletar dúvidas com código fonte que vejo no fórum, sendo que várias delas ainda estavam abertas quando acessei (nenhuma resposta) e agora já foram respondidas, complementando e corrigindo o código original.

Note também que o paradigma das buscas, SEO, etc, já passou, e no meu entender isso está obsoleto. O que pesa hoje é a comunicação direta e o novo paradigma das redes sociais, onde a recomendação e a inteligência coletiva é mais relevante. Portanto, isso não me parece um trabalho em vão, mas uma valorização de quem está colaborando com seu código fonte ao apresentar sua dúvida aqui.

Mas, ao menos, concordo com você que cada um é cada um. ;-)

Sds.,
Rogério Figurelli

 

Fórum de negociação, sistemas de negociação automatizados e testes de estratégias de negociação

StopLoss e TakeProfit

lbevilaqua, 2019.05.12 23:23

Preciso de uma ajuda pessoal, estou desenvolvendo um EA e esbarrei numa questão, preciso que o stoploss seja o preço minimo da vela anterior a entrada, ou seja SL=preço-minimovelaanterior

E o TP seja o preço de entrada + SL.

Grato desde já

Consegui desenvolver a logica para um sl e tp fixo escolhidos, porém não é isso que eu quero.

void Compra()

  {

      double price = simbolo.Ask();

      double stoploss = simbolo.NormalizePrice(price - SL);

      double takeprofit = simbolo.NormalizePrice(price + TP);

      negocio.Buy(Volume, NULL, price, stoploss, takeprofit);

    

  }

   void Venda()

  {

      double price = simbolo.Ask();

      double stoploss = simbolo.NormalizePrice(price + SL);

      double takeprofit = simbolo.NormalizePrice(price - TP);

      negocio.Sell(Volume, NULL, price, stoploss, takeprofit);

  }


 

Fórum de negociação, sistemas de negociação automatizados e testes de estratégias de negociação

Problema com código do indicador Result

prsc, 2019.05.13 17:43

Boa tarde.

Fiz um indicador que mede as pernadas anteriores estilo o Result que muitos conhecem.

O indicador precisa fazer o cálculo quando acontece a inversão, então ele entra no for e faz o cálculo da pernada anterior, até parece que está funcionando mas tem um pequeno bug que não encontrei a solução.

Quando insere ele no gráfico, ele mostra certo o posicionamento da altura com as devidas pernadas, ele começa a calcular alguns e para, então se removo ele do gráfico e adiciono, ele calcula todos, faz mais algumas barras e para de novo.

Também fiz ele para o tryd, onde também acontece um certo bug, ele não para de calcular mas fica deslocando a posição enquanto não fecha a pernada, onde deveria acontecer o calculo apenas quando tivesse alguma inversão.

Então em cada plataforma ele se comporta com algum tipo de bug, logo creio que tem alguma falha no código que não estou encontrando.


//+------------------------------------------------------------------+
//|                                              HistogramaColor.mq5 |
//|                                                             Neto |
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright "Neto"
#property link      ""
#property version   "1.00"
#property indicator_separate_window
//+------------------------------------------------------------------+
//| PROPRIEDADES DO INDICADOR (DIRETIVAS)                        |
//+------------------------------------------------------------------+
#property indicator_buffers 3 
#property indicator_plots 1 
//---
#property indicator_label1 "ForceResult" 
#property indicator_type1 DRAW_COLOR_HISTOGRAM 
#property indicator_style1 STYLE_SOLID 
#property indicator_color1 clrAqua,clrRed 
#property indicator_width1 2 

double wb[]; 
double wC[]; 
double cl[];

//=== Variáveis
int lenU = 0;
int lenD = 0;
double tmU = 0;
double tmD = 0;

int OnInit()
  {
//--- Mapear os buffers do indicador
   SetIndexBuffer(0,wb,INDICATOR_DATA);
   SetIndexBuffer(1,wC,INDICATOR_COLOR_INDEX);
   SetIndexBuffer(2,cl,INDICATOR_DATA);
   IndicatorSetString( INDICATOR_SHORTNAME, "Force Result" );
   return(INIT_SUCCEEDED);
  }

int OnCalculate(const int rates_total,
                const int prev_calculated, 
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {

int i;
if(prev_calculated == 0) i = 0;
else i = prev_calculated-1;
  for(i = 2; i < rates_total; i++) 
        {
           cl[i] = close[i];
           if(cl[i] >= cl[i-1])
            {
             if(lenD > 0)
               {
                tmD = (high[i-lenD]-low[i-1]);
                for(int j = 0; j < lenD; j++)
                  {
                    wb[i-lenD+j] = tmD;
                    wC[i-lenD+j] = 1;
                  }
               lenD = 0;
              }
            if(cl[i-1] >= cl[i-2])
              {
                  lenU +=1;
               }
           else if(cl[i] >= cl[i-1]){
                lenU +=1;
            }
          }
         else
           {
             //Se variável lenU estiver carregada, entra e faz o loop
             if(lenU > 0)
              {
                //tmU recebe valor da máxima i-1 e da última posição da mínima da pernada passada.
                tmU = (high[i-1]-low[i-lenU]);
                for(int n = 0; n < lenU; n++)
                 {
                   wb[i-lenU+n] = tmU; //Insere o valor da altura da pernada em cada index da pernada anterior
                   wC[i-lenU+n] = 0;
                 }
                  lenU = 0; //zeragem da variável
              }
              if(cl[i-1] < cl[i-2])
                {
                     lenD +=1;
                }
                else if(cl[i] <= cl[i-1])
                  {
                   lenD +=1;
                  }
            }
         }
   return(rates_total);
  }
//+------------------------------------------------------------------+


Aqui uns prints para demonstrar o tal bug.

No mt5 a falta de atualizar a pernada, e no tryd o deslocamento até terminar a pernada.

Não quero suporte para tryd, só estou colocando como exemplo para um possível bug no código.


 

Fórum de negociação, sistemas de negociação automatizados e testes de estratégias de negociação

Erro na data de expiração

CaioVitullo, 2019.05.14 19:19

Olá amigos

estou encontrando um problema no meu codigo quando rodo ele na conta real(na conta Demo esta ok e no backtest tambem)

Quando tento realizar uma compra ou venda o código retorna um erro: TRADE_RETCODE_INVALID_EXPIRATION que significa algum erro na Data de Expiração

Ja alterei o codigo diversas vezes mas o erro persiste. 

ativo:WDOM19

corretora: Modal

Codigo:

ZeroMemory(request);
        ZeroMemory(result);
        
        request.action = TRADE_ACTION_PENDING;
        request.symbol = pSymbol;
        request.type = ORDER_TYPE_BUY_STOP;
        request.sl = pStop;
        request.tp = pProfit;
        request.comment = pComment;
        request.price = pPrice;
        request.volume = pVolume;
        request.stoplimit = pStopLimit;
        request.deviation = deviation;
        request.type_filling = ORDER_FILLING_FOK;//fillType;
        request.magic = magicNumber;
        
        
        
        if(pExpiration > 0)
        {
                request.expiration = pExpiration;
                request.type_time =ORDER_TIME_SPECIFIED;
                
        }
        else request.type_time = ORDER_TIME_GTC;

        
        // Order loop
        int retryCount = 0;
        int checkCode = 0;
        
        do 
        {
                bool sent = OrderSend(request,result);
                
                checkCode = CheckReturnCode(result.retcode);
.......

Muito obrigado


 

Fórum de negociação, sistemas de negociação automatizados e testes de estratégias de negociação

SL e TP

Rogerio Figurelli, 2019.05.15 06:14

Olá Claudio Prado, acredito que seu problema é o fato de não estares considerando que deves passar o preço absoluto de SL/TP, e não o relativo, em pontos.

Para facilitar o entendimento disso e correção, recomendo analisares o código em https://www.mql5.com/pt/articles/481 que separei abaixo, que também já leva em consideração a normalização do preço:

//--- 3. example of buying at the specified symbol with specified SL and TP
   double volume=0.1;         // specify a trade operation volume
   string symbol="GBPUSD";    //specify the symbol, for which the operation is performed
   int    digits=(int)SymbolInfoInteger(symbol,SYMBOL_DIGITS); // number of decimal places
   double point=SymbolInfoDouble(symbol,SYMBOL_POINT);         // point
   double bid=SymbolInfoDouble(symbol,SYMBOL_BID);             // current price for closing LONG
   double SL=bid-1000*point;                                   // unnormalized SL value
   SL=NormalizeDouble(SL,digits);                              // normalizing Stop Loss
   double TP=bid+1000*point;                                   // unnormalized TP value
   TP=NormalizeDouble(TP,digits);                              // normalizing Take Profit
//--- receive the current open price for LONG positions
   double open_price=SymbolInfoDouble(symbol,SYMBOL_ASK);
   string comment=StringFormat("Buy %s %G lots at %s, SL=%s TP=%s",
                               symbol,volume,
                               DoubleToString(open_price,digits),
                               DoubleToString(SL,digits),
                               DoubleToString(TP,digits));
   if(!trade.Buy(volume,symbol,open_price,SL,TP,comment))
     {
      //--- failure message
      Print("Buy() method failed. Return code=",trade.ResultRetcode(),
            ". Descrição do código: ",trade.ResultRetcodeDescription());
     }
   else
     {
      Print("Buy() method executed successfully. Return code=",trade.ResultRetcode(),
            " (",trade.ResultRetcodeDescription(),")");
     }

Espero que esse código ajude na definição de SL/TP, mas tenha cuidado quanto ao fato de que ele foi desenvolvido como exemplo para o mercado FX.
Sds.,
Rogério Figurelli


 

Fórum de negociação, sistemas de negociação automatizados e testes de estratégias de negociação

Como registro dado de um Buffers Para continuar fazendo a analise dele nas barras seguintes?

massotti, 2019.05.15 02:27

//+------------------------------------------------------------------+
//|                                                                    EA.mq5 |
//|                                                          Lucas Massotti |
//|                                            https://www.mql5.com |
//+------------------------------------------------------------------+
#property copyright "Lucas Massotti"
#property link      "https://www.mql5.com"
#property version   "1.00"

//+------------------------------------------------------------------+
//| INPUTS (PARAMETROS EXTERNOS)                              |                                                                
//+------------------------------------------------------------------+
input int takeprofit = 10;
input int stoploss=20;

MqlRates candle[]; //---acesso a dados de preço

int handlehaseganshuriken;
double principeny1[],principeny2[],principeny3[],sinalcompra[],sinalvenda[],principenycandle1[],principenycandle2[],principenycandle3[],principenycandle4[];
//+------------------------------------------------------------------+
//| Expert initialization function                                    |
//+------------------------------------------------------------------+
int OnInit()
  {
     
   EventSetMillisecondTimer(1);
   ArraySetAsSeries(candle,true); 
   
   
   handlehaseganshuriken = iCustom(_Symbol,_Period,"RasengaShurikenNY.ex5",30);
   ArraySetAsSeries(principeny1,true);
   ArraySetAsSeries(principeny2,true);
   ArraySetAsSeries(principeny3,true);
   ArraySetAsSeries(sinalcompra,true);
   ArraySetAsSeries(sinalvenda,true);
   ArraySetAsSeries(principenycandle1,true);
   ArraySetAsSeries(principenycandle2,true);
   ArraySetAsSeries(principenycandle3,true);
   ArraySetAsSeries(principenycandle4,true);
   MarketBookAdd(_Symbol); // abre o acesso aos dados do book, ou seja, estamos pedindo acesso ao dado do book.
   return(INIT_SUCCEEDED);
  }

void OnDeinit(const int reason)
  {
   EventKillTimer();
   
  }

 
void OnTimer()
{
   CopyBuffer(handlehaseganshuriken,0,0,1000,principeny1);
   CopyBuffer(handlehaseganshuriken,1,0,1000,principeny2);
   CopyBuffer(handlehaseganshuriken,2,0,1000,principeny3);
   CopyBuffer(handlehaseganshuriken,3,0,1000,sinalcompra);
   CopyBuffer(handlehaseganshuriken,4,0,1000,sinalvenda);
   CopyBuffer(handlehaseganshuriken,5,0,1000,principenycandle1);
   CopyBuffer(handlehaseganshuriken,6,0,1000,principenycandle2);
   CopyBuffer(handlehaseganshuriken,7,0,1000,principenycandle3);
   CopyBuffer(handlehaseganshuriken,8,0,1000,principenycandle4);
  
   CopyRates(_Symbol,_Period,0,1000,candle);
  
//+------------------------------------------------------------------+
//|SETUP DE NEGOCIAÇÃO DE COMPRA E VENDA              |
//+------------------------------------------------------------------+
  
    
      if( sinalcompra[1]==1 && ((candle[1].high-candle[2].high)>=50) ) 
      {
         
        SetupCompra();      
      }
      if( sinalvenda[1]==1 && ((candle[0].low-candle[1].low)>=50) ) 
      {
      
      SetupVenda();
      }  
}







//+------------------------------------------------------------------+
//|                      setup de compra                                  |
//+------------------------------------------------------------------+
   void SetupCompra()
  {
       MqlTradeRequest requisicao;
       MqlTradeResult resposta;
       ZeroMemory(requisicao);   // limpa a memoria da struct
       ZeroMemory(resposta);     // limpa a memoria da struct
       //AGORA: DEFINIR TODAS AS CARACTERÍSTICA DA ORDEM
       requisicao.action=TRADE_ACTION_DEAL; //aqui falei que o negocio é a mercado...no type logo abaixo eu disse que é COMPRA  a MERCADO.
       requisicao.magic = 1234;
       //requisicao.order 
       requisicao.symbol=_Symbol;
       requisicao.volume= vol;
       requisicao.price=0; // a mercado
       //requisicao.stoplimit=
       requisicao.sl=tick2.ask-stoploss; //EU QUE COLOQUEI TRADE_ACTION_DEAL
       requisicao.tp=tick2.ask+takeprofit;  //EU QUE COLOQUEI TRADE_ACTION_DEAL
       requisicao.deviation=5;
       requisicao.type = ORDER_TYPE_BUY; //aqui disse que é COMPRA A MERCADO
       requisicao.type_filling=ORDER_FILLING_FOK;
       requisicao.type_time = ORDER_TIME_DAY;
       requisicao.expiration=0;
       requisicao.comment= "COMPRA A MERCADO";
       //---resetar erros antes de enviar a ordem
       ResetLastError();
       //AGORA USAR A FUNÇÃO PARA ENVIO DE ORDENS
       bool envio_de_compra = OrderSend(requisicao,resposta);
       //---tratamento do envio da ordem caso de errado
       if(envio_de_compra==false)
         {
          //Print( "erro ao enviar ordem. O erro é  ", GetLastError());
          //--Para tratar o erro posso fazer as seguintes coisas:
          //1)remover o robo  usando a funcao "ExpertRemove()"
          //2)retry no envio da ordem
          //3)enviar uma notificação/email
          //4)imprimir um alerta
          }
         else
           {
            //Print("A ordem foi corretamente enviada para a CORRETORA  ");
            //---
            if(resposta.retcode == 10008 || resposta.retcode == 10009)
              {
              //Print("Ordem corretamente colocada/executada ");
              }
            else
              {
                  //Print("Erro ao executar ordem. Erro é  ", GetLastError(), " / retorno = ", resposta.retcode);
                  //--Para tratar o erro posso fazer as seguintes coisas:
                  //1)remover o robo  usando a funcao "ExpertRemove()"
                  //2)retry no envio da ordem
                  //3)enviar uma notificação/email
                  //4)imprimir um alerta
              }
            }
     }
//+------------------------------------------------------------------+
//|                      setup de venda                              |
//+------------------------------------------------------------------+  
      void SetupVenda()
      {
       MqlTradeRequest requisicao;
       MqlTradeResult resposta;
       ZeroMemory(requisicao);   // limpa a memoria da struct
       ZeroMemory(resposta);     // limpa a memoria da struct
       //AGORA: DEFINIR TODAS AS CARACTERÍSTICA DA ORDEM
       requisicao.action=TRADE_ACTION_DEAL; //aqui falei que o negocio é a mercado...no type logo abaixo eu disse que é COMPRA  a MERCADO.
       requisicao.magic = 1234;
       //requisicao.order 
       requisicao.symbol=_Symbol;
       requisicao.volume= vol;
       requisicao.price=0; // a mercado
       //requisicao.stoplimit=
       requisicao.sl=tick2.bid+stoploss; //EU QUE COLOQUEI TRADE_ACTION_DEAL  TRADE_ACTION_DEAL+30
       requisicao.tp=tick2.bid-takeprofit;  //EU QUE COLOQUEI TRADE_ACTION_DEAL   TRADE_ACTION_DEAL-5
       requisicao.deviation=5;
       requisicao.type = ORDER_TYPE_SELL; //aqui disse que é COMPRA A MERCADO
       requisicao.type_filling=ORDER_FILLING_FOK;
       requisicao.type_time = ORDER_TIME_DAY;
       requisicao.expiration=0;
       requisicao.comment= "VENDA A MERCADO";
       //---resetar erros antes de enviar a ordem
       ResetLastError();
       //AGORA USAR A FUNÇÃO PARA ENVIO DE ORDENS
       bool envio_de_venda = OrderSend(requisicao,resposta);
       //---tratamento do envio da ordem caso de errado
       if(envio_de_venda==false)
         {
          //Print( "erro ao enviar ordem. O erro é  ", GetLastError());
          //--Para tratar o erro posso fazer as seguintes coisas:
          //1)remover o robo usando a funcao "ExpertRemove()"
          //2)retry no envio da ordem
          //3)enviar uma notificação/email
          //4)imprimir um alerta
          }
         else
           {
            //Print("A ordem foi corretamente enviada para a CORRETORA  ");
            //---
            if(resposta.retcode == 10008 || resposta.retcode == 10009)
              {
              // Print("Ordem corretamente colocada/executada ");
              }
            else
              {
                  //Print("Erro ao executar ordem. Erro é  ", GetLastError(), " / retorno = ", resposta.retcode);
                  //--Para tratar o erro posso fazer as seguintes coisas:
                  //1)remover o robo  usando a funcao "ExpertRemove()"
                  //2)retry no envio da ordem
                  //3)enviar uma notificação/email
                  //4)imprimir um alerta
              }
           }
  }



123456789101112...16
Novo comentário
Razão: