Menu
Sister Sites

Options

Bookmark Thread

First Page First Unread Last Page Last Post

Print Thread

Similar Threads

Need help programming some indicators/EAs 67 replies

Idea for indicator need help programming 7 replies

need help programming indicator 0 replies

Need Help Programming EA 65 replies

Need help for programming this indicator 2 replies

Attachments: Need help w/ programming logic
Exit Attachments

Need help w/ programming logic

  • Post #1
  • Quote
  • First Post: Jul 19, 2010 6:32pm Jul 19, 2010 6:32pm
Hi all,

Since nobody has stepped into help me with my EA design without furnishing funds, I have decided to continue my own amazing coding!

Can someone help me figure out a riddle in mt4 on how to do a certain task?

The task is:

How can I change my code so that it will enter a stop order 'x' pips away from current price without entering it 10,000 times everytime it hits that price again and again.

If price moves 15 pips long, enter long stop 15 pips away (ONCE!).

Any help with logic is greatly appreciated!!!

Here is my code that enters 30,000 orders... Brokers would love this.

-----Please focus on the 'for existing trades' section.

Inserted Code
   
   if(int NoOrdersYet; NoOrdersYet < 1)
   {
      OrderSend(Symbol(), 4, LotSize, (Ask+(OrderDistance*Point)), Slippage, StopLoss ,TakeProfit ,"First Long", MagicNumber, 0, ArrowColor);  //Sends first long
      OrderSend(Symbol(), 5, LotSize, (Bid-(OrderDistance*Point)), Slippage, StopLoss ,TakeProfit ,"First Short", MagicNumber, 0, ArrowColor); //Sends first short
      NoOrdersYet++;
      
   }
      
   
   //For existing trades
   for (int x = 0; x < OrdersTotal(); x++) 
   {
      if (OrderSelect(x,SELECT_BY_POS,MODE_TRADES))
      {
         if ((OrderSymbol()==Symbol() && OrderMagicNumber() == MagicNumber))
            
         {
            
               if (OrderType()==OP_BUY) 
               { 
                     if(OrderOpenPrice() <= (Ask+(OrderDistance*Point))) 
                     {
                        OrderSend(Symbol(), 4, LotSize, (Ask+OrderDistance*Point), Slippage, StopLoss , TakeProfit ,"Next Entry Long", MagicNumber, 0,ArrowColor);
                        LastLongOpenPrice = OrderOpenPrice();
                     }
                     if(OrderOpenPrice() > (Ask + ((OrderDistance*2)*Point)))
                     {
                        OrderSend(Symbol(), 4, LotSize, (Ask+OrderDistance*Point), Slippage, StopLoss , TakeProfit ,"Retrace Entry Short", MagicNumber, 0,ArrowColor);
                        LastLongOpenPrice = OrderOpenPrice();
                     }
                     //NumberLongPendingOrders++;
               }
               else if (OrderType()==OP_SELL) 
               {  
                     if(OrderOpenPrice() == (Bid*(OrderDistance*Point))) 
                     {
                        OrderSend(Symbol(), 4, LotSize, (Bid+OrderDistance*Point), Slippage, StopLoss , TakeProfit ,"Next Entry Long", MagicNumber, 0,ArrowColor);
                        LastShortOpenPrice = OrderOpenPrice();
                     }
                     if(OrderOpenPrice() < (Bid + ((OrderDistance*2)*Point)))
                     {
                        OrderSend(Symbol(), 4, LotSize, (Bid+OrderDistance*Point), Slippage, StopLoss , TakeProfit ,"Retrace Entry Short", MagicNumber, 0,ArrowColor);
                        LastShortOpenPrice = OrderOpenPrice();
                     }
               }
            
            //Clearing out orders further than 100 pips  ---DOESN'T SEEM TO WORK
            /*else if (OrderType() == 4 && OrderOpenPrice() >= (Ask + (MaximumPipsPending*Point)))
            {
               OrderDelete(OrderTicket());
            }
            else if (OrderType() == 5 && OrderOpenPrice() <= (Bid + (MaximumPipsPending*Point)))
            {
               OrderDelete(OrderTicket());
            }*/
         }
      }
   }
We are our own best indicator.
The primary rule I see here that may be causing the issue is that the OrdersTotal() function should never be used in any loop.

Instead use:

int TotalOrders = OrdersTotal()

Now we use TotalOrders in our loop.


Why do this...because every loop will create an order and so OrdersTotal() is called on every loop but it is now larger then when you started. It is ever increasing.

Does that make sense in terms of how i described it?
Quoting flyer415
The primary rule I see here that may be causing the issue is that the OrdersTotal() function should never be used in any loop.

Instead use:

int TotalOrders = OrdersTotal()

Now we use TotalOrders in our loop.


Why do this...because every loop will create an order and so OrdersTotal() is called on every loop but it is now larger then when you started. It is ever increasing.

Does that make sense in terms of how i described it?
Ok, I changed it to the following:

Inserted Code
TotalOrders = OrdersTotal();
   for (int x = 0; x < TotalOrders; x++) 
   {

Unfortunately, I get the same exact result?

Thank you for the response!

I have uploaded the mq4 file so you can see what happens. I have a TS imbedded from another EA.
Attached File(s)
File Type: mq4 grid trader.mq4   10 KB | 286 downloads
We are our own best indicator.
Here you go.......

PHP Code
    //For existing trades
   int TotalOrders = OrdersTotal();
   if (OrdersTotal()==2){
      for (int x = 0; x < TotalOrders; x++){
         if (OrderSelect(x,SELECT_BY_POS,MODE_TRADES)){
            if ((OrderSymbol()==Symbol() && OrderMagicNumber() == MagicNumber)){
               if (OrderType()==OP_BUY){ 
                  if(OrderOpenPrice() <= Ask+(OrderDistance*Point)){
                     OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+OrderDistance*Point,Digits), Slippage, StopLoss , TakeProfit ,"Next Entry Long", MagicNumber, 0,ArrowColor);
                     LastLongOpenPrice = OrderOpenPrice();
                  }
                  if(OrderOpenPrice() > Ask + (OrderDistance*2)*Point){
                     OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+OrderDistance*Point,Digits), Slippage, StopLoss , TakeProfit ,"Retrace Entry Short", MagicNumber, 0,ArrowColor);
                     LastLongOpenPrice = OrderOpenPrice();
                  }
              }
              if (OrderType()==OP_SELL){  
                  if(OrderOpenPrice() >= Bid+(OrderDistance*Point)){
                     OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Bid+OrderDistance*Point,Digits), Slippage, StopLoss , TakeProfit ,"Next Entry Long", MagicNumber, 0,ArrowColor);
                     LastShortOpenPrice = OrderOpenPrice();
                  }
                  if(OrderOpenPrice() < Bid + (OrderDistance*2)*Point){
                     OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Bid+OrderDistance*Point,Digits), Slippage, StopLoss , TakeProfit ,"Retrace Entry Short", MagicNumber, 0,ArrowColor);
                     LastShortOpenPrice = OrderOpenPrice();
                  }
              }
            }
         }
      }
   } 
Remember to Normalise your doubles. I also fixed a small bug. Under the if (order = OP_SELL), you had Bid * (OrderDistance........I assume you meant Bid +(OrderDistance.........
Quoting kennyhubbard
Here you go.......

[php]...
Awesome! This seems to work now! Good explanation and thanks for pointing the bug out. haha... That would have cost me 15 minutes.

Now I have more things to fix.
We are our own best indicator.
Hi Everyone -

Can't post a thread yet so I will ask in here if that's ok... Don't worry it's very simple as today is the first day I've attempted to code mq4...

Real simple...

I want to round to 2 decimal places! Simple enough right... Someone suggested to me to use NormalizeDouble.... but that just changes 10.123456 to 10.123000.

This is what I want rounded:
Inserted Code
double pipval = MarketInfo(Symbol(),MODE_TICKVALUE);

Please tell me there's an easy function to wrap around what I have... thanks!!
NormaliseDouble will round the number off to 2 digits for you(in your example 3 digits). There is absolutely no difference to the internal calculations if you have 1.23 or 1.230000

If you want to display the number for humans to see then you should use DoubleToStr.
I tried DoubleToStr, however it converts it to a string, and I cannot manipulate it. For example I want to multiply by 10. Here's more of the code:

Inserted Code
   double pipval = MarketInfo(Symbol(),MODE_TICKVALUE);
   
   ObjectCreate("Pipval_vari", OBJ_LABEL, 0, 0, 0);
   ObjectSetText("Pipval_vari","$" + pipval * 10 + "USD",10, "Tahoma", Sienna); // "Pipval_vari" will be variable 
   ObjectSet("Pipval_vari", OBJPROP_CORNER, 0);                    // and will change based on pip value of pair
   ObjectSet("Pipval_vari", OBJPROP_XDISTANCE, 85);
   ObjectSet("Pipval_vari", OBJPROP_YDISTANCE, 35);
Manipulate and then display it.........

double pipval = MarketInfo(Symbol(),MODE_TICKVALUE) * 10;
string My_String_pipval = DoubletoStr(pipval,2);
Move it all into the start function.
Kenny,

Ok, I need some help as my brain is fried. I don't believe my EA will work per what I need.

I am actually trying to do something quite simple, but the logic defies me at the moment and maybe you have some ideas. you can point me down a road if possible and I will code my way though the jungle.

I just want a system that:

a) puts a buy stop ever X pips from current price (each time only once!)
b) puts a sell stop every x pips from current price (each time only once!)

