3й Дубль. Теперь с кодом. Не открываются выставленные отложенные ордера.

Forex Trader 2005.12.26 02:59

Народ. Кто может - помогите найти причину. Долбусь уже месяц. Отправки метаквотовцам закончились тишиной с их стороны. Вынос темы на обсуждение дважды закончились несколькими вопросами и тишиной. Ордер отложенный выставляется, но когда подходит цена для его срабатывания с вероятностью процентов 20 ничего не происходит. Цена проходит мимо, а ордер продолжает висеть. Пример - История с альпари, АУДЮСД, М1, Все тики, с 2005.4.11 по 2005.4.12, Депозит 100000, параметр Lot=0.1, сервер МетаквотесДемо. Распечатываю всё, что только может дать информацию. Далее код:

//+------------------------------------------------------------------+
//|                                         Martengail-2Hands_V1.mq4 |
//+------------------------------------------------------------------+

#property copyright "Maloma"
#include <stdlib.mqh>


extern double Lot     = 1; // Начальный размер лота.
 int    Grid    = 19; // Начальный размер сетки.
 int    Limit   = 5; // На каком шаге будет ЛОК.
   double LotSeq[8] = {1,1,2.5,5.7,12.9,29.3,65.65}; // For 19 AUDUSD
   double Spred;
   double SellWorkPrice;
   double BuyWorkPrice;
   double BuyStopPrice;
   double BuyStopProfit;
   double SellLimitPrice;
   double SellLimitProfit;
   double BuyLimitPrice;
   double BuyLimitProfit;
   double SellStopPrice;
   double SellStopProfit;
   int    StateOld, StateCur;
   int    Magic=120976;
   double CurrentPrice, OldPrice;
   int    Step;
   int    LastBuy, LastSell, ProfitOrder;
   int    BuyCnt, SellCnt, BuyStopCnt, BuyLimitCnt, SellStopCnt, SellLimitCnt;
   bool   DelAll, SetAll, AP;
   int    LastLock;
      
//+------------------------------------------------------------------+
//+ Вункция считает отложенные ордера по текущему инструменту.       +
//+ Если все 4 типа выставлены, то TRUE. Если какогото нет, то FALSE +
//+------------------------------------------------------------------+
bool AllPresent() {

     BuyCnt = 0;
     SellCnt = 0;
     BuyStopCnt = 0;
     BuyLimitCnt = 0;
     SellStopCnt = 0;
     SellLimitCnt = 0;
     for (int cnt=OrdersTotal()-1;cnt>=0;cnt--)
         {
          OrderSelect(cnt,SELECT_BY_POS,MODE_TRADES);
          if ((OrderSymbol() == Symbol()) && (OrderTicket() > LastLock))
             {
              Print ("Ticket=", OrderTicket(),"  OrderType=", OrderType(), "  OrderOpenPrice=", OrderOpenPrice(), "  OrderTakeProfit=", OrderTakeProfit()," Lots=",OrderLots());
              switch (OrderType())
                  {
                   case 0: BuyCnt++;
                           break;
                   case 1: SellCnt++;
                           break;
                   case 2: BuyLimitCnt++;
                           break;
                   case 3: SellLimitCnt++;
                           break;
                   case 4: BuyStopCnt++;
                           break;
                   case 5: SellStopCnt++;
                           break;
                  }
             }
         }
     Print ("Buy=",BuyCnt," Sell=",SellCnt," BuyStopCnt==",BuyStopCnt," BuyLimitCnt==",BuyLimitCnt," SellStopCnt==",SellStopCnt," SellLimitCnt==",SellLimitCnt," Bid=",Bid);
     if ((BuyStopCnt==0) || (BuyLimitCnt==0) || (SellStopCnt==0) || (SellLimitCnt==0)) {return(false);}
     else {return(true);}
} 

//+------------------------------------------------------------------+
//+ Инициализация начальных значений и установка стартовых ордеров.  +
//+------------------------------------------------------------------+
int Initialization() { 

    Step = 1;
    StateCur = 0;
    StateOld=StateCur;
    Spred = Ask-Bid;
    RefreshRates();
    CurrentPrice = Bid;
    OpenOrder (Symbol(), OP_SELL, LotSize(0), Bid, 3, Bid+400*Point, Ask-Grid*Point, "", Magic, 0, Red);
    OpenOrder (Symbol(), OP_BUY, LotSize(0), Ask, 3, Ask-400*Point, Bid+Grid*Point, "", Magic, 0, Green);
    CalcAllPrice (CurrentPrice);
    SetAll = SetOrders (LotSize(1), LotSize(1), LotSize(1), LotSize(1));
    SearchLastSellBuy();
    LastLock=0;
}

