USDJPY Time

Author: Copyright © 2019, Vladimir Karputov
Price Data Components
Series array that contains tick volumes of each bar
Orders Execution
Checks for the total of open orders
Miscellaneous
It issuies visual alerts to the screen
0 Views
0 Downloads
0 Favorites
USDJPY Time 
ÿþ//+------------------------------------------------------------------+

//|                                                  USDJPY Time.mq5 |

//|                              Copyright © 2019, Vladimir Karputov |

//|                                           http://wmua.ru/slesar/ |

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

#property copyright "Copyright © 2019, Vladimir Karputov"

#property link      "http://wmua.ru/slesar/"

#property version   "1.000"

/*

   barabashkakvn Trading engine 3.010

*/

#include <Trade\PositionInfo.mqh>

#include <Trade\Trade.mqh>

#include <Trade\SymbolInfo.mqh>  

#include <Trade\AccountInfo.mqh>

#include <Trade\DealInfo.mqh>

#include <Trade\OrderInfo.mqh>

#include <Expert\Money\MoneyFixedMargin.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

CMoneyFixedMargin *m_money;

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

//| Enum Lor or Risk                                                 |

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

enum ENUM_LOT_OR_RISK

  {

   lot=0,   // Constant lot

   risk=1,  // Risk in percent for a deal

  };

//--- input parameters

input ushort   InpStopLoss          = 00;          // Stop Loss, in pips (1.00045-1.00055=1 pips)

input ushort   InpTakeProfit        = 00;          // Take Profit, in pips (1.00045-1.00055=1 pips)

input ushort   InpTrailingFrequency = 09;          // Trailing, in seconds (< "10" -> only on a new bar)

input ushort   InpSignalsFrequency  = 10;          // Search signals, in seconds (< "10" -> only on a new bar)

input ushort   InpTrailingStop      = 00;          // Trailing Stop (min distance from price to Stop Loss, in pips

input ushort   InpTrailingStep      = 5;           // Trailing Step, in pips (1.00045-1.00055=1 pips)

input ENUM_LOT_OR_RISK IntLotOrRisk = risk;        // Money management: Lot OR Risk

input double   InpVolumeLotOrRisk   = 3.0;         // The value for "Money management"

//--- open 04::00, close 05::55

input ENUM_POSITION_TYPE InpPos_0=POSITION_TYPE_BUY;// Position 0: type

input uchar    InpPos_0_OpenHour    = 04;          // Position 0: Open hour

input uchar    InpPos_0_OpenMinutes = 00;          // Position 0: Open minutes

input uchar    InpPos_0_CloseHour   = 05;          // Position 0: Close hour

input uchar    InpPos_0_CloseMinutes= 55;          // Position 0: Close minutes

//--- BUY: open 10::00, close 12::55 

input ENUM_POSITION_TYPE InpPos_1=POSITION_TYPE_SELL;// Position 1: type

input uchar    InpPos_1_OpenHour    = 10;          // Position 0: Open hour

input uchar    InpPos_1_OpenMinutes = 00;          // Position 0: Open minutes

input uchar    InpPos_1_CloseHour   = 12;          // Position 0: Close hour

input uchar    InpPos_1_CloseMinutes= 55;          // Position 0: Close minutes

//---

input bool     InpPrintLog          = false;       // Print log

input ulong    InpMagic             = 754619436;   // Magic number

//---

ulong  ExtSlippage=10;              // Slippage



double ExtStopLoss      = 0.0;      // Stop Loss      -> double

double ExtTakeProfit    = 0.0;      // Take Profit    -> double

double ExtTrailingStop  = 0.0;      // Trailing Stop  -> double

double ExtTrailingStep  = 0.0;      // Trailing Step  -> double

double   ExtAdjustedPoint;                   // point value adjusted for 3 or 5 points

bool     ExtNeedClosePos_0       = false;    // close Position 0

bool     ExtNeedClosePos_1       = false;    // close Position 1

datetime ExtLastTrailing         = 0;        // "0" -> D'1970.01.01 00:00';

datetime ExtLastSignals          = 0;        // "0" -> D'1970.01.01 00:00';

datetime ExtPrevBars             = 0;        // "0" -> D'1970.01.01 00:00';

//--- B0:B8:0 B0:0O: 4;O ?>78F89 65AB:> >BA;568205< @57C;LB0B ...

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

//| Structure Need Positions                                         |

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

struct STRUCT_NEED_POSITION

  {

   ENUM_POSITION_TYPE pos_type;              // position type

   double            volume;                 // position volume (if "0.0" -> the lot is "Money management")

   double            stop_loss;              // position stop loss, in pips * ExtAdjustedPoint (if "0.0" -> the ExtStopLoss)

   double            take_profit;            // position take profit, in pips * ExtAdjustedPoint (if "0.0" -> the ExtTakeProfit)

   bool              waiting_transaction;    // waiting transaction, "true" -> it's forbidden to trade, we expect a transaction

   ulong             waiting_order_ticket;   // waiting order ticket, ticket of the expected order

   bool              transaction_confirmed;  // transaction confirmed, "true" -> transaction confirmed

   //--- Constructor 

                     STRUCT_NEED_POSITION()

     {

      pos_type                   = WRONG_VALUE;

      volume                     = 0.0;

      stop_loss                  = 0.0;

      take_profit                = 0.0;

      waiting_transaction        = false;

      waiting_order_ticket       = 0;

      transaction_confirmed      = false;

     }

  };

STRUCT_NEED_POSITION SNeedPosition[];

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

//| Expert initialization function                                   |

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