If buy gets opened, then TS (per previous EA attachment) gets used with new entries in long position, with Sell Stop @ 2 times X below waiting if market retraces.

Example, upon open, 2 orders, 1 short stop 15 pips away, 1 long stop 15 pips away. Long gets entered, then if price goes another 15 pips, long gets entered again. Then, the next short stop will be 2 times X = 30 pips below for retrace. Then if market continues down 15 pips, another short gets opened and long stop 30 pips away. (make sense??--- haha)

Basic grid of X pips, with reentry on retraces of 2 times X.

My trailing stop will take care so no more than one entry in current direction could be opened without TS = 0.

I have tried:

Single order entry without buy/sell stops, no luck
Single order entries following price, no luck
Looping and creating a static distance for 150 X pip entries on both sides, then trying to update if price moves X pips away etc..

How would you do this? I know it is simple, but when I do it, it keeps opening 10,000 orders each time price == X distance and/or if I change it I can't seem to get the lastopenorderprice to be accurate, etc...

One week down of learning.
We are our own best indicator.
Let me think about it a bit. I can probably throw some ideas your way.

What happens to the order that doesn't activate the TS such a long when the price reverses and picks up the short stop? Does it have a SL?
bluemele,

One thing to look at. The reason you are having problems with getting an accurate lastorderopenprice is because you are not selecting the order.

You are selecting the previous order and then making a trade. Logic dictates that when you make a trade THAT order becomes the selected one. Unfortunately MQL4 does not do this......it will still retain the previous order.

Try using OrderSelect(OrderTicket(),SELECT_BY_TICKET) and then store the OrderOpenPrice.
Quoting kennyhubbard
Let me think about it a bit. I can probably throw some ideas your way.

What happens to the order that doesn't activate the TS such a long when the price reverses and picks up the short stop? Does it have a SL?
NO SL, I was going to write in a martingale at 200-300 pips out (dependent upon currency) to recover trade at BE + 10 pips or so.

I am doing this on a penny per pip account, and I figure 1K per currency is enough and 10K for 20 currencies should be good enough.
We are our own best indicator.
Quoting kennyhubbard
bluemele,

One thing to look at. The reason you are having problems with getting an accurate lastorderopenprice is because you are not selecting the order.

You are selecting the previous order and then making a trade. Logic dictates that when you make a trade THAT order becomes the selected one. Unfortunately MQL4 does not do this......it will still retain the previous order.

Try using OrderSelect(OrderTicket(),SELECT_BY_TICKET) and then store the OrderOpenPrice.
Ok, I have gone down another road for now. If that doesn't work by this afternoon, I will go back and try that. I figure that OpenOrderPrice() would be accurate, but that makes sense!
We are our own best indicator.
Ok, Thanks Kenny for your help. As mentioned, I am going down maybe a simpler path that accomplishes the same thing.

What I am doing, is, if no orders, then open 2 stops orders, one long, one short.

Then, if only one pending order now exists (meaning one got filled), then delete all orders (pending only) and then add the one stop in the same direction 1 X orderdistance, and 2 X orderdistance in opposite direction.

So, if it drops 15 pips, it enters short, and deletes buy stop and places buy stop 30 pips to the north while adding sell stop 15 pips to the south.