//+---------------------+
//+ Отладочна ф-ция     +
//+---------------------+
int PrSt(int what){

  Print ("What=",what," Time=",TimeToStr(CurTime(),TIME_DATE|TIME_SECONDS)," Ask=", Ask);

}

//+------------------------------------------------------------------+
//+ Функция открытия ордера. Пытается до тех пор, пока не выставит.  +
//+ Ордер не выставится только по несоответствующим рынку параметрам.+
//+------------------------------------------------------------------+  
bool OpenOrder(string Sym, int Cmd, double Vol, double Prc, int Slp, double Stl, double Tpt, string Com, int Mag, datetime Exp, color Clr) {
  int err, max;
  
  int ticket = -1;
  max = 100;
  while ((ticket < 0) && (max != 0)) 
    {
     RefreshRates();
     ticket=OrderSend(Sym, Cmd, Vol, Prc, Slp, Stl, Tpt, Com, Mag, Exp, Clr);
     Print ("Sym=",Sym," Cmd=",Cmd," Vol=",Vol," Prc=",Prc," Stl=",Stl," Tpt=",Tpt," Com=",Com," Mag=",Mag);
     PrSt(99);
     err=GetLastError();
     if (ticket == -1) 
        {
         Comment("Error=", err, "   ", ErrorDescription(err));
         Sleep(6000);
        }
     else
        {Comment("                                             ");}
     max--;
    }
  Sleep(1000);
  if (max != 0) {return(true);}
  else {return(false);}
}
  
//+------------------------------------------------------------------------------+
//+ Функция рассчитывает Размер лота в зависимости от шага и внешних переменных. +
//+------------------------------------------------------------------------------+  
double LotSize(int tStep) {

  double rez = NormalizeDouble(Lot*LotSeq[tStep],1);
  if (rez < 0.1) {rez = 0.1;}
  return(rez);
}

//+------------------------------------------------------------------+
//+ Функция рассчитывает цены открытия и ТП для отложенных ордеров.  +
//+------------------------------------------------------------------+  
double CalcAllPrice(double SellPrice) {

   SellWorkPrice = NormalizeDouble(SellPrice,Digits);
   BuyWorkPrice = NormalizeDouble(SellWorkPrice+Spred,Digits);
   BuyStopPrice = NormalizeDouble(BuyWorkPrice+Grid*Point,Digits);
   SellLimitPrice = NormalizeDouble(SellWorkPrice+Grid*Point,Digits);
   BuyLimitPrice = NormalizeDouble(BuyWorkPrice-Grid*Point,Digits);
   SellStopPrice = NormalizeDouble(SellWorkPrice-Grid*Point,Digits);
   BuyStopProfit = NormalizeDouble(BuyStopPrice-Spred+Grid*Point,Digits);
   SellLimitProfit = NormalizeDouble(SellLimitPrice+Spred-Grid*Point,Digits);
   BuyLimitProfit = NormalizeDouble(BuyLimitPrice-Spred+Grid*Point,Digits);
   SellStopProfit = NormalizeDouble(SellStopPrice+Spred-Grid*Point,Digits);
   Print ("Spred=",Spred,"  SellWorkPrice=",SellWorkPrice,"  BuyWorkPrice=",BuyWorkPrice);
   Print ("BuyStopPrice=",BuyStopPrice,"  BuyStopProfit=",BuyStopProfit);
   Print ("SellLimitPrice=",SellLimitPrice,"  SellLimitProfit=",SellLimitProfit);
   Print ("BuyLimitPrice=",BuyLimitPrice,"  BuyLimitProfit=",BuyLimitProfit);
   Print ("SellStopPrice=",SellStopPrice,"  SellStopProfit=",SellStopProfit);
}