int OnInit()

  {

//---

   if(InpTrailingStop!=0 && InpTrailingStep==0)

     {

      string err_text=(TerminalInfoString(TERMINAL_LANGUAGE)=="Russian")?

                      ""@59;8=3 =52>7<>65=: ?0@0<5B@ \"Trailing Step\" @025= =C;N!":

                      "Trailing is not possible: parameter \"Trailing Step\" is zero!";

      //--- when testing, we will only output to the log about incorrect input parameters

      if(MQLInfoInteger(MQL_TESTER))

        {

         Print(__FUNCTION__,", ERROR: ",err_text);

         return(INIT_FAILED);

        }

      else // if the Expert Advisor is run on the chart, tell the user about the error

        {

         Alert(__FUNCTION__,", ERROR: ",err_text);

         return(INIT_PARAMETERS_INCORRECT);

        }

     }

//---

   if(!m_symbol.Name(Symbol())) // sets symbol name

      return(INIT_FAILED);

   RefreshRates();

//---

   m_trade.SetExpertMagicNumber(InpMagic);

   m_trade.SetMarginMode();

   m_trade.SetTypeFillingBySymbol(m_symbol.Name());

   m_trade.SetDeviationInPoints(ExtSlippage);

//--- tuning for 3 or 5 digits

   int digits_adjust=1;

   if(m_symbol.Digits()==3 || m_symbol.Digits()==5)

      digits_adjust=10;

   ExtAdjustedPoint=m_symbol.Point()*digits_adjust;



   ExtStopLoss       = InpStopLoss        * ExtAdjustedPoint;

   ExtTakeProfit     = InpTakeProfit      * ExtAdjustedPoint;

   ExtTrailingStop   = InpTrailingStop    * ExtAdjustedPoint;

   ExtTrailingStep   = InpTrailingStep    * ExtAdjustedPoint;

//--- check the input parameter "Lots"

   string err_text="";

   if(IntLotOrRisk==lot)

     {

      if(!CheckVolumeValue(InpVolumeLotOrRisk,err_text))

        {

         //--- when testing, we will only output to the log about incorrect input parameters

         if(MQLInfoInteger(MQL_TESTER))

           {

            Print(__FUNCTION__,", ERROR: ",err_text);

            return(INIT_FAILED);

           }

         else // if the Expert Advisor is run on the chart, tell the user about the error

           {

            Alert(__FUNCTION__,", ERROR: ",err_text);

            return(INIT_PARAMETERS_INCORRECT);

           }

        }

     }

   else

     {

      if(m_money!=NULL)

         delete m_money;

      m_money=new CMoneyFixedMargin;

      if(m_money!=NULL)

        {

         if(InpVolumeLotOrRisk<1 || InpVolumeLotOrRisk>100)

           {

            Print("The value for \"Money management\" (",DoubleToString(InpVolumeLotOrRisk,2),") -> invalid parameters");

            Print("   parameter must be in the range: from 1.00 to 100.00");

            return(INIT_FAILED);

           }

         if(!m_money.Init(GetPointer(m_symbol),Period(),m_symbol.Point()*digits_adjust))

            return(INIT_FAILED);

         m_money.Percent(InpVolumeLotOrRisk);

        }

      else

        {

         Print(__FUNCTION__,", ERROR: Object CMoneyFixedMargin is NULL");

         return(INIT_FAILED);

        }

     }

//---

   return(INIT_SUCCEEDED);

  }

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

//| Expert deinitialization function                                 |

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

void OnDeinit(const int reason)

  {

//---

   if(m_money!=NULL)

      delete m_money;

  }

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

//| Expert tick function                                             |

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

void OnTick()

  {

   if(ExtNeedClosePos_0 || ExtNeedClosePos_1)

     {

      int count_buys=0,count_sells=0;

      CalculateAllPositions(count_buys,count_sells);



      if(ExtNeedClosePos_0 && ((InpPos_0==POSITION_TYPE_BUY && count_buys>0) || (InpPos_0==POSITION_TYPE_SELL && count_sells>0)))

        {

         double level;

         if(FreezeStopsLevels(level))

           {

            CloseAllPositions(InpPos_0,level);  return;

           }

         else

            return;

        }

      else

         ExtNeedClosePos_0=false;



      if(ExtNeedClosePos_1 && ((InpPos_1==POSITION_TYPE_BUY && count_buys>0) || (InpPos_1==POSITION_TYPE_SELL && count_sells>0)))

        {

         double level;

         if(FreezeStopsLevels(level))

           {

            CloseAllPositions(InpPos_1,level);  return;

           }

         else

            return;

        }

      else

         ExtNeedClosePos_1=false;

     }

//---

   int size_need_position=ArraySize(SNeedPosition);

   if(size_need_position>0)

     {

      for(int i=0;i<size_need_position;i++)

        {

         if(SNeedPosition[i].waiting_transaction)

           {

            if(!SNeedPosition[i].transaction_confirmed)

              {

               Print("transaction_confirmed: ",SNeedPosition[i].transaction_confirmed);   return;

              }

            else if(SNeedPosition[i].transaction_confirmed)

              {

               ArrayRemove(SNeedPosition,i,1);  return;

              }

           }

         if(SNeedPosition[i].pos_type==POSITION_TYPE_BUY)

           {

            double level;

            if(FreezeStopsLevels(level))

              {

               SNeedPosition[i].waiting_transaction=true;

               OpenPosition(i,POSITION_TYPE_BUY,SNeedPosition[i].volume,

                            SNeedPosition[i].stop_loss,SNeedPosition[i].take_profit,level);

              }

            return;

           }

         if(SNeedPosition[i].pos_type==POSITION_TYPE_SELL)

           {

            double level;

            if(FreezeStopsLevels(level))

              {

               SNeedPosition[i].waiting_transaction=true;

               OpenPosition(i,POSITION_TYPE_SELL,SNeedPosition[i].volume,

                            SNeedPosition[i].stop_loss,SNeedPosition[i].take_profit,level);

              }

            return;

           }

        }

     }

//---

   if(InpTrailingFrequency>=10) // trailing no more than once every 10 seconds

     {

      datetime time_current=TimeCurrent();

      if(time_current-ExtLastTrailing>10)

        {

         double level;

         if(FreezeStopsLevels(level))

            Trailing(level);

         else

            return;

         ExtLastTrailing=time_current;

        }

     }

   if(InpSignalsFrequency>=10) // search for trading signals no more than once every 10 seconds

     {

      datetime time_current=TimeCurrent();

      if(time_current-ExtLastSignals>10)

        {

         //--- search for trading signals

         if(!RefreshRates())

           {

            ExtPrevBars=0; return;

           }

         if(!SearchTradingSignals())

           {

            ExtPrevBars=0; return;

           }

         ExtLastSignals=time_current;

        }

     }

//--- we work only at the time of the birth of new bar

   datetime time_0=iTime(m_symbol.Name(),Period(),0);

   if(time_0==ExtPrevBars)

      return;

   ExtPrevBars=time_0;

   if(InpTrailingFrequency<10) // trailing only at the time of the birth of new bar

     {

      double level;

      if(FreezeStopsLevels(level))

         Trailing(level);

     }

   if(InpSignalsFrequency<10) // search for trading signals only at the time of the birth of new bar

     {

      if(!RefreshRates())

        {

         ExtPrevBars=0; return;

        }

      //--- search for trading signals

      if(!SearchTradingSignals())

        {

         ExtPrevBars=0; return;

        }

     }

//---

  }

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

