Robot Example 5 – One Cancels the Other Order

This example robot adds separate take profit and stop loss orders to example one. It also needs to implement the MetaTrader equivalent of a One Cancels the Other order. When one of the exit orders is executed the robot cancels the other one itself.

Here are the results from the MetaTrader strategy tester (but with the list of trades shortened):

Here's the source code for our OCO "robot":

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

//|                                                     GuruEx05.mq4 |

//|     Copyright © 2009, Marketing Dreams Ltd. All Rights Reserved. |

//|                                         http://trading-gurus.com |

//|                                                                  |

//| GuruTrader™ example 5                                            |

//| Version 1.0                                                      |

//|                                                                  |

//| Adds futures style stops and targets to example 1.               |

//| The EA does a One Cancels the Other order all by itself!         |

//|                                                                  |

//| Wealth Warning! This expert is for educational purposes only.    |

//| It should NEVER be used on a live account. Past performance is   |

//| in no way indicative of future results!                          |

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

#property copyright "Copyright © 2009, Marketing Dreams Ltd."

#property link      "http://trading-gurus.com"

#define SLEEP_OK     250
#define SLEEP_ERR    250

//---- input parameters
extern int     Magic = 12349;
extern int     Slippage=30;
extern int     ProfitTarget=1000;
extern int     StopLoss=10000;
extern double  Lots=0.01;

//---- static variables
static int     Dig;
static double  Points;

static bool    Initialized = FALSE;
static bool    Running = FALSE;
static int     OrderNumber;
static int     TargetOrder;
static int     StopOrder;
static double  LastBid;
static double  LastAsk;

static color   clBuy = DodgerBlue;
static color   clSell = Crimson;

//+------------------------------------------------------------------+
//| Utility functions                                                |
//+------------------------------------------------------------------+
#include <stdlib.mqh>
#include <stderror.mqh>
#include <WinUser32.mqh>

//+------------------------------------------------------------------+
//| Expert helper functions                                          |
//+------------------------------------------------------------------+

//+------------------------------------------------------------------+
//| Places a market order                                            |
//+------------------------------------------------------------------+
int Order(string symbol, int Type, double Entry, double Quantity,
          double TargetPrice, double StopPrice, string comment="")
{
   string TypeStr;
   color  TypeCol;
   int    ErrorCode, Ticket;
   double Price, FillPrice;

   Price = NormalizeDouble(Entry, Dig);

   switch (Type) {
      case OP_BUY:
         TypeStr = "BUY";
         TypeCol = clBuy;
         break;
      case OP_SELL:
         TypeStr = "SELL";
         TypeCol = clSell;
         break;
      default:
         Print("Unknown order type ", Type);
         break;
   }

   Ticket = OrderSend(symbol, Type, Quantity, Price, Slippage,
              StopPrice, TargetPrice, comment, Magic, 0, TypeCol);
   if (Ticket >= 0) {
      Sleep(SLEEP_OK);
      if (OrderSelect(Ticket, SELECT_BY_TICKET) == TRUE) {
         FillPrice = OrderOpenPrice();
         if (Entry != FillPrice) {
            RefreshRates();
            Print("Slippage on order ", Ticket, " - Requested = ",
                  Entry, ", Fill = ", FillPrice, ", Current Bid = ",
                  Bid, ", Current Ask = ", Ask);
         }
      }
      else {
         ErrorCode = GetLastError();
         Print("Error selecting new order ", Ticket, ": ",
               ErrorDescription(ErrorCode), " (", ErrorCode, ")");
      }
      return (Ticket);
   }

   ErrorCode = GetLastError();
   RefreshRates();
   Print("Error opening ", TypeStr, " order: ", ErrorDescription(ErrorCode),
         " (", ErrorCode, ")", ", Entry = ", Price, ", Target = ",
         TargetPrice, ", Stop = ", StopPrice, ", Current Bid = ", Bid,
         ", Current Ask = ", Ask);
   Sleep(SLEEP_ERR);

   return (-1);
}

