robo_3_media_movel

ÿþ//+------------------------------------------------------------------+

//| INCLUDES                                                         |

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

#include <Trade/Trade.mqh> // biblioteca-padrão CTrade

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

//| INPUTS                                                           |

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

input int lote = 1;                  //numero de lote/contratos de compra, padrão 1

input int periodoCurta = 3;          //periodo da media rapida

input int periodoMeio = 9;           //periodo da media do meio

input int periodoLonga = 21;         //periodo da media longa

input int hora = 11;                 //hora do horário da finalização do robo

input int minuto = 30;               //minutos da finalização do robo

input double stopLoss = 6.5;         //stop loss de cada operação

input double stopLossDinheiro = 75;  //segundo stop loss por precaução de pular ordem

input double protecao = 1;           //numeros de pontos em que a operação vai ficar protegida

input double protecaoLucro = 60;     //lucro da operação para ocorrer a proteção

input double stopGain = 10;          //stop gain de cada operação

input bool vaiProteger = true;       //verifica se vai ocorrer a proteção



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

//| GLOBAIS                                                          |

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

//--- manipuladores dos indicadores de média móvel

int curtaHandle = INVALID_HANDLE;

int meioHandle = INVALID_HANDLE;

int longaHandle = INVALID_HANDLE;

//--- vetores de dados dos indicadores de média móvel

double mediaCurta[];

double mediaMeio[];

double mediaLonga[];

//--- declarara variável trade

CTrade trade;



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

//| Expert initialization function                                   |

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

int OnInit()

  {

//---

   ArraySetAsSeries(mediaCurta,true);

   ArraySetAsSeries(mediaMeio,true);

   ArraySetAsSeries(mediaLonga,true);



//--- atribuir p/ os manupuladores de média móvel

   curtaHandle = iMA(_Symbol,_Period,periodoCurta,0,MODE_EMA,PRICE_CLOSE);

   meioHandle = iMA(_Symbol,_Period,periodoMeio,0,MODE_EMA,PRICE_CLOSE);

   longaHandle = iMA(_Symbol,_Period,periodoLonga,0,MODE_EMA,PRICE_CLOSE);









//---

   return(INIT_SUCCEEDED);

  }

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

//| Expert deinitialization function                                 |

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

void OnDeinit(const int reason)

  {

//---



  }

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

//| Expert tick function                                             |

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