//+---------------------------------------------------------------------+
//+ Функция выставляет отложенные ордера по цене Lx, если Lx не равен 0 +
//+---------------------------------------------------------------------+  
bool SetOrders (double L1, double L2, double L3, double L4){
  bool rez, temp;

  rez = true;
  if (L1 != 0) {
                temp = OpenOrder (Symbol(), OP_BUYSTOP, L1, BuyStopPrice, 3, BuyStopPrice-400*Point, BuyStopProfit, "", Magic, 0, Green);
                if (!temp) {rez = false;}
               }
  if (L3 != 0) {
                temp = OpenOrder (Symbol(), OP_BUYLIMIT, L3, BuyLimitPrice, 3, BuyLimitPrice-400*Point, BuyLimitProfit, "", Magic, 0, Green);
                if (!temp) {rez = false;}
               }
  if (L2 != 0) {
                temp = OpenOrder (Symbol(), OP_SELLLIMIT, L2, SellLimitPrice, 3, SellLimitPrice+400*Point, SellLimitProfit, "", Magic, 0, Red);
                if (!temp) {rez = false;}
               }
  if (L4 != 0) {
                temp = OpenOrder (Symbol(), OP_SELLSTOP, L4, SellStopPrice, 3, SellStopPrice+400*Point, SellStopProfit, "", Magic, 0, Red);
                if (!temp) {rez = false;}
               }
  return(rez);
}

//+----------------------------------------------------------------+
//+                        Проверка на старт.                      +
//+----------------------------------------------------------------+  
bool First(){
 
  int ordcnt=0;
  for (int cnt=OrdersTotal()-1;cnt>=0;cnt--)
      {
       OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
       if ((OrderSymbol() == Symbol()) && (OrderTicket() > LastLock) && ((OrderType() == OP_BUY) || (OrderType() == OP_SELL))) {ordcnt++;}
      }
  if (ordcnt>0) {return(false);}
  else {return(true);}
}

//+------------------------------------------------------------------+
//+ Функция ищет тикеты последних открытых ордеров BUY и SELL.       +
//+------------------------------------------------------------------+  
int SearchLastSellBuy(){
  
  LastBuy=0;
  LastSell=0;
  for (int cnt=OrdersTotal()-1;cnt>=0;cnt--)
      {
       OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
       if ((OrderSymbol() == Symbol()) && (OrderTicket() > LastLock) && (OrderType() == OP_BUY))
          {
           if (OrderTicket()>LastBuy) {LastBuy=OrderTicket();}
          }
       if ((OrderSymbol() == Symbol()) && (OrderTicket() > LastLock) && (OrderType() == OP_SELL))
          {
           if (OrderTicket()>LastSell) {LastSell=OrderTicket();}
          }   
      }
  return(0);
}

//+---------------------------------------------------------------------------+
//+ Функция возврвщает тикет ордера, который достиг ТП. Если нет такого, то 0.+
//+---------------------------------------------------------------------------+  
int TakeProfit(){
   
   ProfitOrder=0;
   for (int cnt=HistoryTotal()-1;cnt>=0;cnt--)
       {
        OrderSelect(cnt, SELECT_BY_POS, MODE_HISTORY);
        if ((OrderType() == OP_SELL) || (OrderType() == OP_BUY))
           if (OrderTicket() > ProfitOrder)
              if (OrderClosePrice() == OrderTakeProfit()) {ProfitOrder = OrderTicket();}
       }
   return(ProfitOrder);
}

//+---------------------------------------------------------------------------+
//+ Функция возврвщает тикет последнего ЛОК ордера.                           +
//+---------------------------------------------------------------------------+  
int LockSearch(){
   
  LastLock = 0;
  for (int cnt=OrdersTotal()-1;cnt>=0;cnt--)
      {
       OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
       if ((OrderSymbol() == Symbol()) && (OrderMagicNumber() == 1001001) && (OrderType() == OP_BUY))
          {
           if (OrderTicket()>LastLock) {LastLock=OrderTicket();}
          }
       if ((OrderSymbol() == Symbol()) && (OrderMagicNumber() == 1001001) && (OrderType() == OP_SELL))
          {
           if (OrderTicket()>LastLock) {LastLock=OrderTicket();}
          }   
      }
  return(0);
}