//+------------------------------------------------------------------+
//| Places a pending order                                           |
//+------------------------------------------------------------------+
int PendingOrder(string symbol, int Type, double Entry, double Quantity,
          double TargetPrice, double StopPrice, string comment="")
{
   string TypeStr;
   color  TypeCol;
   int    ErrorCode, Ticket;
   double Price, FillPrice;

   Price = NormalizeDouble(Entry, Dig);

   switch (Type) {
      case OP_BUYSTOP:
         TypeStr = "BUY STOP";
         TypeCol = clBuy;
         break;
      case OP_SELLSTOP:
         TypeStr = "SELL STOP";
         TypeCol = clSell;
         break;
      case OP_BUYLIMIT:
         TypeStr = "BUY LIMIT";
         TypeCol = clBuy;
         break;
      case OP_SELLLIMIT:
         TypeStr = "SELL LIMIT";
         TypeCol = clSell;
         break;
      default:
         Print("Unknown pending order type ", Type);
         break;
   }

   Ticket = OrderSend(symbol, Type, Quantity, Price, Slippage,
              StopPrice, TargetPrice, comment, Magic, 0, TypeCol);
   if (Ticket >= 0) {
      Sleep(SLEEP_OK);
      if (OrderSelect(Ticket, SELECT_BY_TICKET) == FALSE) {
         ErrorCode = GetLastError();
         Print("Error selecting new pending order ", Ticket, ": ",
               ErrorDescription(ErrorCode), " (", ErrorCode, ")");
      }
      return (Ticket);
   }

   ErrorCode = GetLastError();
   RefreshRates();
   Print("Error opening ", TypeStr, " order: ", ErrorDescription(ErrorCode),
         " (", ErrorCode, ")", ", Entry = ", Price, ", Target = ",
         TargetPrice, ", Stop = ", StopPrice, ", Current Bid = ", Bid,
         ", Current Ask = ", Ask);
   Sleep(SLEEP_ERR);

   return (-1);
}

//+------------------------------------------------------------------+
//| Cancels a pending order                                           |
//+------------------------------------------------------------------+
int Cancel(int Ticket)
{
   int ErrorCode;

   if (OrderSelect(Ticket, SELECT_BY_TICKET) != TRUE) {
      ErrorCode = GetLastError();
      Print("Error selecting order to cancel ", Ticket, ": ",
            ErrorDescription(ErrorCode), " (", ErrorCode, ")");
   }

   if (OrderDelete(Ticket) != TRUE) {
      ErrorCode = GetLastError();
      Print("Error cancelling order ", Ticket, ": ",
            ErrorDescription(ErrorCode), " (", ErrorCode, ")");
      Sleep(SLEEP_ERR);
      return (-1);
   }
   switch(OrderType()) {
   case OP_BUYSTOP:
   case OP_SELLSTOP:
      StopOrder = 0;
      break;
   case OP_BUYLIMIT:
   case OP_SELLLIMIT:
      TargetOrder = 0;
      break;
   default:
      break;
   }
   Sleep(SLEEP_OK);
   return (0);
}

int CloseBy(int Ticket, int Opposite)
{
   int ErrorCode;

   if (OrderCloseBy(Ticket, Opposite) != TRUE) {
      ErrorCode = GetLastError();
      Print("Error closing order ", Ticket, " with order ", Opposite, ": ",
            ErrorDescription(ErrorCode), " (", ErrorCode, ")");
      Sleep(SLEEP_ERR);
      return (-1);
   }
   Sleep(SLEEP_OK);
   return (0);
}

//+------------------------------------------------------------------+
//| Performs system initialisation                                   |
//+------------------------------------------------------------------+
void InitSystem()
{
   Running = FALSE;

   RefreshRates();
   LastBid = Bid;
   LastAsk = Ask;

   Initialized = TRUE;
}