void OnTick()

  {

//valida o horário de operação

   if(validarHorario(hora,minuto))

     {

      //verifica a formação de um novo candle

      if(isNewBar())

        {

         //   execute a lógica operacional do robô



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

         //| OBTENÇÃO DOS DADOS                                               |

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

         int copied1 = CopyBuffer(curtaHandle,0,0,3,mediaCurta);

         int copied3 = CopyBuffer(meioHandle,0,0,3,mediaMeio);

         int copied2 = CopyBuffer(longaHandle,0,0,3,mediaLonga);

         //---

         bool sinalCompra = false;

         bool sinalVenda = false;



         int    digits=(int)SymbolInfoInteger(_Symbol,SYMBOL_DIGITS);

         double bid=SymbolInfoDouble(_Symbol,SYMBOL_BID);

         double ask=SymbolInfoDouble(_Symbol,SYMBOL_ASK);

         double SL, LC;





         //--- se os dados tiverem sido copiados corretamente verifica sinais de compra e venda

         if(copied1==3 && copied2==3)

           {

            //--- sinal de compra

            if(mediaCurta[1]>mediaLonga[1] && mediaCurta[2]<mediaLonga[2])

              {

               sinalCompra = true;

              }

            //--- sinal de venda

            if(mediaCurta[1]<mediaLonga[1] && mediaCurta[2]>mediaLonga[2])

              {

               sinalVenda = true;

              }

           }



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

         //| VERIFICAR SE ESTOU POSICIONADO                                   |

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

         bool comprado = false;

         bool vendido = false;

         if(PositionSelect(_Symbol))

           {

            //--- se a posição for comprada

            if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_BUY)

              {

               comprado = true;

              }

            //--- se a posição for vendida

            if(PositionGetInteger(POSITION_TYPE)==POSITION_TYPE_SELL)

              {

               vendido = true;

              }

           }



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

         //| LÓGICA DE ROTEAMENTO                                             |

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

         //--- ZERADO

         if(!comprado && !vendido)

           {

            //--- sinal de compra

            if(sinalCompra)

              {



               SL=bid-stopLoss;

               SL=NormalizeDouble(SL,digits);

               LC = ask+stopGain;

               LC=NormalizeDouble(LC,digits);

               trade.Buy(lote,_Symbol,0,SL,LC,"Compra a mercado");



               Print("---------- sinal de COMPRA ----------");

              }

            //--- sinal de venda

            if(sinalVenda)

              {

               SL=bid+stopLoss;

               SL=NormalizeDouble(SL,digits);

               LC = ask-stopGain;

               LC=NormalizeDouble(LC,digits);

               trade.Sell(lote,_Symbol,0,SL,LC,"Venda a mercado");



               Print("---------- sinal de VENDA ----------");

              }

           }

         else

           {

            //--- estou comprado

            if(comprado)

              {

               // Dupla Proteção de Stop

               if(PositionGetDouble(POSITION_PROFIT)<=-stopLossDinheiro)

                 {

                  trade.PositionClose(PositionGetInteger(POSITION_TICKET));



                  Print("-----------stopLossDinheiro--------");

                 }

               // verifica se vai proteger a operação

               if(vaiProteger)

                 {

                  SL = PositionGetDouble(POSITION_PRICE_OPEN)-protecao;

                  SL=NormalizeDouble(SL,digits);



                  if(PositionGetDouble(POSITION_PROFIT)>=protecaoLucro && PositionGetDouble(POSITION_SL)!=SL)

                    {

                     SL = PositionGetDouble(POSITION_PRICE_OPEN)+protecao;

                     SL=NormalizeDouble(SL,digits);



                     trade.PositionModify(_Symbol,SL,0);



                     Print("-----------PROTEÇÃO--------");

                    }

                 }

               //se ocorrer o cruzamento da media da rapida com a lenta, finaliza a operação e inicia outra

               if(sinalVenda)

                 {

                  SL=PositionGetDouble(POSITION_PRICE_OPEN)+stopLoss;

                  SL=NormalizeDouble(SL,digits);

                  LC = ask-stopGain;

                  LC=NormalizeDouble(LC,digits);



                  trade.Sell(lote*2,_Symbol,0,SL,LC,"Virada de mão (compra->venda)");



                  Print("------------Virada de mão (compra->venda)---------");

                 }

               else

                  if(mediaCurta[1]<mediaMeio[1] && mediaCurta[2]>mediaMeio[2])

                    {

                     //finaliza a operação se a media rápida cruzar com a do meio

                     trade.Sell(lote,_Symbol,0,0,0,"Stop comprado");

                     Print("---------Stop comprado-----------");

                    }

              }

            //--- estou vendido

            else

               if(vendido)

                 {

                  // Dupla Proteção de Stop

                  if(PositionGetDouble(POSITION_PROFIT)<-stopLossDinheiro)

                    {

                     trade.PositionClose(PositionGetInteger(POSITION_TICKET));



                     Print("-----------stopLossDinheiro--------");

                    }



                  // verifica se vai proteger a operação

                  if(vaiProteger)

                    {

                     SL = PositionGetDouble(POSITION_PRICE_OPEN)-protecao;

                     SL=NormalizeDouble(SL,digits);



                     if(PositionGetDouble(POSITION_PROFIT)>=protecaoLucro && PositionGetDouble(POSITION_SL)!=SL)

                       {

                        trade.PositionModify(_Symbol,SL,0);



                        Print("----------PROTEÇÃO-----------");

                       }

                    }



                  //se ocorrer o cruzamento da media da rapida com a lenta, finaliza a operação e inicia outra

                  if(sinalCompra)

                    {

                     SL=PositionGetDouble(POSITION_PRICE_OPEN)-stopLoss;

                     SL=NormalizeDouble(SL,digits);

                     LC = ask+stopGain;

                     LC=NormalizeDouble(LC,digits);



                     trade.Buy(lote*2,_Symbol,0,SL,LC,"Virada de mão (venda->compra)");



                     Print("---------Virada de mão (venda->compra)-----------");

                    }

                  else

                     if(mediaCurta[1]>mediaMeio[1] && mediaCurta[2]<mediaMeio[2])

                       {

                        //finaliza a operação se a media rápida cruzar com a do meio

                        trade.Buy(lote,_Symbol,0,0,0,"Stop vendido");

                        Print("---------Stop vendido-----------");

                       }



                 }

           }

        }

     }

   else

     {

      if(PositionsTotal() > 0)

        {

         trade.PositionClose(PositionGetInteger(POSITION_TICKET));

        }

     }

  }

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

//| Verifica a formação de um novo Candle                            |

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

bool isNewBar()

  {

   static datetime last_time=0;

   datetime lastbar_time=(datetime)SeriesInfoInteger(Symbol(),Period(),SERIES_LASTBAR_DATE);



   if(last_time==0)

     {

      last_time=lastbar_time;

      return(false);

     }



   if(last_time!=lastbar_time)

     {

      last_time=lastbar_time;

      return(true);

     }

   return(false);

  }

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

//| Valida o Horário de Operação                                     |

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

bool validarHorario(int horaF, int minutoF)

  {

   MqlDateTime atual;

   TimeCurrent(atual);

   if(atual.hour >= hora)

     {

      return false;

     }

   else

      if(atual.hour == hora && atual.min >= minuto)

        {

         return false;

        }

   return true;

  }

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