BolRSIMAs.mq5


#property copyright "Copyright 2010, vsebastien3"
#include <Trade\PositionInfo.mqh>
#include <Trade\Trade.mqh>
#include <Trade\SymbolInfo.mqh>  
#include <Trade\AccountInfo.mqh>
#include <Trade\DealInfo.mqh>
#include <Trade\OrderInfo.mqh>
CPositionInfo  m_position;                   // trade position object
CTrade         m_trade;                      // trading object
CSymbolInfo    m_symbol;                     // symbol info object
CAccountInfo   m_account;                    // account info wrapper
CDealInfo      m_deal;                       // deals object
COrderInfo     m_order;                      // pending orders object


//--- input parameters
input int bands_period= 20;        // Bollinger Bands period
input int rsi_period =13;          //rsi period
input int rsi_up=70;               //rsi overbought lvl
input int rsi_down=30;            // rsi oversold lvl
input double Lot=0.1;             // Lot if autolot inactive
input double SL=0.0238;            //stop lose value 
input int MAperiod = 200;          // Period of the MA
input int magic=1234;





input bool autolot = true ;        // activate or not autolot
input double risk=0.05;           // risk per trade of total equity


//--- global variables
//--- initialize global variables

bool           m_need_modify=false;
bool           m_OnTradeTransaction=false;
long           m_last_closed_position_type=-1;
double         m_last_closed_position_volume=0.0;
double         m_last_closed_position_profit=0.0;


bool                 InpAllMagic    = false;
int bands_shift = 0;         // Bollinger Bands shift
double deviation= 2;         // Standard deviation
 int MAshift=0;              // Ma shift
double usedlot;
double usedlot2;                  
int BolBandsHandle;                // Bolinger Bands handle
int rsiHandle;
int MAHandle;
double BBUp[],BBLow[],BBMidle[];   // dynamic arrays for numerical values of Bollinger Bands 


ulong orderTicket;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- Do we have sufficient bars to work
   if(Bars(_Symbol,_Period)<60) // total number of bars is less than 60?
     {
      Alert("We have less than 60 bars on the chart, an Expert Advisor terminated!!");
      return(-1);
     }
     
//-------------------------------------------- last closed position
    
     
//--- get handle of the Bollinger Bands and RSI indicators
   BolBandsHandle=iBands(NULL,PERIOD_CURRENT,bands_period,bands_shift,deviation,PRICE_CLOSE);
   rsiHandle=iRSI(NULL,0,rsi_period,PRICE_CLOSE);
   MAHandle=iMA(NULL,PERIOD_D1,MAperiod,MAshift,MODE_EMA,PRICE_CLOSE);
   
     if ( MAHandle == INVALID_HANDLE )
    {
      Print("Creating MA failed. Error #", GetLastError());
      return(-1);
    }
   
   if ( rsiHandle == INVALID_HANDLE )
    {
      Print("Creating RSI failed. Error #", GetLastError());
      return(-1);
    }
//--- Check for Invalid Handle
   if((BolBandsHandle<0))
     {
      Alert("Error in creation of indicators - error: ",GetLastError(),"!!");
      return(-1);
     }

   return(0);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//--- release indicator handles
   IndicatorRelease(BolBandsHandle);
   IndicatorRelease(rsiHandle);
   IndicatorRelease(MAHandle);
   
  }
  
  //--------------------------------------------------------------------------------------------------
  double RsiValue() {
//---
   double rsi[2];
  
   ResetLastError();
   if ( CopyBuffer(rsiHandle, 0, 0, 2, rsi) == 2 ) {
      return(rsi[0]);
   } else {
      Print(__FUNCTION__, ": getting RSI data failed. Error #", GetLastError());
   }
//---
   return(-1.0);
}

//----------------------------------------------------------------------------------------

  double MAvalue() {
//---
   double MA[2];
  
   ResetLastError();
   if ( CopyBuffer(MAHandle, 0, 0, 2, MA) == 2 ) {
      return(MA[0]);
   } else {
      Print(__FUNCTION__, ": getting MA data failed. Error #", GetLastError());
   }
//---
   return(-1.0);
}