//+------------------------------------+
//+ Удаляем ненужные отложенные ордера +
//+------------------------------------+
bool DelNotNeed(){
  bool res, tmp;
  int max, cnt;

  Sleep(1000);
  for (cnt=OrdersTotal()-1;cnt>=0;cnt--)
      {
       RefreshRates();
       OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
       if ((OrderSymbol() == Symbol()) && (OrderTicket() > LastLock))
          {
           if ((OrderType() == 0) && (OrderTakeProfit() <= Bid))
              {
               res = false;
               max = 100;
               while ((!res) && (max != 0)) 
                  {
                   OrderClose(OrderTicket(), OrderLots(), Bid, 3, CLR_NONE);
                   res = GetLastError();
                   max--;
                   RefreshRates();
                  }
               Sleep(1000);
              }
          }
      }
  tmp = true;
  for (cnt=OrdersTotal()-1;cnt>=0;cnt--)
      {
       RefreshRates();
       OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
       if ((OrderSymbol() == Symbol()) && (OrderTicket() > LastLock))
          {
           if (OrderType() > 1)
              {
               res = false;
               max = 100;
               while ((!res) && (max != 0)) 
                  {
                   res = OrderDelete(OrderTicket());
                   max--;
                   RefreshRates();
                  }
               if (!res) tmp = false;
              }
          }
      }
  return(tmp);
}

//+------------------------------------------------------------------------------------+
//+ Двигаем Профиты так, чтобы при откате все в убыточной руке закрылись автоматически +
//+------------------------------------------------------------------------------------+
int MoveTP(bool Last){

  int cnt, err, ticket, max;
  bool res;
    
  if (StateCur == 1)
     {
      for (cnt=OrdersTotal()-1;cnt>=0;cnt--)
          {
           RefreshRates();
           OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
           if (OrderSymbol() == Symbol())
              {
               if (OrderType() == OP_SELL)
                  {
                   if ((Last)  && (OrderTicket() < LastLock))
                      {
                       res = false;
                       max = 100;
                       while ((!res) && (max != 0)) 
                          {
                           res = OrderModify(OrderTicket(), OrderOpenPrice(), 0, 0, 0, CLR_NONE);
                           res = GetLastError();
                           Sleep(1000);
                           max--;
                          }
                      }
                   else 
                      {
                       if ((OrderTicket() != LastSell) && (OrderTicket() > LastLock))
                          {
                           res = false;
                           max = 100;
                           while ((!res) && (max != 0))  
                              {
                               res = OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), BuyLimitPrice, 0, CLR_NONE);
                               res = GetLastError();
                               Sleep(1000);
                               max--;
                              }
                          }
                      }   
                  }
              }
          }
      return(0);
     }
  if (StateCur==-1)
     {
      for (cnt=OrdersTotal()-1;cnt>=0;cnt--)
          {
           RefreshRates();
           OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
           if (OrderSymbol() == Symbol())
              {
               if (OrderType() == OP_BUY)
                  {
                   if ((Last) && (OrderTicket() < LastLock))
                      {
                       res = false;
                       max = 100;
                       while ((!res) && (max != 0))  
                          {
                           res = OrderModify(OrderTicket(), OrderOpenPrice(), 0, 0, 0, CLR_NONE);
                           res = GetLastError();
                           Sleep(1000);
                           max--;
                          }
                      }
                   else 
                      {
                       if ((OrderTicket() != LastBuy) && (OrderTicket() > LastLock))
                          {
                           res = false;
                           max = 100;
                           while ((!res) && (max != 0))  
                              {
                               res = OrderModify(OrderTicket(), OrderOpenPrice(), OrderStopLoss(), SellLimitPrice, 0, CLR_NONE);
                               res = GetLastError();
                               Sleep(1000);
                               max--;
                              }
                          }
                      }
                  }
              }
          }
      return(0);
     }
}

//+---------------------------+
//+  Это ЛОК                  +
//+---------------------------+
int Lock(){
  int cnt;
  double lotcnt;
  
  lotcnt = 0;
  for (cnt = OrdersTotal()-1;cnt <= 0;cnt--)
      {
       OrderSelect(cnt, SELECT_BY_POS, MODE_TRADES);
       if ((OrderSymbol() == Symbol()) && (OrderComment() != "LOCK"))
          {
           if (StateCur==1)
              {
               if (OrderType() == OP_SELL) {lotcnt = lotcnt + OrderLots();}
              }
          }
      }
}

//+++++++++++++++++++++++++++++++++++++++++++
// Считаем спред, определяем текущий шаг... +
//+++++++++++++++++++++++++++++++++++++++++++
bool SetFlags(){

  Spred = MarketInfo(Symbol(), MODE_SPREAD);
  if (Digits == 4) {Spred = Spred / 10000;}
  else if (Digits == 2) {Spred = Spred / 100;}
  AP = AllPresent();
  if (BuyCnt > SellCnt) {Step = BuyCnt;} else {Step = SellCnt;}
  Print ("Step=",Step);
  Print ("СРЕЗ. Margin=",AccountMargin()," FreeMargin=",AccountFreeMargin()," Balance=",AccountBalance()," Equity=",AccountEquity());
}