//| 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_ticket       =0;

      long     deal_order        =0;

      long     deal_time         =0;

      long     deal_time_msc     =0;

      long     deal_type         =-1;

      long     deal_entry        =-1;

      long     deal_magic        =0;

      long     deal_reason       =-1;

      long     deal_position_id  =0;

      double   deal_volume       =0.0;

      double   deal_price        =0.0;

      double   deal_commission   =0.0;

      double   deal_swap         =0.0;

      double   deal_profit       =0.0;

      string   deal_symbol       ="";

      string   deal_comment      ="";

      string   deal_external_id  ="";

      if(HistoryDealSelect(trans.deal))

        {

         deal_ticket       =HistoryDealGetInteger(trans.deal,DEAL_TICKET);

         deal_order        =HistoryDealGetInteger(trans.deal,DEAL_ORDER);

         deal_time         =HistoryDealGetInteger(trans.deal,DEAL_TIME);

         deal_time_msc     =HistoryDealGetInteger(trans.deal,DEAL_TIME_MSC);

         deal_type         =HistoryDealGetInteger(trans.deal,DEAL_TYPE);

         deal_entry        =HistoryDealGetInteger(trans.deal,DEAL_ENTRY);

         deal_magic        =HistoryDealGetInteger(trans.deal,DEAL_MAGIC);

         deal_reason       =HistoryDealGetInteger(trans.deal,DEAL_REASON);

         deal_position_id  =HistoryDealGetInteger(trans.deal,DEAL_POSITION_ID);



         deal_volume       =HistoryDealGetDouble(trans.deal,DEAL_VOLUME);

         deal_price        =HistoryDealGetDouble(trans.deal,DEAL_PRICE);

         deal_commission   =HistoryDealGetDouble(trans.deal,DEAL_COMMISSION);

         deal_swap         =HistoryDealGetDouble(trans.deal,DEAL_SWAP);

         deal_profit       =HistoryDealGetDouble(trans.deal,DEAL_PROFIT);



         deal_symbol       =HistoryDealGetString(trans.deal,DEAL_SYMBOL);

         deal_comment      =HistoryDealGetString(trans.deal,DEAL_COMMENT);

         deal_external_id  =HistoryDealGetString(trans.deal,DEAL_EXTERNAL_ID);

        }

      else

         return;

      ENUM_DEAL_ENTRY enum_deal_entry=(ENUM_DEAL_ENTRY)deal_entry;

      if(deal_symbol==m_symbol.Name() && deal_magic==InpMagic)

        {

         if(deal_type==DEAL_TYPE_BUY || deal_type==DEAL_TYPE_SELL)

           {

            int size_need_position=ArraySize(SNeedPosition);

            if(size_need_position>0)

              {

               for(int i=0;i<size_need_position;i++)

                 {

                  if(SNeedPosition[i].waiting_transaction)

                     if(SNeedPosition[i].waiting_order_ticket==deal_order)

                       {

                        Print(__FUNCTION__," Transaction confirmed");

                        SNeedPosition[i].transaction_confirmed=true;

                        break;

                       }

                 }

              }

           }

        }

     }

  }

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

//| Refreshes the symbol quotes data                                 |

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

bool RefreshRates(void)

  {

//--- refresh rates

   if(!m_symbol.RefreshRates())

     {

      Print("RefreshRates error");

      return(false);

     }

//--- protection against the return value of "zero"

   if(m_symbol.Ask()==0 || m_symbol.Bid()==0)

      return(false);

//---

   return(true);

  }

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

//| Check the correctness of the position volume                     |

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

bool CheckVolumeValue(double volume,string &error_description)

  {

//--- minimal allowed volume for trade operations

   double min_volume=m_symbol.LotsMin();

   if(volume<min_volume)

     {

      if(TerminalInfoString(TERMINAL_LANGUAGE)=="Russian")

         error_description=StringFormat("1J5< <5=LH5 <8=8<0;L=> 4>?CAB8<>3> SYMBOL_VOLUME_MIN=%.2f",min_volume);

      else

         error_description=StringFormat("Volume is less than the minimal allowed SYMBOL_VOLUME_MIN=%.2f",min_volume);

      return(false);

     }

//--- maximal allowed volume of trade operations

   double max_volume=m_symbol.LotsMax();

   if(volume>max_volume)

     {

      if(TerminalInfoString(TERMINAL_LANGUAGE)=="Russian")

         error_description=StringFormat("1J5< 1>;LH5 <0:A8<0;L=> 4>?CAB8<>3> SYMBOL_VOLUME_MAX=%.2f",max_volume);

      else

         error_description=StringFormat("Volume is greater than the maximal allowed SYMBOL_VOLUME_MAX=%.2f",max_volume);

      return(false);

     }

//--- get minimal step of volume changing

   double volume_step=m_symbol.LotsStep();

   int ratio=(int)MathRound(volume/volume_step);

   if(MathAbs(ratio*volume_step-volume)>0.0000001)

     {

      if(TerminalInfoString(TERMINAL_LANGUAGE)=="Russian")

         error_description=StringFormat("1J5< =5 :@0B5= <8=8<0;L=><C H03C SYMBOL_VOLUME_STEP=%.2f, 1;8609H89 ?@028;L=K9 >1J5< %.2f",

                                        volume_step,ratio*volume_step);

      else

         error_description=StringFormat("Volume is not a multiple of the minimal step SYMBOL_VOLUME_STEP=%.2f, the closest correct volume is %.2f",

                                        volume_step,ratio*volume_step);

      return(false);

     }

   error_description="Correct volume value";

   return(true);

  }

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