//-----------------------------------------------------------
  
   double Autolot()

  {
  double balance=AccountInfoDouble(ACCOUNT_BALANCE);
  double pertem=balance*risk;
  double perte=SL*SymbolInfoDouble(_Symbol,SYMBOL_BID);
  double maxvol=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MAX);
  double minvol=SymbolInfoDouble(Symbol(),SYMBOL_VOLUME_MIN);
  double lotsize=SymbolInfoDouble(Symbol(),SYMBOL_TRADE_CONTRACT_SIZE);

   if(autolot==true)
    {
    usedlot=(pertem/perte)/lotsize;

     usedlot2 = NormalizeDouble(usedlot,2);
          if(usedlot2<minvol)
         {
         usedlot2=minvol;
         }
         
         if(usedlot2>maxvol)
         {
         usedlot2=maxvol;
         }
         
    
    }
    else usedlot2=Lot;
  
         if(usedlot2<minvol)
         {
         usedlot2=minvol;
         }
         
         if(usedlot2>maxvol)
         {
         usedlot2=maxvol;
         }
  
  
  return(0.01);
  }
  
  //------------------------------------------------------------
  
 
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//--- we will use the static Old_Time variable to serve the bar time.
//--- at each OnTick execution we will check the current bar time with the saved one.
//--- if the bar time isn't equal to the saved time, it indicates that we have a new tick.

   static datetime Old_Time;
   datetime New_Time[1];
   bool IsNewBar=false;
   
   Autolot();
   
   double rsi_value = RsiValue();
   double MA_value = MAvalue();
   bool Ismoney=CheckMoneyForTrade(_Symbol,usedlot2,0);
   
     
   

   
   
   
 

//--- copying the last bar time to the element New_Time[0]
   int copied=CopyTime(_Symbol,_Period,0,1,New_Time);
   if(copied>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
     {
      Alert("Error in copying historical times data, error =",GetLastError());
      ResetLastError();
      return;
     }

//--- EA should only check for new trade if we have a new bar
   if(IsNewBar==false)
     {
      return;
     }

//--- do we have enough bars to work with
   int Mybars=Bars(_Symbol,_Period);
   if(Mybars<60) // if total bars is less than 60 bars
     {
      Alert("We have less than 60 bars, EA will now exit!!");
      return;
     }

   MqlRates mrate[];          // To be used to store the prices, volumes and spread of each bar   

/*
     Let's make sure our arrays values for the Rates and Indicators 
     is stored serially similar to the timeseries array
*/

// the rates arrays
   ArraySetAsSeries(mrate,true);
 
// the indicator arrays
   ArraySetAsSeries(BBUp,true);
   ArraySetAsSeries(BBLow,true);
   ArraySetAsSeries(BBMidle,true);

//--- Get the details of the latest 3 bars
   if(CopyRates(_Symbol,_Period,0,3,mrate)<0)
     {
      Alert("Error copying rates/history data - error:",GetLastError(),"!!");
      return;
     }

//--- Copy the new values of our indicators to buffers (arrays) using the handle
   if(CopyBuffer(BolBandsHandle,0,0,3,BBMidle)<0 || CopyBuffer(BolBandsHandle,1,0,3,BBUp)<0
      || CopyBuffer(BolBandsHandle,2,0,3,BBLow)<0)
     {
      Alert("Error copying Bollinger Bands indicator Buffers - error:",GetLastError(),"!!");
      return;
     }


   double Ask = SymbolInfoDouble(_Symbol,SYMBOL_ASK);   // Ask price
   double Bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);   // Bid price
   
 //--- Declare bool type variables to hold our Buy and Sell Conditions
   bool Buy_Condition =(mrate[1].close < BBLow[1] &&   //closing candle under lowest BB
                        rsi_value<rsi_down &&          // rsi value lower than oversold limit
                         mrate[1].close>MA_value);     // closing candle above MA     

   bool Sell_Condition = (mrate[1].close > BBUp[1] &&  //closing candle above Highest BB
                          rsi_value>rsi_up &&          // rsi value higher than overbought limit
                          mrate[1].close<MA_value);    // closing candle under MA    
                          

   if(Buy_Condition && !PositionSelect(_Symbol) && Ismoney==true)    // Open long position
     {                                              // DEÌÀ is growing up
      LongPositionOpen();                           // and white candle crossed the Lower Band from below to above
     }

   if(Sell_Condition && !PositionSelect(_Symbol)&& Ismoney==true)    // Open short position
     {                                              // DEÌÀ is falling down
      ShortPositionOpen();                          // and Black candle crossed the Upper Band from above to below
     }

  
   return;
  }
//+------------------------------------------------------------------+
//| Open Long position                                               |
//+------------------------------------------------------------------+
void LongPositionOpen()
  {
   MqlTradeRequest mrequest;                             // Will be used for trade requests
   MqlTradeResult mresult;                               // Will be used for results of trade requests
   
   ZeroMemory(mrequest);
   ZeroMemory(mresult);
   
   double Ask = SymbolInfoDouble(_Symbol,SYMBOL_ASK);    // Ask price
   double Bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);    // Bid price

   if(!PositionSelect(_Symbol))
     {
      mrequest.action = TRADE_ACTION_DEAL;               // Immediate order execution
      mrequest.price = NormalizeDouble(Ask,_Digits);     // Lastest Ask price
      mrequest.sl = BBLow[1]-SL;                         // Stop Loss
      mrequest.tp = BBMidle[1];                          // Take Profit
      mrequest.symbol = _Symbol;                         // Symbol
      mrequest.volume = usedlot2;                             // Number of lots to trade
      mrequest.magic = magic;                                // Magic Number
      mrequest.type = ORDER_TYPE_BUY;                    // Buy Order
      mrequest.type_filling = ORDER_FILLING_FOK;         // Order execution type
      mrequest.deviation=5;                              // Deviation from current price
      OrderSend(mrequest,mresult);                       // Send order
     }
  }