I think this is easier in a way! however, my logic is messed up as it keeps adding a number to my TotalPendingOrders each time!

Probably something easy to spot!




Inserted Code
//+------------------------------------------------------------------+
//|                                               Ben_trail_stop.mq4 |
//|                            Copyright © 2010, www.compu-forex.com |
//|                                              www.compu-forex.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2010, www.compu-forex.com"
#property link      "www.compu-forex.com"

//+------------------------------------------------------------------+
// Added by Robert for better error reporting
#include <stdlib.mqh>
#include <stderror.mqh>
//+------------------------------------------------------------------+

//---- input parameters
extern int        OrderDistance     = 15;       //Distance of order entry to include spread*2 + Minimum Broker Modification distance
extern int        Retracement       = 2;        //# of OrderDistance increments to reenter in opposite direction, ex. (2)Retracement X (15)OrderDistance = 30 total
extern double     LotSize           = 0.01;     //Size of lot to be introduced
extern int        MagicNumber       = 0;
extern bool       Own_Symbol_Only   = true;
extern double     Trail_From        = 10.0;
extern double     Trail_Max         = 50.0;
extern double     Trail_Percent     = 50;
extern int        Slippage          = 3;        //slippage for orders
extern double     StopLoss          = 0.0;      //Take Profit
extern double     TakeProfit        = 0.0;      //Take Profit
extern int        MaximumPipsPending= 100;      //Maixmum pips distance to leave pending orders open
extern int        TotalOrdersToInput = 150;     //Total pending orders in both directions 

string   ArrowColor = "blue";
bool     mod;
int      err; // for better error reporting
double   My_Profit, 
         My_Trail, 
         My_SL, 
         lTrail_Max, 
         lTrail_From,
         Stop_Level,
         Pip,
         LastLongOpenPrice,
         LastShortOpenPrice,
         LastOpenOrderPrice;
int      TotalOrders,NumberofLongPendingOrders,NumberofShortPendingOrders,TotalPendingOrders;




//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
{
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
{
////////////-------------------------------------------------------///
//    THIS SECTION OPENS ORDERS
///////////--------------------------------------------------------///
   int TotalOrders = OrdersTotal();
   double OrderReEntryPrice = ((OrderDistance * 2) * Point);
   
   if(TotalOrders == 0)
   {
      OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+(OrderDistance*Point),Digits), Slippage, StopLoss ,TakeProfit ,"First Long", MagicNumber, 0, ArrowColor);  //Sends first longs
      OrderSend(Symbol(), 5, LotSize, NormalizeDouble(Bid-(OrderDistance*Point),Digits), Slippage, StopLoss ,TakeProfit ,"First Short", MagicNumber, 0, ArrowColor);  //Sends first shorts
   }
   else if(TotalOrders > 0)
   {
      for(int x = 0; x < TotalOrders; x++)
      {
         if (OrderSelect(x,SELECT_BY_POS,MODE_TRADES))
         {
            if ((OrderSymbol()==Symbol() && OrderMagicNumber() == MagicNumber))
            {
               if(OrderType() == 4)
               {
                  NumberofLongPendingOrders++;break;
               }  
               if(OrderType() == 5)
               {
                  NumberofShortPendingOrders++;break;
               }     
            }
            
         }
      }
      TotalPendingOrders = NumberofLongPendingOrders + NumberofShortPendingOrders;
      if(TotalPendingOrders < 2)
      {
         for(int d = 0; d < TotalOrders; d++)
         {
            OrderDelete(OrderTicket());
         }
         if(NumberofLongPendingOrders < 1)
         {
            OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+OrderDistance*Point,Digits), Slippage, StopLoss , TakeProfit ,"2nd Entry Long", MagicNumber, 0,ArrowColor);
            OrderSend(Symbol(), 5, LotSize, NormalizeDouble(Ask-(OrderDistance*Point*Retracement),Digits), Slippage, StopLoss ,TakeProfit ,"Retrace Short", MagicNumber, 0, ArrowColor);  //Sends first shorts   
         }
         if(NumberofLongPendingOrders < 1)
         {
            OrderSend(Symbol(), 5, LotSize, NormalizeDouble(Bid-(OrderDistance*Point),Digits), Slippage, StopLoss ,TakeProfit ,"First Short", MagicNumber, 0, ArrowColor);  //Sends first shorts   
            OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+OrderDistance*Point*Retracement,Digits), Slippage, StopLoss , TakeProfit ,"Retrace Entry Long", MagicNumber, 0,ArrowColor);
         }
      }             
   }
   Comment(
   "Number of Pending Orders: ",(TotalPendingOrders),"n",
   "Long Pending Orders: ",(NumberofLongPendingOrders),"n",
   "Short Pending Orders: ", (NumberofLongPendingOrders));
      
  
   