//| Check Freeze and Stops levels                                    |

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

bool FreezeStopsLevels(double &level)

  {

//--- check Freeze and Stops levels

/*

   Type of order/position  |  Activation price  |  Check

   ------------------------|--------------------|--------------------------------------------

   Buy Limit order         |  Ask               |  Ask-OpenPrice  >= SYMBOL_TRADE_FREEZE_LEVEL

   Buy Stop order          |  Ask	            |  OpenPrice-Ask  >= SYMBOL_TRADE_FREEZE_LEVEL

   Sell Limit order        |  Bid	            |  OpenPrice-Bid  >= SYMBOL_TRADE_FREEZE_LEVEL

   Sell Stop order	      |  Bid	            |  Bid-OpenPrice  >= SYMBOL_TRADE_FREEZE_LEVEL

   Buy position            |  Bid	            |  TakeProfit-Bid >= SYMBOL_TRADE_FREEZE_LEVEL 

                           |                    |  Bid-StopLoss   >= SYMBOL_TRADE_FREEZE_LEVEL

   Sell position           |  Ask	            |  Ask-TakeProfit >= SYMBOL_TRADE_FREEZE_LEVEL

                           |                    |  StopLoss-Ask   >= SYMBOL_TRADE_FREEZE_LEVEL

                           

   Buying is done at the Ask price                 |  Selling is done at the Bid price

   ------------------------------------------------|----------------------------------

   TakeProfit        >= Bid                        |  TakeProfit        <= Ask

   StopLoss          <= Bid	                     |  StopLoss          >= Ask

   TakeProfit - Bid  >= SYMBOL_TRADE_STOPS_LEVEL   |  Ask - TakeProfit  >= SYMBOL_TRADE_STOPS_LEVEL

   Bid - StopLoss    >= SYMBOL_TRADE_STOPS_LEVEL   |  StopLoss - Ask    >= SYMBOL_TRADE_STOPS_LEVEL

*/

   if(!RefreshRates() || !m_symbol.Refresh())

      return(false);

//--- FreezeLevel -> for pending order and modification

   double freeze_level=m_symbol.FreezeLevel()*m_symbol.Point();

   if(freeze_level==0.0)

      freeze_level=(m_symbol.Ask()-m_symbol.Bid())*3.0;

//--- StopsLevel -> for TakeProfit and StopLoss

   double stop_level=m_symbol.StopsLevel()*m_symbol.Point();

   if(stop_level==0.0)

      stop_level=(m_symbol.Ask()-m_symbol.Bid())*3.0;



   if(freeze_level<=0.0 || stop_level<=0.0)

      return(false);



   level=(freeze_level>stop_level)?freeze_level:stop_level;



//double spread=m_symbol.Spread()*ExtAdjustedPoint;

//level=(level>spread)?level:spread;

//---

   return(true);

  }

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

//| Open position                                                    |

//|   double stop_loss                                               |

//|      -> pips * ExtAdjustedPoint (if "0.0" -> the ExtStopLoss)    |

//|   double take_profit                                             |

//|      -> pips * ExtAdjustedPoint (if "0.0" -> the ExtTakeProfit)  |

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

void OpenPosition(const int index_in_structure,const ENUM_POSITION_TYPE pos_type,

                  const double volume,const double stop_loss,const double take_profit,

                  const double level)

  {

//--- buy

   if(pos_type==POSITION_TYPE_BUY)

     {

      double price=m_symbol.Ask();



      double sl=0.0;

      if(stop_loss==0.0)

        {

         sl=(InpStopLoss==0)?0.0:price-ExtStopLoss;

         if(sl!=0.0 && ExtStopLoss<level) // check sl

            sl=price-level;

        }

      else

        {

         sl=(stop_loss==0.0)?0.0:price-stop_loss;

         if(sl!=0.0 && stop_loss<level) // check sl

            sl=price-level;

        }



      double tp=0.0;

      if(take_profit==0.0)

        {

         tp=(InpTakeProfit==0)?0.0:price+ExtTakeProfit;

         if(tp!=0.0 && ExtTakeProfit<level) // check price

            tp=price+level;

        }

      else

        {

         tp=(take_profit==0)?0.0:price+take_profit;

         if(tp!=0.0 && take_profit<level) // check price

            tp=price+level;

        }



      OpenBuy(index_in_structure,volume,sl,tp);

     }

//--- sell

   if(pos_type==POSITION_TYPE_SELL)

     {

      double price=m_symbol.Bid();



      double sl=0.0;

      if(stop_loss==0.0)

        {

         sl=(InpStopLoss==0)?0.0:price+ExtStopLoss;

         if(sl!=0.0 && ExtStopLoss<level) // check sl

            sl=price+level;

        }

      else

        {

         sl=(stop_loss==0.0)?0.0:price+stop_loss;

         if(sl!=0.0 && stop_loss<level) // check sl

            sl=price+level;

        }



      double tp=0.0;

      if(take_profit==0.0)

        {

         tp=(InpTakeProfit==0)?0.0:price-ExtTakeProfit;

         if(tp!=0.0 && ExtTakeProfit<level) // check tp

            tp=price-level;

        }

      else

        {

         tp=(take_profit==0)?0.0:price-take_profit;

         if(tp!=0.0 && take_profit<level) // check tp

            tp=price-level;

        }



      OpenSell(index_in_structure,volume,sl,tp);

     }

  }

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

//| Open Buy position                                                |

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