//+---------------------------+
//+ Собственно тело программы +
//+---------------------------+
int start(){
  int tp;

  SetFlags();
  if (First()) {Initialization();}
  if (AP) {return (0);}
  tp = TakeProfit();
  PrSt(1); Print ("tp=", tp);
  if (tp == 0) {return(0);}
  SearchLastSellBuy();
  PrSt(2); Print ("LastSell=", LastSell, "  LastBuy=", LastBuy);
  LockSearch();
  PrSt(3); Print ("LastLock=", LastLock);
  OrderSelect(tp, SELECT_BY_TICKET);
  StateOld = StateCur;
  OldPrice = CurrentPrice;
  if (OrderType() == OP_BUY) StateCur = 1;
  else if (OrderType() == OP_SELL) StateCur = -1;
  CurrentPrice = OrderTakeProfit();
  PrSt(4); Print ("CurrentPrice=", CurrentPrice);
  
  DelAll = DelNotNeed();
  PrSt(5); Print ("DelNotNeed()");
  if (StateCur == 1) {CalcAllPrice(CurrentPrice);}
  if (StateCur == -1) {CalcAllPrice(CurrentPrice-Spred);}

  if (Step < (Limit + 1))
     {
      MoveTP(false);
      if (StateCur == 1) {SetAll = SetOrders (LotSize(1), LotSize(Step), LotSize(1), LotSize(1));}
      if (StateCur == -1) {SetAll = SetOrders (LotSize(1), LotSize(1), LotSize(Step), LotSize(1));}
     }
  if (Step == (Limit + 1))
     {
      MoveTP(false);
      if (StateCur == 1) {
                          OpenOrder (Symbol(), OP_BUYSTOP, LotSize(Step), BuyStopPrice, 3, 0, 0, "LOCK", 1001001, 0, Green);
                          SetAll = SetOrders (LotSize(1), LotSize(1), LotSize(1), LotSize(1));
                         }
      if (StateCur == -1) {
                           OpenOrder (Symbol(), OP_SELLSTOP, LotSize(Step), SellStopPrice, 3, 0, 0, "LOCK", 1001001, 0, Red);
                           SetAll = SetOrders (LotSize(1), LotSize(1), LotSize(1), LotSize(1));
                          }
     }
  if (Step > (Limit+1))
     { 
      Step=1;
      MoveTP(true);
      if (StateCur == 1) {SetAll = SetOrders (LotSize(1), LotSize(Step), LotSize(1), LotSize(1));}
      if (StateCur == -1) {SetAll = SetOrders (LotSize(1), LotSize(1), LotSize(Step), LotSize(1));}
     }
  PrSt(7);
  Print ("После. Margin=",AccountMargin()," FreeMargin=",AccountFreeMargin()," Balance=",AccountBalance()," Equity=",AccountEquity());
  return (0);
}

Forex Trader 2005.12.26 03:23 #1

А причем здесь код, если ордер таки выставляется? Смотри журнал, может у тебя в это время был сбой по связи? Или денег не было в достатке.

Forex Trader 2005.12.26 09:31 #2

Связь не причем. Ошибка в тестере. Бабласа в достатке. Депозит 100000, Lot=0.1
Всёже есть наверно е зависимость от кода какая-то. Я не первый раз с таким сталкиваюсь в своих экспертах.
Скорее всего что-то я гдето не учитываю каких-то тонкостей MQ4. Просто я RickD заказал то-же самое. Он написал по своему. Я прогнал его версию на том-же месте и всё ок. Значит дело где-то в методе запрограммирования процесса. Вот я и прошу, чтобы господа ШАРЯЩИЕ помогли разобраться. Если очень длиный код, то я могу выложить по проще и по короче.

[АРХИВ] Любой вопрос новичка, Почему эксперт на демо Возобновляемые ордера.

MetaQuotes 2005.12.26 12:54 #3

Для начала проверяйте все вызовы OrderSelect();

Forex Trader 2005.12.26 21:00 #4

Для начала проверяйте все вызовы OrderSelect();

Прости пожалуйста, что конкретно мне проверять в этих вызовах, нет ли ошибки при отработке?

Новый комментарий