//-------------------------------------------------------------------+++++++++++++++++++++++++++++++++
   /////////////BEGIN TRAILING STOP /////////////////////////////////
//-------------------------------------------------------------------+++++++++++++++++++++++++++++++++
   for (int i = 0; i < OrdersTotal(); i++){
      if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)){
         if(OrderLots() != LotSize) // only modifies base lot size for martingaling larger lots
            {break;}
         if(Own_Symbol_Only && OrderSymbol() != Symbol())continue;
         if(OrderMagicNumber() == MagicNumber || MagicNumber == 0){
            RefreshRates();
            Pip = MarketInfo(OrderSymbol(),MODE_POINT);
            if (MarketInfo(OrderSymbol(),MODE_DIGITS) == 3|| MarketInfo(OrderSymbol(),MODE_DIGITS) == 5)Pip*=10;
            lTrail_Max = Trail_Max * Pip;
            lTrail_From = Trail_From * Pip;
            Stop_Level = MarketInfo(OrderSymbol(),MODE_STOPLEVEL)*Pip;
            switch(OrderType()){
               case OP_BUY :  My_Profit = MarketInfo(OrderSymbol(), MODE_BID) - OrderOpenPrice();
                              My_Trail = MathMin(My_Profit * Trail_Percent/100,lTrail_Max);
                              My_SL = NormalizeDouble(MarketInfo(OrderSymbol(),MODE_BID)-My_Trail,Digits);
                              if(My_Profit > lTrail_From){
                                 if(MarketInfo(OrderSymbol(),MODE_BID) - My_SL > Stop_Level){
//+------------------------------------------------------------------+
// This will cause a double OrderModify if OrderStopLoss() returns 0
// Combining both tests fixes the bug that returns error 1.
//
//                                 if(OrderStopLoss() == 0)mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0, CLR_NONE);
//+------------------------------------------------------------------+
                                    if(OrderStopLoss() < My_SL || OrderStopLoss() == 0) mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0, CLR_NONE);
                                 }
                              }
                              break;
                        
               case OP_SELL : My_Profit = OrderOpenPrice() - MarketInfo(OrderSymbol(), MODE_ASK);
                              My_Trail = MathMin(My_Profit * Trail_Percent/100,lTrail_Max);
                              My_SL = NormalizeDouble(MarketInfo(OrderSymbol(),MODE_ASK)+My_Trail,Digits);
                              if(My_Profit > lTrail_From){
                                 if(My_SL - MarketInfo(OrderSymbol(),MODE_ASK) > Stop_Level){
// Combined these as well for cleaner code
//                                 if(OrderStopLoss() == 0)mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0,CLR_NONE);
                                    if(My_SL < OrderStopLoss() || OrderStopLoss() == 0) mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0,CLR_NONE);
                                 }
                              }
                              break;
               }
// Modified to output a text description of the error
//             if(!mod && GetLastError() > 1)Print("Error entering Trailing Stop - Error " + GetLastError());
               if(!mod)
               {
                  err = GetLastError();
                  if (err > 1) Print("Error entering Trailing Stop - Error (" + err + "} " + ErrorDescription(err) );
               }
         }
      }
      else Print("Error selecting order");
   } 
//----
   return(0);
  }
  