void OpenBuy(const int index_in_structure,const double volume,double sl,double tp)

  {

   sl=m_symbol.NormalizePrice(sl);

   tp=m_symbol.NormalizePrice(tp);



   double long_lot=0.0;

   if(volume>0.0)

      long_lot=volume;

   else

     {

      if(IntLotOrRisk==risk)

        {

         long_lot=m_money.CheckOpenLong(m_symbol.Ask(),sl);

         if(InpPrintLog)

            Print("sl=",DoubleToString(sl,m_symbol.Digits()),

                  ", CheckOpenLong: ",DoubleToString(long_lot,2),

                  ", Balance: ",    DoubleToString(m_account.Balance(),2),

                  ", Equity: ",     DoubleToString(m_account.Equity(),2),

                  ", FreeMargin: ", DoubleToString(m_account.FreeMargin(),2));

         if(long_lot==0.0)

           {

            SNeedPosition[index_in_structure].waiting_transaction=false;

            if(InpPrintLog)

               Print(__FUNCTION__,", ERROR: method CheckOpenLong returned the value of \"0.0\"");

            return;

           }

        }

      else if(IntLotOrRisk==lot)

         long_lot=InpVolumeLotOrRisk;

      else

        {

         SNeedPosition[index_in_structure].waiting_transaction=false;

         return;

        }

     }

   if(m_symbol.LotsLimit()>0.0)

     {

      int count_buys=0;    double volume_buys=0.0;    double volume_biggest_buys=0.0;

      int count_sells=0;   double volume_sells=0.0;   double volume_biggest_sells=0.0;

      CalculateAllPositions(count_buys,volume_buys,volume_biggest_buys,

                            count_sells,volume_sells,volume_biggest_sells);

      if(volume_buys+volume_sells+long_lot>m_symbol.LotsLimit())

        {

         Print("#0 Buy, Volume Buy (",DoubleToString(volume_buys,2),

               ") + Volume Sell (",DoubleToString(volume_sells,2),

               ") + Volume long (",DoubleToString(long_lot,2),

               ") > Lots Limit (",DoubleToString(m_symbol.LotsLimit(),2),")");

         return;

        }

     }

//--- check volume before OrderSend to avoid "not enough money" error (CTrade)

   double free_margin_check= m_account.FreeMarginCheck(m_symbol.Name(),ORDER_TYPE_BUY,long_lot,m_symbol.Ask());

   double margin_check     = m_account.MarginCheck(m_symbol.Name(),ORDER_TYPE_SELL,long_lot,m_symbol.Bid());

   if(free_margin_check>margin_check)

     {

      if(m_trade.Buy(long_lot,m_symbol.Name(),m_symbol.Ask(),sl,tp)) // CTrade::Buy -> "true"

        {

         if(m_trade.ResultDeal()==0)

           {

            if(m_trade.ResultRetcode()==10009) // trade order went to the exchange

              {

               SNeedPosition[index_in_structure].waiting_transaction=true;

               SNeedPosition[index_in_structure].waiting_order_ticket=m_trade.ResultOrder();

              }

            else

               SNeedPosition[index_in_structure].waiting_transaction=false;

            if(InpPrintLog)

               Print("#1 Buy -> false. Result Retcode: ",m_trade.ResultRetcode(),

                     ", description of result: ",m_trade.ResultRetcodeDescription());

            if(InpPrintLog)

               PrintResultTrade(m_trade,m_symbol);

           }

         else

           {

            if(m_trade.ResultRetcode()==10009)

              {

               SNeedPosition[index_in_structure].waiting_transaction=true;

               SNeedPosition[index_in_structure].waiting_order_ticket=m_trade.ResultOrder();

              }

            else

               SNeedPosition[index_in_structure].waiting_transaction=false;

            if(InpPrintLog)

               Print("#2 Buy -> true. Result Retcode: ",m_trade.ResultRetcode(),

                     ", description of result: ",m_trade.ResultRetcodeDescription());

            if(InpPrintLog)

               PrintResultTrade(m_trade,m_symbol);

           }

        }

      else

        {

         SNeedPosition[index_in_structure].waiting_transaction=false;

         if(InpPrintLog)

            Print("#3 Buy -> false. Result Retcode: ",m_trade.ResultRetcode(),

                  ", description of result: ",m_trade.ResultRetcodeDescription());

         if(InpPrintLog)

            PrintResultTrade(m_trade,m_symbol);

        }

     }

   else

     {

      ArrayRemove(SNeedPosition,index_in_structure,1);

      if(InpPrintLog)

         Print(__FUNCTION__,", ERROR: method CAccountInfo::FreeMarginCheck returned the value ",DoubleToString(free_margin_check,2));

      return;

     }

//---

  }

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

//| Open Sell position                                               |

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

