HELP, failed cancel order [Invalid stops] problem!

Fernando Carreiro 2022.02.08 13:03 #11

Edison Chen #: thx, I've done all the validation in my code, including the Freeze Levels, Stop levels, etc.But the check is still wrong, I feel very confused!

Sorry, but I have difficulty believing that you are checking the Freeze Level and Stops Levels properly, because from your original post it was clear you were not aware of them, and simply stating "etc." shows that you don't even know what other checks you need to do, or else you would have referenced them.

If you want us to help check your code then you are going to have to show your code. Just because you "say" you are doing it does not mean you are doing it correctly. If you don't want to show your code, then you will have to debug it and figure it yourself and try to find what it is doing wrong.

Articles on the development Viewing project history - Trading Signals and Copy

Edison Chen 2022.02.08 13:23 #12

Fernando Carreiro #:

抱歉，但我很难相信您正在正确检查冻结级别和停止级别，因为从您的原始帖子中可以清楚地看出您不知道它们，并且只是说“等”。表明您甚至不知道您需要执行哪些其他检查，否则您会引用它们。

如果您希望我们帮助检查您的代码，那么您将不得不展示您的代码。仅仅因为你“说”你在做这件事并不意味着你做对了。如果您不想显示您的代码，那么您将不得不调试它并自己弄清楚它并尝试找出它做错了什么。

TradeClass::TradeClass(const string _symbol,
                       OrderInfo *OInfoObj,
                       const int Magic = DEFULT_TRADE_MAGIC,
                       const int _Slippage = DEFULT_TRADE_SLIPPAGE,
                       const int _MaxSpread = DEFULT_TRADE_SPREAD,
                       const string comment = DEFULT_TRADE_COMMENT) {
   symbol = _symbol;
   MaxLot = SymbolInfoDouble(_symbol,SYMBOL_VOLUME_MAX);
   MinLot = SymbolInfoDouble(_symbol,SYMBOL_VOLUME_MIN);
   point = SymbolInfoDouble(_symbol,SYMBOL_POINT);
   //FreezeLevel = SymbolInfoInteger(_symbol,SYMBOL_TRADE_FREEZE_LEVEL)*point;
   //StopLevel = SymbolInfoInteger(_symbol,SYMBOL_TRADE_STOPS_LEVEL)*point;
   StopLevel = (MathMax(SymbolInfoInteger(_symbol,SYMBOL_TRADE_STOPS_LEVEL),SymbolInfoInteger(_symbol,SYMBOL_TRADE_FREEZE_LEVEL)))*point+50*point;
   //StopLevel = SymbolInfoInteger(_symbol,SYMBOL_TRADE_STOPS_LEVEL)*point+SymbolInfoInteger(_symbol,SYMBOL_TRADE_FREEZE_LEVEL)*point;
   SymbolStartTime = SymbolInfoInteger(_symbol,SYMBOL_START_TIME);
   SymbolExpirationTime = SymbolInfoInteger(_symbol,SYMBOL_EXPIRATION_TIME);
   Slippage = _Slippage;
   MaxSpread = _MaxSpread*point;
   MagicNumber = Magic;
   Comment = comment;
   OrderObj = OInfoObj;
   t.SetAsyncMode(false);
}