//+------------------------------------------------------------------+
//| Open Short position                                              |
//+------------------------------------------------------------------+
void ShortPositionOpen()
  {
   MqlTradeRequest mrequest;                             // Will be used for trade requests
   MqlTradeResult mresult;                               // Will be used for results of trade requests
   
   ZeroMemory(mrequest);
   ZeroMemory(mresult);
   
   double Ask = SymbolInfoDouble(_Symbol,SYMBOL_ASK);    // Ask price
   double Bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);    // Bid price

   if(!PositionSelect(_Symbol))
     {
      mrequest.action = TRADE_ACTION_DEAL;               // Immediate order execution
      mrequest.price = NormalizeDouble(Bid,_Digits);     // Lastest Bid price
      mrequest.sl = BBUp[1]+SL;                          // Stop Loss
      mrequest.tp = BBMidle[1];                          // Take Profit
      mrequest.symbol = _Symbol;                         // Symbol
      mrequest.volume = usedlot2;                             // Number of lots to trade
      mrequest.magic = magic;                                // Magic Number
      mrequest.type= ORDER_TYPE_SELL;                    // Sell order
      mrequest.type_filling = ORDER_FILLING_FOK;         // Order execution type
      mrequest.deviation=5;                              // Deviation from current price
      OrderSend(mrequest,mresult);                       // Send order
     }
  }

  
  
  //-----------------------------------------------------
  
  
  double LotCheck(double lots)
  {
//--- calculate maximum volume
   double volume=NormalizeDouble(lots,2);
   double stepvol=m_symbol.LotsStep();
   if(stepvol>0.0)
      volume=stepvol*MathFloor(volume/stepvol);
//---
   double minvol=m_symbol.LotsMin();
   if(volume<minvol)
      volume=0.0;
//---
   double maxvol=m_symbol.LotsMax();
   if(volume>maxvol)
      volume=maxvol;
   return(volume);
  }
  
  
  
  //---------------------------------------------------------
  
  
  //+------------------------------------------------------------------+
//| TradeTransaction function                                        |
//+------------------------------------------------------------------+
void OnTradeTransaction(const MqlTradeTransaction &trans,
                        const MqlTradeRequest &request,
                        const MqlTradeResult &result)
  {
//--- get transaction type as enumeration value 
   ENUM_TRADE_TRANSACTION_TYPE type=trans.type;
//--- if transaction is result of addition of the transaction in history
   if(type==TRADE_TRANSACTION_DEAL_ADD)
     {
      long     deal_entry        =0;
      string   deal_symbol       ="";
      long     deal_magic        =0;
      double   deal_profit=0;
      if(HistoryDealSelect(trans.deal))
        {
         deal_entry=HistoryDealGetInteger(trans.deal,DEAL_ENTRY);
         deal_symbol=HistoryDealGetString(trans.deal,DEAL_SYMBOL);
         deal_magic=HistoryDealGetInteger(trans.deal,DEAL_MAGIC);
         deal_profit=HistoryDealGetDouble(trans.deal,DEAL_PROFIT);
        }
      else
         return;
      if(deal_symbol==Symbol() && deal_magic==magic)
         if(deal_entry==DEAL_ENTRY_OUT)
           {
            if(deal_profit>0)
              {
               Print("profit > 0.0");
              }
            else
              {
              Print("profit < 0.0");
              }
           }
     }
  }
  
  
  //----------------------------------
  bool CheckMoneyForTrade(string symb,double lots,ENUM_ORDER_TYPE type)
  {
//--- Getting the opening price
   MqlTick mqltick;
   SymbolInfoTick(symb,mqltick);
   double price=mqltick.ask;
   if(type==ORDER_TYPE_SELL)
      price=mqltick.bid;
//--- values of the required and free margin
   double margin,free_margin=AccountInfoDouble(ACCOUNT_MARGIN_FREE);
   //--- call of the checking function
   if(!OrderCalcMargin(type,symb,lots,price,margin))
     {
      //--- something went wrong, report and return false
      Print("Error in ",__FUNCTION__," code=",GetLastError());
      return(false);
     }
   //--- if there are insufficient funds to perform the operation
   if(margin>free_margin)
     {
      //--- report the error and return false
      Print("Not enough money for ",EnumToString(type)," ",lots," ",symb," Error code=",GetLastError());
      return(false);
     }
//--- checking successful
   return(true);
  }