void OpenSell(const int index_in_structure,const double volume,double sl,double tp)

  {

   sl=m_symbol.NormalizePrice(sl);

   tp=m_symbol.NormalizePrice(tp);



   double short_lot=0.0;

   if(volume>0.0)

      short_lot=volume;

   else

     {

      if(IntLotOrRisk==risk)

        {

         short_lot=m_money.CheckOpenShort(m_symbol.Bid(),sl);

         if(InpPrintLog)

            Print("sl=",DoubleToString(sl,m_symbol.Digits()),

                  ", CheckOpenLong: ",DoubleToString(short_lot,2),

                  ", Balance: ",    DoubleToString(m_account.Balance(),2),

                  ", Equity: ",     DoubleToString(m_account.Equity(),2),

                  ", FreeMargin: ", DoubleToString(m_account.FreeMargin(),2));

         if(short_lot==0.0)

           {

            SNeedPosition[index_in_structure].waiting_transaction=false;

            if(InpPrintLog)

               Print(__FUNCTION__,", ERROR: method CheckOpenShort returned the value of \"0.0\"");

            return;

           }

        }

      else if(IntLotOrRisk==lot)

         short_lot=InpVolumeLotOrRisk;

      else

        {

         SNeedPosition[index_in_structure].waiting_transaction=false;

         return;

        }

     }

   if(m_symbol.LotsLimit()>0.0)

     {

      int count_buys=0;    double volume_buys=0.0;    double volume_biggest_buys=0.0;

      int count_sells=0;   double volume_sells=0.0;   double volume_biggest_sells=0.0;

      CalculateAllPositions(count_buys,volume_buys,volume_biggest_buys,

                            count_sells,volume_sells,volume_biggest_sells);

      if(volume_buys+volume_sells+short_lot>m_symbol.LotsLimit())

         Print("#0 Buy, Volume Buy (",DoubleToString(volume_buys,2),

               ") + Volume Sell (",DoubleToString(volume_sells,2),

               ") + Volume short (",DoubleToString(short_lot,2),

               ") > Lots Limit (",DoubleToString(m_symbol.LotsLimit(),2),")");

      return;

     }

//--- check volume before OrderSend to avoid "not enough money" error (CTrade)

   double free_margin_check= m_account.FreeMarginCheck(m_symbol.Name(),ORDER_TYPE_SELL,short_lot,m_symbol.Bid());

   double margin_check     = m_account.MarginCheck(m_symbol.Name(),ORDER_TYPE_SELL,short_lot,m_symbol.Bid());

   if(free_margin_check>margin_check)

     {

      if(m_trade.Sell(short_lot,m_symbol.Name(),m_symbol.Bid(),sl,tp)) // CTrade::Sell -> "true"

        {

         if(m_trade.ResultDeal()==0)

           {

            if(m_trade.ResultRetcode()==10009) // trade order went to the exchange

              {

               SNeedPosition[index_in_structure].waiting_transaction=true;

               SNeedPosition[index_in_structure].waiting_order_ticket=m_trade.ResultOrder();

              }

            else

               SNeedPosition[index_in_structure].waiting_transaction=false;

            if(InpPrintLog)

               Print("#1 Sell -> false. Result Retcode: ",m_trade.ResultRetcode(),

                     ", description of result: ",m_trade.ResultRetcodeDescription());

            if(InpPrintLog)

               PrintResultTrade(m_trade,m_symbol);

           }

         else

           {

            if(m_trade.ResultRetcode()==10009)

              {

               SNeedPosition[index_in_structure].waiting_transaction=true;

               SNeedPosition[index_in_structure].waiting_order_ticket=m_trade.ResultOrder();

              }

            else

               SNeedPosition[index_in_structure].waiting_transaction=false;

            if(InpPrintLog)

               Print("#2 Sell -> true. Result Retcode: ",m_trade.ResultRetcode(),

                     ", description of result: ",m_trade.ResultRetcodeDescription());

            if(InpPrintLog)

               PrintResultTrade(m_trade,m_symbol);

           }

        }

      else

        {

         SNeedPosition[index_in_structure].waiting_transaction=false;

         if(InpPrintLog)

            Print("#3 Sell -> false. Result Retcode: ",m_trade.ResultRetcode(),

                  ", description of result: ",m_trade.ResultRetcodeDescription());

         if(InpPrintLog)

            PrintResultTrade(m_trade,m_symbol);

        }

     }

   else

     {

      ArrayRemove(SNeedPosition,index_in_structure,1);

      if(InpPrintLog)

         Print(__FUNCTION__,", ERROR: method CAccountInfo::FreeMarginCheck returned the value ",DoubleToString(free_margin_check,2));

      return;

     }

//---

  }

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

//| Print CTrade result                                              |

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

void PrintResultTrade(CTrade &trade,CSymbolInfo &symbol)

  {

   Print("File: ",__FILE__,", symbol: ",symbol.Name());

   Print("Code of request result: "+IntegerToString(trade.ResultRetcode()));

   Print("code of request result as a string: "+trade.ResultRetcodeDescription());

   Print("Deal ticket: "+IntegerToString(trade.ResultDeal()));

   Print("Order ticket: "+IntegerToString(trade.ResultOrder()));

   Print("Volume of deal or order: "+DoubleToString(trade.ResultVolume(),2));

   Print("Price, confirmed by broker: "+DoubleToString(trade.ResultPrice(),symbol.Digits()));

   Print("Current bid price: "+DoubleToString(symbol.Bid(),symbol.Digits())+" (the requote): "+DoubleToString(trade.ResultBid(),symbol.Digits()));

   Print("Current ask price: "+DoubleToString(symbol.Ask(),symbol.Digits())+" (the requote): "+DoubleToString(trade.ResultAsk(),symbol.Digits()));

   Print("Broker comment: "+trade.ResultComment());

  }

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

//| Get value of buffers                                             |

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

double iGetArray(const int handle,const int buffer,const int start_pos,const int count,double &arr_buffer[])

  {

   bool result=true;

   if(!ArrayIsDynamic(arr_buffer))

     {

      Print("This a no dynamic array!");

      return(false);

     }

   ArrayFree(arr_buffer);

//--- reset error code 

   ResetLastError();

//--- fill a part of the iBands array with values from the indicator buffer

   int copied=CopyBuffer(handle,buffer,start_pos,count,arr_buffer);

   if(copied!=count)

     {

      //--- if the copying fails, tell the error code 

      PrintFormat("Failed to copy data from the indicator, error code %d",GetLastError());

      //--- quit with zero result - it means that the indicator is considered as not calculated 

      return(false);

     }

   return(result);

  }

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

//| Trailing                                                         |

//|   InpTrailingStop: min distance from price to Stop Loss          |

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