void OpenLongs()
{
   for(int x = 0; x < TotalOrdersToInput; x++)
      {
         OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+(OrderDistance*Point*x),Digits), Slippage, StopLoss ,TakeProfit ,"First Long", MagicNumber, 0, ArrowColor);  //Sends first longs
         //LastLongOpenPrice == OrderOpenPrice();
      }
}
void OpenShorts()
{
   for(int x = 0; x < TotalOrdersToInput; x++)
      {
         OrderSend(Symbol(), 5, LotSize, NormalizeDouble(Bid-(OrderDistance*Point*x),Digits), Slippage, StopLoss ,TakeProfit ,"First Short", MagicNumber, 0, ArrowColor);  //Sends first shorts
         //LastShortOpenPrice == OrderOpenPrice();
      }
}
void DeleteLongs()
{
   for(int d = 0; d < TotalOrders; d++)
   {
      if (OrderSelect(d,SELECT_BY_POS,MODE_TRADES))
      {
         if ((OrderSymbol()==Symbol() && OrderMagicNumber() == MagicNumber))
         {
            //if (OrderType()==OP_BUY)
            //{
               OrderDelete(OrderTicket());
               
            //}
         }
      }
   }
   return(0);
}
//+------------------------------------------------------------------+
We are our own best indicator.
Here's something you can toy with. Should give you a few ideas. I still think you need to find a way to deal with the hanging orders.

Unfortunately, I'm not much one for comments in my code, so ask if there is anything you don't follow.
Attached File(s)
File Type: mq4 Bluemele_Trend_Grid.mq4   8 KB | 338 downloads
Ok, I think i got it!

Only a few things now I have to implement for logic:

1. If sending pending order, check for existing orders in same direction within OrderDistance, if order exists, then increment OrderDistance by X times.

2. Add Martingale to incorporate grabbing smaller trades and getting out of them.

3. Change TS to skip if ordersize is greater than starting lots.

After that, I think it will work.

This concept was from a RENKO concept that I tested on NinjaTrader. However, NT doesn't incorporate spread and I had to do it off slippage and commission.

Should work reasonably well. Incorporating Snowball and NanningBob 4H system.


Inserted Code
//+------------------------------------------------------------------+
//|                                               Ben_trail_stop.mq4 |
//|                            Copyright © 2010, www.compu-forex.com |
//|                                              www.compu-forex.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2010, www.compu-forex.com"
#property link      "www.compu-forex.com"

//+------------------------------------------------------------------+
// Added by Robert for better error reporting
#include <stdlib.mqh>
#include <stderror.mqh>
//+------------------------------------------------------------------+

//---- input parameters
extern int        OrderDistance     = 15;       //Distance of order entry to include spread*2 + Minimum Broker Modification distance
extern double     Retracement       = 2.0;        //# of OrderDistance increments to reenter in opposite direction, ex. (2)Retracement X (15)OrderDistance = 30 total
extern double     LotSize           = 0.01;     //Size of lot to be introduced
extern int        MagicNumber       = 0;
extern bool       Own_Symbol_Only   = true;
extern double     Trail_From        = 10.0;
extern double     Trail_Max         = 50.0;
extern double     Trail_Percent     = 50;
extern int        Slippage          = 3;        //slippage for orders
extern double     StopLoss          = 0.0;      //Take Profit
extern double     TakeProfit        = 0.0;      //Take Profit
extern int        MaximumPipsPending= 100;      //Maixmum pips distance to leave pending orders open
extern int        TotalOrdersToInput = 150;     //Total pending orders in both directions 

string   ArrowColor = "blue";
bool     mod;
int      err; // for better error reporting
double   My_Profit, 
         My_Trail, 
         My_SL, 
         lTrail_Max, 
         lTrail_From,
         Stop_Level,
         Pip,
         LastLongOpenPrice,
         LastShortOpenPrice,
         LastOpenOrderPrice;
int      TotalOrders,NumberofLongPendingOrders,NumberofShortPendingOrders,TotalPendingOrders;