//+------------------------------------------------------------------+
//| Checks for entry to a trade                                      |
//+------------------------------------------------------------------+
int CheckEntry(double Size)
{
   if (Ask > LastAsk) {  // Short term uptrend so GO LONG!
      Print("Going Long!");
      OrderNumber = Order(Symbol(), OP_BUY, Ask, Size, 0,0, 0.0);
      if (OrderNumber <= 0)
         return(0);

      TargetOrder = PendingOrder(Symbol(), OP_SELLLIMIT,
            Ask + (Points * ProfitTarget), Size, 0.0, 0.0);
      if (TargetOrder <= 0)
         return(0);
      StopOrder = PendingOrder(Symbol(), OP_SELLSTOP,Bid - (Points * StopLoss), Size, 0.0,0,0);
      if (StopOrder > 0)
         return(1);
   }
   else if (Bid < LastBid) {  // Short term downtrend so GO SHORT!
      Print("Going Short!");
      OrderNumber = Order(Symbol(), OP_SELL, Bid, Size, 0.0, 0.0);
      if (OrderNumber <= 0)
         return(0);

      TargetOrder = PendingOrder(Symbol(), OP_BUYLIMIT,
            Bid - (Points * ProfitTarget), Size, 0.0, 0,0);
      if (TargetOrder <= 0)
         return(0);
      StopOrder = PendingOrder(Symbol(), OP_BUYSTOP, Ask + (Points * StopLoss), Size, 0.0,0.0);
      if (StopOrder > 0)
         return(1);

   }
   return(0);
}

//+------------------------------------------------------------------+
//| Checks for exit from a trade                                     |
//+------------------------------------------------------------------+
int CheckExit()
{
   int ErrorCode;

   if (OrderSelect(TargetOrder, SELECT_BY_TICKET) != TRUE) {
      ErrorCode = GetLastError();
      Print("Error selecting target order ", TargetOrder, ": ",
            ErrorDescription(ErrorCode), " (", ErrorCode, ")");
      return (0);
   }
   else if ((OrderType() == OP_SELL) || (OrderType() == OP_BUY)) {
      Print("Target ", TargetOrder, " reached: ", OrderOpenPrice(),
             " at ", TimeToStr(OrderOpenTime(), TIME_SECONDS));
      CloseBy(OrderNumber, TargetOrder);
      Cancel(StopOrder);
      return (1);
   }

   if (OrderSelect(StopOrder, SELECT_BY_TICKET) != TRUE) {
      ErrorCode = GetLastError();
      Print("Error selecting stop order ", StopOrder, ": ",
            ErrorDescription(ErrorCode), " (", ErrorCode, ")");
      return (0);
   }
   else if ((OrderType() == OP_SELL) || (OrderType() == OP_BUY)) {
      Print("Stop Loss ", StopOrder, " reached: ", OrderOpenPrice(),
             " at ", TimeToStr(OrderOpenTime(), TIME_SECONDS));
      CloseBy(OrderNumber, StopOrder);
      Cancel(TargetOrder);
      return (1);
   }

   return(0);
}

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
{
   Dig = MarketInfo(Symbol(), MODE_DIGITS);
   Points = MarketInfo(Symbol(), MODE_POINT);

   Print("Digits = ", Dig, ", Points = ", DoubleToStr(Points, 5));

   if (!IsDemo() && !IsTesting()) {
      MessageBox("Wealth Warning! This expert is for educational purposes only." +
            " It should NEVER be used on a live account." +
            " Past performance is in no way indicative of future results!");
      Print("Initialization Failure");
      return(-1);
   }

   InitSystem();

   Print("Initialized OK");

   return(0);
}

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
{
    Print("DeInitialized OK");

    return(0);
}

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

//| Expert start function                                            |

//| Executed on every tick                                           |

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

int start()

{

   if (!Initialized) {

      return(-1);

   }

   else if (Running) {                    // Are we in a trade at the moment?

      if (CheckExit() > 0) {              // Yes - Last trade complete?

         Initialized = FALSE;             // Yes - Indicate we need to reinitialise

         InitSystem();                    //  and start all over again!

      }

   }

   else {

      if (CheckEntry(Lots) > 0) {         // Entered a trade?

         Running = TRUE;                  // Yes - Indicate that we're in a trade

      }

   }

   return(0);

}

You can also download the source code here.