void Trailing(const double stop_level)

  {

/*

     Buying is done at the Ask price                 |  Selling is done at the Bid price

   ------------------------------------------------|----------------------------------

   TakeProfit        >= Bid                        |  TakeProfit        <= Ask

   StopLoss          <= Bid	                     |  StopLoss          >= Ask

   TakeProfit - Bid  >= SYMBOL_TRADE_STOPS_LEVEL   |  Ask - TakeProfit  >= SYMBOL_TRADE_STOPS_LEVEL

   Bid - StopLoss    >= SYMBOL_TRADE_STOPS_LEVEL   |  StopLoss - Ask    >= SYMBOL_TRADE_STOPS_LEVEL

*/

   if(InpTrailingStop==0)

      return;

   for(int i=PositionsTotal()-1;i>=0;i--) // returns the number of open positions

      if(m_position.SelectByIndex(i))

         if(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==InpMagic)

           {

            if(m_position.PositionType()==POSITION_TYPE_BUY)

              {

               if(m_position.PriceCurrent()-m_position.PriceOpen()>ExtTrailingStop+ExtTrailingStep)

                  if(m_position.StopLoss()<m_position.PriceCurrent()-(ExtTrailingStop+ExtTrailingStep))

                     if(ExtTrailingStop>=stop_level)

                       {

                        if(!m_trade.PositionModify(m_position.Ticket(),

                           m_symbol.NormalizePrice(m_position.PriceCurrent()-ExtTrailingStop),

                           m_position.TakeProfit()))

                           Print("Modify ",m_position.Ticket(),

                                 " Position -> false. Result Retcode: ",m_trade.ResultRetcode(),

                                 ", description of result: ",m_trade.ResultRetcodeDescription());

                        RefreshRates();

                        m_position.SelectByIndex(i);

                        PrintResultModify(m_trade,m_symbol,m_position);

                        continue;

                       }

              }

            else

              {

               if(m_position.PriceOpen()-m_position.PriceCurrent()>ExtTrailingStop+ExtTrailingStep)

                  if((m_position.StopLoss()>(m_position.PriceCurrent()+(ExtTrailingStop+ExtTrailingStep))) || 

                     (m_position.StopLoss()==0))

                     if(ExtTrailingStop>=stop_level)

                       {

                        if(!m_trade.PositionModify(m_position.Ticket(),

                           m_symbol.NormalizePrice(m_position.PriceCurrent()+ExtTrailingStop),

                           m_position.TakeProfit()))

                           Print("Modify ",m_position.Ticket(),

                                 " Position -> false. Result Retcode: ",m_trade.ResultRetcode(),

                                 ", description of result: ",m_trade.ResultRetcodeDescription());

                        RefreshRates();

                        m_position.SelectByIndex(i);

                        PrintResultModify(m_trade,m_symbol,m_position);

                       }

              }



           }

  }

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

//| Print CTrade result                                              |

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

void PrintResultModify(CTrade &trade,CSymbolInfo &symbol,CPositionInfo &position)

  {

   Print("File: ",__FILE__,", symbol: ",symbol.Name());

   Print("Code of request result: "+IntegerToString(trade.ResultRetcode()));

   Print("code of request result as a string: "+trade.ResultRetcodeDescription());

   Print("Deal ticket: "+IntegerToString(trade.ResultDeal()));

   Print("Order ticket: "+IntegerToString(trade.ResultOrder()));

   Print("Volume of deal or order: "+DoubleToString(trade.ResultVolume(),2));

   Print("Price, confirmed by broker: "+DoubleToString(trade.ResultPrice(),symbol.Digits()));

   Print("Current bid price: "+DoubleToString(symbol.Bid(),symbol.Digits())+" (the requote): "+DoubleToString(trade.ResultBid(),symbol.Digits()));

   Print("Current ask price: "+DoubleToString(symbol.Ask(),symbol.Digits())+" (the requote): "+DoubleToString(trade.ResultAsk(),symbol.Digits()));

   Print("Broker comment: "+trade.ResultComment());

   Print("Freeze Level: "+DoubleToString(symbol.FreezeLevel(),0),", Stops Level: "+DoubleToString(symbol.StopsLevel(),0));

   Print("Price of position opening: "+DoubleToString(position.PriceOpen(),symbol.Digits()));

   Print("Price of position's Stop Loss: "+DoubleToString(position.StopLoss(),symbol.Digits()));

   Print("Price of position's Take Profit: "+DoubleToString(position.TakeProfit(),symbol.Digits()));

   Print("Current price by position: "+DoubleToString(position.PriceCurrent(),symbol.Digits()));

   int d=0;

  }

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

//| Close positions                                                  |

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

void ClosePositions(const ENUM_POSITION_TYPE pos_type,const double level)

  {

   for(int i=PositionsTotal()-1;i>=0;i--) // returns the number of current positions

      if(m_position.SelectByIndex(i)) // selects the position by index for further access to its properties

         if(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==InpMagic)

            if(m_position.PositionType()==pos_type)

              {

               if(m_position.PositionType()==POSITION_TYPE_BUY)

                  if(MathAbs(m_symbol.Bid()-m_position.PriceOpen())>=level)

                     m_trade.PositionClose(m_position.Ticket()); // close a position by the specified symbol

               if(m_position.PositionType()==POSITION_TYPE_SELL)

                  if(MathAbs(m_symbol.Ask()-m_position.PriceOpen())>=level)

                     m_trade.PositionClose(m_position.Ticket()); // close a position by the specified symbol

              }

  }

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

//| Calculate all positions                                          |

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

void CalculateAllPositions(int &count_buys,double &volume_buys,double &volume_biggest_buys,

                           int &count_sells,double &volume_sells,double &volume_biggest_sells)

  {

   count_buys  =0;   volume_buys   = 0.0; volume_biggest_buys  = 0.0;

   count_sells =0;   volume_sells  = 0.0; volume_biggest_sells = 0.0;

   for(int i=PositionsTotal()-1;i>=0;i--)

      if(m_position.SelectByIndex(i)) // selects the position by index for further access to its properties

         if(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==InpMagic)

           {

            if(m_position.PositionType()==POSITION_TYPE_BUY)

              {

               count_buys++;

               volume_buys+=m_position.Volume();

               if(m_position.Volume()>volume_biggest_buys)

                  volume_biggest_buys=m_position.Volume();

               continue;

              }

            else if(m_position.PositionType()==POSITION_TYPE_SELL)

              {

               count_sells++;

               volume_sells+=m_position.Volume();

               if(m_position.Volume()>volume_biggest_sells)

                  volume_biggest_sells=m_position.Volume();

              }

           }

  }

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

//| Search trading signals                                           |

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