bool TradeClass::MoveOrder(const ENUM_ORDER_TYPE _OP,
                           const int Ticket,
                           const double _Price,
                           const double _SL=0,
                           const double _TP=0) {
   if(!OrderSelect(Ticket)) return false;
   if(MathAbs(_Price - OrderGetDouble(ORDER_PRICE_OPEN)) < point || MathAbs(_Price - OrderGetDouble(ORDER_PRICE_OPEN)) < SymbolInfoDouble(symbol,SYMBOL_TRADE_TICK_SIZE)) return false;
   if(!CheckPrice(_OP,_Price)) return false;
   static double SL,TP;
   SL = _SL != 0 ? SLTransfer(symbol,_OP,_SL,_Price) : _SL;
   TP = _TP != 0 ? TPTransfer(symbol,_OP,_TP,_Price) : _TP;
   if(!CheckTP(_OP,TP,SL)) return false;
   if(!CheckSL(_OP,SL,TP)) return false;
   //if(!OrderValid(_OP,_Price,SL,TP)) return false;
   ExeState = t.OrderModify(Ticket,_Price,SL,TP,0,0,0);
   if(ExeState) {
      PendingMoveTime[PositionGetInteger(POSITION_TYPE)] = TimeCurrent();
      OrderObj.RefreshOrderInfo();
   } else printf(__FUNCTION__+" Failed to move order price : "+GetLastError());
   return ExeState;
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool TradeClass::PositionMoveTP(const int Ticket,const double TP) {
   if(!PositionSelectByTicket(Ticket)) return false;
   if(MathAbs(TP - PositionGetDouble(POSITION_TP)) < point) {
      return false;
   }
   if(PositionGetInteger(POSITION_TYPE) == ORDER_TYPE_SELL) {
      if(!CheckTP(ORDER_TYPE_SELL,TP,PositionGetDouble(POSITION_PRICE_OPEN))) return false;
      if(!CheckSL(ORDER_TYPE_SELL,PositionGetDouble(POSITION_SL),PositionGetDouble(POSITION_PRICE_OPEN))) return false;
   } else if(PositionGetInteger(POSITION_TYPE) == ORDER_TYPE_BUY) {
      if(!CheckTP(ORDER_TYPE_BUY,TP,PositionGetDouble(POSITION_PRICE_OPEN))) return false;
      if(!CheckSL(ORDER_TYPE_BUY,PositionGetDouble(POSITION_SL),PositionGetDouble(POSITION_PRICE_OPEN))) return false;
   }
   //if(!PositionValid(PositionGetInteger(POSITION_TYPE),PositionGetDouble(POSITION_SL),TP)) return false;
   ExeState = t.PositionModify(Ticket,PositionGetDouble(POSITION_SL),TP);
   if(ExeState) {
      TPMoveTime[PositionGetInteger(POSITION_TYPE)] = TimeCurrent();
      OrderObj.RefreshOrderInfo();
   } else printf(__FUNCTION__+" Failed to move takeprofit : "+GetLastError());
   return ExeState;
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool TradeClass::PositionMoveSL(const int Ticket,const double SL) {
   if(!PositionSelectByTicket(Ticket)) return false;
   if(MathAbs(SL - PositionGetDouble(POSITION_SL)) < point) return false;
   if(PositionGetInteger(POSITION_TYPE) == ORDER_TYPE_SELL) {
      if(!CheckSL(ORDER_TYPE_SELL,SL,PositionGetDouble(POSITION_PRICE_OPEN))) return false;
      if(!CheckTP(ORDER_TYPE_SELL,PositionGetDouble(POSITION_TP),PositionGetDouble(POSITION_PRICE_OPEN))) return false;
   }
   if(PositionGetInteger(POSITION_TYPE) == ORDER_TYPE_BUY) {
      if(!CheckSL(ORDER_TYPE_BUY,SL,PositionGetDouble(POSITION_PRICE_OPEN))) return false;
      if(!CheckTP(ORDER_TYPE_BUY,PositionGetDouble(POSITION_TP),PositionGetDouble(POSITION_PRICE_OPEN))) return false;
   }
   //if(!PositionValid(PositionGetInteger(POSITION_TYPE),SL,PositionGetDouble(POSITION_TP))) return false;
   ExeState = t.PositionModify(Ticket,SL,PositionGetDouble(POSITION_TP));
   if(ExeState) OrderObj.RefreshOrderInfo();
   else printf(__FUNCTION__+" Failed to move stoploss : "+GetLastError());
   return ExeState;
}

bool TradeClass::CheckPrice(const ENUM_ORDER_TYPE OP,const double _Price) {
   if(OP == ORDER_TYPE_BUY_LIMIT) {
      if(_Price < BID(symbol) - StopLevel-1*point) {
         return true;
      }
   } else if(OP == ORDER_TYPE_SELL_LIMIT) {
      if(_Price > ASK(symbol) + StopLevel+1*point) {
         return true;
      }
   } else if(OP == ORDER_TYPE_SELL_STOP) {
      if(_Price < BID(symbol) - StopLevel-1*point) {
         return true;
      }
   } else if(OP == ORDER_TYPE_BUY_STOP) {
      if(_Price > ASK(symbol) + StopLevel+1*point) {
         return true;
      }
   }
   return false;
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double TradeClass::SLTransfer(const string s,const int OP,const double Sl,const double price=0) {
   if(OP == ORDER_TYPE_BUY) {
      return (ASK(symbol) - Sl*point);
   }
   if(OP == ORDER_TYPE_BUY_LIMIT || OP == ORDER_TYPE_BUY_STOP) {
      return (price - Sl*point);
   }
   if(OP == ORDER_TYPE_SELL) {
      return (BID(symbol) + Sl*point);
   }
   if(OP == ORDER_TYPE_SELL_LIMIT || OP == ORDER_TYPE_SELL_STOP) {
      return (price + Sl*point);
   }
   return 0;
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
double TradeClass::TPTransfer(const string s,const int OP,const double Tp,const double price=0) {
   if(OP == ORDER_TYPE_BUY)
      return (ASK(symbol) + Tp*point);
   if(OP == ORDER_TYPE_BUY_LIMIT || OP == ORDER_TYPE_BUY_STOP)
      return (price + Tp*point);
   if(OP == ORDER_TYPE_SELL)
      return (BID(symbol) - Tp*point);
   if(OP == ORDER_TYPE_SELL_LIMIT || OP == ORDER_TYPE_SELL_STOP)
      return (price - Tp*point);
   return 0;
}

I did try everything and had no problems running EA on MT5. The code is posted, please help me to have a look, thank you!

Fernando Carreiro 2022.02.08 13:34 #13

No! You can't just interchange Stops Levels and Freeze Levels. They are completely different concepts and limits.

StopLevel Minimum Distance Limitation.

A trade operation will not be performed if any of the following conditions is disrupted.

Order Type	Open Price	StopLoss (SL)	TakeProfit (TP)
Buy	Modification is prohibited	Bid-SL ≥ StopLevel	TP-Bid ≥ StopLevel
Sell	Modification is prohibited	SL-Ask ≥ StopLevel	Ask-TP ≥ StopLevel
BuyLimit	Ask-OpenPrice ≥ StopLevel	OpenPrice-SL ≥ StopLevel	TP-OpenPrice ≥ StopLevel
SellLimit	OpenPrice-Bid ≥ StopLevel	SL-OpenPrice ≥StopLevel	OpenPrice-TP ≥ StopLevel
BuyStop	OpenPrice-Ask ≥ StopLevel	OpenPrice-SL ≥ StopLevel	TP-OpenPrice ≥ StopLevel
SellStop	Bid-OpenPrice ≥ StopLevel	SL-OpenPrice ≥ StopLevel	OpenPrice-TP ≥ StopLevel

FreezeLevel Limitation (Freezing Distance).

Market orders can not be closed if the StopLoss and TakeProfit values violate the FreezLevel parameter requirements.
StopLoss or TakeProfit orders can not be modified if StopLoss or TakeProfit values violate the StopLevel parameter requirements.
Pending orders can not be deleted or modified if the declared open price violates the FreezeLevel parameter requirements.

Order Type	Open Price	StopLoss (SL)	TakeProfit (TP)
Buy	Modification is prohibited	Bid-SL > FreezeLevel	TP-Bid > FreezeLevel
Sell	Modification is prohibited	SL-Ask > FreezeLevel	Ask-TP > FreezeLevel
BuyLimit	Ask-OpenPrice > FreezeLevel	Regulated by the StopLevel parameter	Regulated by the StopLevel parameter
SellLimit	OpenPrice-Bid > FreezeLevel	Regulated by the StopLevel parameter	Regulated by the StopLevel parameter
BuyStop	OpenPrice-Ask > FreezeLevel	Regulated by the StopLevel parameter	Regulated by the StopLevel parameter
SellStop	Bid-OpenPrice > FreezeLevel	Regulated by the StopLevel parameter	Regulated by the StopLevel parameter

Fernando Carreiro 2022.02.08 13:35 #14

Also read the following in detail ... The checks a trading robot must pass before publication in the Market

Especially these points:

Setting the TakeProfit and StopLoss levels within the SYMBOL_TRADE_STOPS_LEVEL minimum level

Attempt to modify order or position within the SYMBOL_TRADE_FREEZE_LEVEL freeze level

The checks a trading robot must pass before publication in the Market

www.mql5.com

Before any product is published in the Market, it must undergo compulsory preliminary checks in order to ensure a uniform quality standard. This article considers the most frequent errors made by developers in their technical indicators and trading robots. An also shows how to self-test a product before sending it to the Market.

Modifying a Position - Modifying a Position - Request Execution - Opening

Edison Chen 2022.02.08 14:08 #15

Fernando Carreiro #:

另请详细阅读以下内容...交易机器人在市场上发布之前必须通过的检查

尤其是这几点：

在 SYMBOL_TRADE_STOPS_LEVEL 最低水平内设置止盈和止损水平

尝试在 SYMBOL_TRADE_FREEZE_LEVEL 冻结级别内修改订单或头寸

You are very detailed, it is very useful indeed, thank you very much!

Keith Watford 2022.02.08 22:45 #16

Edison Chen:

Do not double post!

I have deleted your duplicated topic.

Edison Chen 2022.02.09 03:36 #17

TradeClass::TradeClass(const string _symbol,
                       OrderInfo *OInfoObj,
                       const int Magic = DEFULT_TRADE_MAGIC,
                       const int _Slippage = DEFULT_TRADE_SLIPPAGE,
                       const int _MaxSpread = DEFULT_TRADE_SPREAD,
                       const string comment = DEFULT_TRADE_COMMENT) {
   symbol = _symbol;
   MaxLot = SymbolInfoDouble(_symbol,SYMBOL_VOLUME_MAX);
   MinLot = SymbolInfoDouble(_symbol,SYMBOL_VOLUME_MIN);
   point = SymbolInfoDouble(_symbol,SYMBOL_POINT);
   FreezeLevel = SymbolInfoInteger(_symbol,SYMBOL_TRADE_FREEZE_LEVEL)*point+50*point;
   StopLevel = SymbolInfoInteger(_symbol,SYMBOL_TRADE_STOPS_LEVEL)*point+50*point;
   SymbolStartTime = SymbolInfoInteger(_symbol,SYMBOL_START_TIME);
   SymbolExpirationTime = SymbolInfoInteger(_symbol,SYMBOL_EXPIRATION_TIME);
   Slippage = _Slippage;
   MaxSpread = _MaxSpread*point;
   MagicNumber = Magic;
   Comment = comment;
   OrderObj = OInfoObj;
   t.SetAsyncMode(false);
}

//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool TradeClass::CheckTP(const ENUM_ORDER_TYPE _OP,const double _TP,const double _Price) {
   switch(_OP) {
   case ORDER_TYPE_BUY: {
      if(_TP - BID(symbol) > MathMax(StopLevel,FreezeLevel)) {
         return true;
      }
   }
   break;
   case ORDER_TYPE_SELL: {
      if(ASK(symbol) - _TP > MathMax(StopLevel,FreezeLevel)) {
         return true;
      }
   }
   break;
   case ORDER_TYPE_BUY_LIMIT: {
      if(_TP - _Price > StopLevel) {
         return true;
      }
   }
   break;
   case ORDER_TYPE_BUY_STOP: {
      if(_TP - _Price > StopLevel) {
         return true;
      }
   }
   break;
   case ORDER_TYPE_SELL_LIMIT: {
      if(_Price - _TP > StopLevel) {
         return true;
      }
   }
   break;
   case ORDER_TYPE_SELL_STOP: {
      if(_Price - _TP > StopLevel) {
         return true;
      }
   }
   break;
   }
   return false;
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool TradeClass::CheckSL(const ENUM_ORDER_TYPE _OP,const double _SL,const double _Price) {
   switch(_OP) {
   case ORDER_TYPE_BUY: {
      if(BID(symbol) - _SL > MathMax(StopLevel,FreezeLevel)) {
         return true;
      }
   }
   break;
   case ORDER_TYPE_SELL: {
      if(_SL-ASK(symbol) > MathMax(StopLevel,FreezeLevel)) {
         return true;
      }
   }
   break;
   case ORDER_TYPE_BUY_LIMIT: {
      if(_Price - _SL > StopLevel) {
         return true;
      }
   }
   break;
   case ORDER_TYPE_BUY_STOP: {
      if(_Price - _SL > StopLevel) {
         return true;
      }
   }
   break;
   case ORDER_TYPE_SELL_LIMIT: {
      if(_SL - _Price > StopLevel) {
         return true;
      }
   }
   break;
   case ORDER_TYPE_SELL_STOP: {
      if(_SL - _Price > StopLevel) {
         return true;
      }
   }
   break;
   }
   return false;
}
//+------------------------------------------------------------------+
//|                                                                  |
//+------------------------------------------------------------------+
bool TradeClass::CheckPrice(const int _OP,const double _Price) {
   switch(_OP) {
   case ORDER_TYPE_BUY_LIMIT: {
      if(ASK(symbol) - _Price > MathMax(StopLevel,FreezeLevel)) {
         return true;
      }
   }
   break;
   case ORDER_TYPE_BUY_STOP: {
      if(_Price-ASK(symbol) > MathMax(StopLevel,FreezeLevel)) {
         return true;
      }
   }
   break;
   case ORDER_TYPE_SELL_LIMIT: {
      if(_Price-BID(symbol) > MathMax(StopLevel,FreezeLevel)) {
         return true;
      }
   }
   break;
   case ORDER_TYPE_SELL_STOP: {
      if(BID(symbol) - _Price > MathMax(StopLevel,FreezeLevel)) {
         return true;
      }
   }
   break;
   }
   return false;
}

I recalculated STOPLEVEL and FREEZELEVEL according to the method provided in the article, but it still couldn't pass directly. I had to add some extra points. At present, I added 50 points to pass the verification, but it was wrong for my trading system. Who can help me to see if there is a problem with the code? Thanks very much!

Average Directional Movement Index Average Directional Movement Index Average Directional Movement Index

HELP, failed cancel order [Invalid stops] problem! - page 2

StopLevel Minimum Distance Limitation.

FreezeLevel Limitation (Freezing Distance).