//+------------------------------------------------------------------+
//| expert initialization function                                   |
//+------------------------------------------------------------------+
int init()
{
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert deinitialization function                                 |
//+------------------------------------------------------------------+
int deinit()
  {
//----
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| expert start function                                            |
//+------------------------------------------------------------------+
int start()
{
////////////-------------------------------------------------------///
//    THIS SECTION OPENS ORDERS
///////////--------------------------------------------------------///
   int TotalOrders = OrdersTotal();
   double OrderReEntryPrice = ((OrderDistance * 2) * Point);
   
   if(TotalOrders == 0)
   {
      OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+(OrderDistance*Point),Digits), Slippage, StopLoss ,TakeProfit ,"First Long", MagicNumber, 0, ArrowColor);  //Sends first longs
      OrderSend(Symbol(), 5, LotSize, NormalizeDouble(Bid-(OrderDistance*Point),Digits), Slippage, StopLoss ,TakeProfit ,"First Short", MagicNumber, 0, ArrowColor);  //Sends first shorts
   }
   else if(TotalOrders > 0)
   {
      NumberofLongPendingOrders = 0;
      NumberofShortPendingOrders = 0;
      TotalPendingOrders = 0;
      for(int x = 0; x < TotalOrders; x++)
      {
         if (OrderSelect(x,SELECT_BY_POS,MODE_TRADES))
         {
            if ((OrderSymbol()==Symbol() && OrderMagicNumber() == MagicNumber))
            {
               if(OrderType() == 4)
               {
                  NumberofLongPendingOrders++;
               }
               if(OrderType() == 5)
               {
                  NumberofShortPendingOrders++;
               }              
            }
            
         }
      }
      TotalPendingOrders = NumberofLongPendingOrders + NumberofShortPendingOrders;
      if(TotalPendingOrders != 2)
      {
         for(int d = 0; d < TotalOrders; d++)
         {
            if(OrderSelect(d,SELECT_BY_POS,MODE_TRADES))
            {
               OrderDelete(OrderTicket());
            }
         }
         if(NumberofLongPendingOrders < 1)
         {
            OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+OrderDistance*Point,Digits), Slippage, StopLoss , TakeProfit ,"2nd Entry Long", MagicNumber, 0,ArrowColor);
            OrderSend(Symbol(), 5, LotSize, NormalizeDouble(Ask-(OrderDistance*Point*Retracement),Digits), Slippage, StopLoss ,TakeProfit ,"Retrace Entry Short", MagicNumber, 0, ArrowColor);  //Sends first shorts   
         }
         if(NumberofShortPendingOrders < 1)
         {
            OrderSend(Symbol(), 5, LotSize, NormalizeDouble(Bid-(OrderDistance*Point),Digits), Slippage, StopLoss ,TakeProfit ,"2nd Entry Short", MagicNumber, 0, ArrowColor);  //Sends first shorts   
            OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+OrderDistance*Point*Retracement,Digits), Slippage, StopLoss , TakeProfit ,"Retrace Entry Long", MagicNumber, 0,ArrowColor);
         }
      }             
   }
   Comment(
   "Number of Pending Orders: ",(TotalPendingOrders),"n",
   "Long Pending Orders: ",(NumberofLongPendingOrders),"n",
   "Short Pending Orders: ", (NumberofLongPendingOrders));
   
//-------------------------------------------------------------------+++++++++++++++++++++++++++++++++
   /////////////BEGIN TRAILING STOP /////////////////////////////////
//-------------------------------------------------------------------+++++++++++++++++++++++++++++++++
   for (int i = 0; i < OrdersTotal(); i++){
      if (OrderSelect(i,SELECT_BY_POS,MODE_TRADES)){
         if(OrderLots() != LotSize) // only modifies base lot size for martingaling larger lots
            {break;}
         if(Own_Symbol_Only && OrderSymbol() != Symbol())continue;
         if(OrderMagicNumber() == MagicNumber || MagicNumber == 0){
            RefreshRates();
            Pip = MarketInfo(OrderSymbol(),MODE_POINT);
            if (MarketInfo(OrderSymbol(),MODE_DIGITS) == 3|| MarketInfo(OrderSymbol(),MODE_DIGITS) == 5)Pip*=10;
            lTrail_Max = Trail_Max * Pip;
            lTrail_From = Trail_From * Pip;
            Stop_Level = MarketInfo(OrderSymbol(),MODE_STOPLEVEL)*Pip;
            switch(OrderType()){
               case OP_BUY :  My_Profit = MarketInfo(OrderSymbol(), MODE_BID) - OrderOpenPrice();
                              My_Trail = MathMin(My_Profit * Trail_Percent/100,lTrail_Max);
                              My_SL = NormalizeDouble(MarketInfo(OrderSymbol(),MODE_BID)-My_Trail,Digits);
                              if(My_Profit > lTrail_From){
                                 if(MarketInfo(OrderSymbol(),MODE_BID) - My_SL > Stop_Level){
//+------------------------------------------------------------------+
// This will cause a double OrderModify if OrderStopLoss() returns 0
// Combining both tests fixes the bug that returns error 1.
//
//                                 if(OrderStopLoss() == 0)mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0, CLR_NONE);
//+------------------------------------------------------------------+
                                    if(OrderStopLoss() < My_SL || OrderStopLoss() == 0) mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0, CLR_NONE);
                                 }
                              }
                              break;
                        
               case OP_SELL : My_Profit = OrderOpenPrice() - MarketInfo(OrderSymbol(), MODE_ASK);
                              My_Trail = MathMin(My_Profit * Trail_Percent/100,lTrail_Max);
                              My_SL = NormalizeDouble(MarketInfo(OrderSymbol(),MODE_ASK)+My_Trail,Digits);
                              if(My_Profit > lTrail_From){
                                 if(My_SL - MarketInfo(OrderSymbol(),MODE_ASK) > Stop_Level){
// Combined these as well for cleaner code
//                                 if(OrderStopLoss() == 0)mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0,CLR_NONE);
                                    if(My_SL < OrderStopLoss() || OrderStopLoss() == 0) mod = OrderModify(OrderTicket(),OrderOpenPrice(),My_SL,OrderTakeProfit(),0,CLR_NONE);
                                 }
                              }
                              break;
               }
// Modified to output a text description of the error
//             if(!mod && GetLastError() > 1)Print("Error entering Trailing Stop - Error " + GetLastError());
               if(!mod)
               {
                  err = GetLastError();
                  if (err > 1) Print("Error entering Trailing Stop - Error (" + err + "} " + ErrorDescription(err) );
               }
         }
      }
      else Print("Error selecting order");
   } 