bool SearchTradingSignals(void)

  {

   datetime m1_0=iTime(m_symbol.Name(),PERIOD_M1,0);

   if(m1_0==D'1970.01.01 00:00')

      return(false);



   MqlDateTime STimeM1_0;

   TimeToStruct(m1_0,STimeM1_0);



   int count_buys=0,count_sells=0;

   CalculateAllPositions(count_buys,count_sells);



   long pos_0_open   = InpPos_0_OpenHour*60*60+InpPos_0_OpenMinutes*60;

   long pos_0_close  = InpPos_0_CloseHour*60*60+InpPos_0_CloseMinutes*60;

   long pos_1_open   = InpPos_1_OpenHour*60*60+InpPos_1_OpenMinutes*60;

   long pos_1_close  = InpPos_1_CloseHour*60*60+InpPos_1_CloseMinutes*60;

   long m1_0_current = STimeM1_0.hour*60*60+STimeM1_0.min*60;





   if(m1_0_current>=pos_0_open && m1_0_current<pos_0_open+60)

     {

      if(count_buys==0 && InpPos_0==POSITION_TYPE_BUY)

        {

         int size_need_position=ArraySize(SNeedPosition);

         ArrayResize(SNeedPosition,size_need_position+1);

         SNeedPosition[size_need_position].pos_type=POSITION_TYPE_BUY;

        }

      else if(count_sells==0 && InpPos_0==POSITION_TYPE_SELL)

        {

         int size_need_position=ArraySize(SNeedPosition);

         ArrayResize(SNeedPosition,size_need_position+1);

         SNeedPosition[size_need_position].pos_type=POSITION_TYPE_SELL;

        }

     }

   else if(m1_0_current>=pos_0_close && m1_0_current<pos_0_close+60)

     {

      ExtNeedClosePos_0=true;

     }



   if(m1_0_current>=pos_1_open && m1_0_current<pos_1_open+60)

     {

      if(count_buys==0 && InpPos_1==POSITION_TYPE_BUY)

        {

         int size_need_position=ArraySize(SNeedPosition);

         ArrayResize(SNeedPosition,size_need_position+1);

         SNeedPosition[size_need_position].pos_type=POSITION_TYPE_BUY;

        }

      else if(count_sells==0 && InpPos_1==POSITION_TYPE_SELL)

        {

         int size_need_position=ArraySize(SNeedPosition);

         ArrayResize(SNeedPosition,size_need_position+1);

         SNeedPosition[size_need_position].pos_type=POSITION_TYPE_SELL;

        }

     }

   else if(m1_0_current>=pos_1_close && m1_0_current<pos_1_close+60)

     {

      ExtNeedClosePos_1=true;

     }

//---

   return(true);

  }

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

//| Delete all pending orders                                        |

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

void DeleteAllPendingOrders(const double level)

  {

   for(int i=OrdersTotal()-1;i>=0;i--) // returns the number of current orders

      if(m_order.SelectByIndex(i))     // selects the pending order by index for further access to its properties

         if(m_order.Symbol()==m_symbol.Name() && m_order.Magic()==InpMagic)

           {

            if(m_order.OrderType()==ORDER_TYPE_BUY_LIMIT)

              {

               if(m_symbol.Ask()-m_order.PriceOpen()>=level)

                  m_trade.OrderDelete(m_order.Ticket());

               continue;

              }

            if(m_order.OrderType()==ORDER_TYPE_BUY_STOP)

              {

               if(m_order.PriceOpen()-m_symbol.Ask()>=level)

                  m_trade.OrderDelete(m_order.Ticket());

               continue;

              }

            if(m_order.OrderType()==ORDER_TYPE_SELL_LIMIT)

              {

               if(m_order.PriceOpen()-m_symbol.Bid()>=level)

                  m_trade.OrderDelete(m_order.Ticket());

               continue;

              }

            if(m_order.OrderType()==ORDER_TYPE_SELL_STOP)

              {

               if(m_symbol.Bid()-m_order.PriceOpen()>=level)

                  m_trade.OrderDelete(m_order.Ticket());

               continue;

              }

           }

  }

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

//| Calculate all positions Buy and Sell                             |

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

void CalculateAllPositions(int &count_buys,int &count_sells)

  {

   count_buys=0;

   count_sells=0;



   for(int i=PositionsTotal()-1;i>=0;i--)

      if(m_position.SelectByIndex(i)) // selects the position by index for further access to its properties

         if(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==InpMagic)

           {

            if(m_position.PositionType()==POSITION_TYPE_BUY)

               count_buys++;



            if(m_position.PositionType()==POSITION_TYPE_SELL)

               count_sells++;

           }

//---

   return;

  }

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

//| Close all positions                                              |

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

void CloseAllPositions(const ENUM_POSITION_TYPE pos_type,const double level)

  {

   for(int i=PositionsTotal()-1;i>=0;i--) // returns the number of current positions

      if(m_position.SelectByIndex(i))     // selects the position by index for further access to its properties

         if(m_position.Symbol()==m_symbol.Name() && m_position.Magic()==InpMagic)

           {

            double ask=m_symbol.Ask();

            double bid=m_symbol.Bid();

            double price_open=m_position.PriceOpen();

            if(m_position.PositionType()==POSITION_TYPE_BUY && pos_type==POSITION_TYPE_BUY)

               if(MathAbs(bid-price_open)>=level)

                  m_trade.PositionClose(m_position.Ticket()); // close a position by the specified symbol

            if(m_position.PositionType()==POSITION_TYPE_SELL && pos_type==POSITION_TYPE_SELL)

               if(MathAbs(ask-price_open)>=level)

                  m_trade.PositionClose(m_position.Ticket()); // close a position by the specified symbol

           }

  }

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

Similar scripts

EA Close

N-_Candles_v7

Pound trade

BrakeExp EA

Fractals minimum distance

Open Close

MACD and SAR

55 MA

Executor AO

RSI RFTL EA

Forex Fraus M1

Comments

Markdown supported. Formatting help

Markdown Formatting Guide

Element Markdown Syntax
Heading # H1
## H2
### H3
Bold **bold text**
Italic *italicized text*
Link [title](https://www.example.com)
Image ![alt text](image.jpg)
Code `code`
Code Block ```
code block
```
Quote > blockquote
Unordered List - Item 1
- Item 2
Ordered List 1. First item
2. Second item
Horizontal Rule ---