//----
   return(0);
  }
  
void OpenLongs()
{
   for(int x = 0; x < TotalOrdersToInput; x++)
      {
         OrderSend(Symbol(), 4, LotSize, NormalizeDouble(Ask+(OrderDistance*Point*x),Digits), Slippage, StopLoss ,TakeProfit ,"First Long", MagicNumber, 0, ArrowColor);  //Sends first longs
         //LastLongOpenPrice == OrderOpenPrice();
      }
}
void OpenShorts()
{
   for(int x = 0; x < TotalOrdersToInput; x++)
      {
         OrderSend(Symbol(), 5, LotSize, NormalizeDouble(Bid-(OrderDistance*Point*x),Digits), Slippage, StopLoss ,TakeProfit ,"First Short", MagicNumber, 0, ArrowColor);  //Sends first shorts
         //LastShortOpenPrice == OrderOpenPrice();
      }
}
void DeleteLongs()
{
   for(int d = 0; d < TotalOrders; d++)
   {
      if (OrderSelect(d,SELECT_BY_POS,MODE_TRADES))
      {
         if ((OrderSymbol()==Symbol() && OrderMagicNumber() == MagicNumber))
         {
            //if (OrderType()==OP_BUY)
            //{
               OrderDelete(OrderTicket());
               
            //}
         }
      }
   }
   return(0);
}
//+------------------------------------------------------------------+
We are our own best indicator.
Quoting kennyhubbard
Here's something you can toy with. Should give you a few ideas. I still think you need to find a way to deal with the hanging orders.

Unfortunately, I'm not much one for comments in my code, so ask if there is anything you don't follow.
Will check it out!
We are our own best indicator.
  • Post #20
  • Quote
  • Last Post: Jul 21, 2010 10:25pm Jul 21, 2010 10:25pm
Quoting kennyhubbard
Here's something you can toy with. Should give you a few ideas. I still think you need to find a way to deal with the hanging orders.

Unfortunately, I'm not much one for comments in my code, so ask if there is anything you don't follow.
Kenny,

Wow, I think we ended up coming to the same conclusion but with your code about 10,000 times more efficient (although harder to read for me.. )!

Awesome!

I created a thread to use this system and enhance it, so if we could redirect to here: http://www.forexfactory.com/showthread.php?t=246739

Yours seems to have the same kind of issue that I have with my code. One big thing is that since I plan on Martingaling the straggler trades, then I would not want to have multiple stragglers possible within the ORDERDISTANCE.

I tried doing this in my EA that I built, but I failed and realized this may be above my level for now. If you run it on the backtester, you will see where two trades will get stranded within 2-3 or 5-8 pips of each other. I wonder if there is a way to check that if an existing order within the next grid sizing exists, then to push the next order just outside of orderdistance?

You are a stud man! Wow.... You are gifted at this for sure! Wow...
We are our own best indicator.
0 traders viewing now