//+------------------------------------------------------------------+
//|                                              Система_Черепах.mq4 |
//|                                      Copyright © 2012, PMN Trade |
//|                                          http://www.pmntrades.ru |
//+------------------------------------------------------------------+

#property copyright "Copyright © 2012, PMN Trade"
#property link      "http://pmntrade.ru"


/////////////////////////
// Пользовательские переменные
/////////////////////////
extern ENUM_TIMEFRAMES Work = PERIOD_M15;
extern bool       closedonch         = true; //закрыть по касанию быстрого канала
extern string _1                     = "Установки индикаторов";
extern int        Период_красного_канала = 10; // Период быстрого канала
extern double     Корр_ширины_красного_канала = 0.0; // Корреция ширины быстрого канала
extern int        Период_зелёного_канала  = 20; // Период зелёного канала
extern double     Корр_ширины_зелёного_канала = 0.0; // Корреция ширины зелёного канала
extern int        Период_синего_канала = 55; // Период синего канала
extern double     Корр_ширины_синего_канала = 0.0; // Корреция ширины синего канала
extern int        Период_АТР = 0; // Период расчёта среднего истинного диапазона (Average True Range)
                                    // 0-метод Уайлдера; любое полож.число-классический метод

extern string _2                    = "Установки ордеров";
extern int        Магик_номер          = 20120201; // Уникальный (магик) номер ордера

extern string _3                    = "Установки манименеджмента";
extern double     Количество_лотов = 1; // Количество лотов при ручном вводе лотов
extern bool       Авторасчёт_лотов = true; // Включение автоматического расчёта лота на основе ATR
extern double     Выделенные_средства = 1000; // Размер выделенных средств
extern double     Процент_риска = 2; // Риск в процентах от свободных средств

extern string _4                     = "Установки выхода из позиции";
extern double     СтопЛосс_в_АТР = 2; // Определение размера для выхода с убытком (1N = ATR = Процент_риска)
extern double     СтопЛосс_в_барах = 0; // Количество баров, необходимое для удержания позиции
extern double     ТейкПрофит_в_АТР = 0; // Определение размера для фиксации прибыли (1N = ATR = Процент_риска)

extern string _5                     = "Установки пропуска сделок";
extern bool       Пропуск_после_прибыльной = true; // Пропускать сделки после прибыльной сделки
extern bool       Пропуск_после_убыточной = false; // Пропускать сделки после убыточной сделки

extern string _6                     = "Установки фильтра входа в покупку после продажи и наоборот";
extern bool       Фильтр_ПокупкаПродажа  = false; // Фильтр входа в покупку после продажи и наоборот,
                                              // вход в продажу только после покупки.

extern string _7                     = "Установки фильтра входа Moving Average";
extern bool       Фильтр_MA = false; // Фильтр входа по двум средним скользящим
extern int        Период_быстрой_MA = 100; // Период быстрой средней скользящей (используется для Фильтр_MA)
extern int        Период_медленной_MA = 200; // Период медленной средней скользящей (используется для Фильтр_MA)

extern string _8                     = "Установки фильтра входа по времени";
extern bool       Фильтр_времени_работы = false; // Фильтр входа по времени
extern string     Время_начала_работы = "10:05"; // Время начала работы системы
extern string     Время_окончания_работы = "18:50"; // Время окончания работы системы (поддержка открытых сделок продолжается)

//extern string _9                    = "Установки вывода комментариев";
//extern bool       Вывод_комментариев = false; // Вывод комментариев на график

extern string q6="Параметры трала";
extern bool   TralMode   = True;          // Использование трала
extern bool    TralType = True;               //Тип трала 1-Простой 2 - по АТР
extern bool   TralProfitOnly = false;           // Тралить только профит
extern string q61="Параметры обычного трала";
extern int    TralBuySize    = 1000;            // Размер трала в пунктах для покупок
extern int    TralSellSize   = 1000;            // Размер трала в пунктах для продаж
extern int    TrailStep = 30;             // Шаг трала в пунктах
extern string q62="Параметры трала по ATR";
extern   int      ATR_T_1 = 5;      // период первого ATR
extern   int      ATR_Sh_1 = 1;     // сдвиг первого ATR
extern   int      ATR_T_2 = 36;     // период второго ATR
extern   int      ATR_Sh_2 = 1;     // сдвиг второго ATR
extern   double   ATR_X = 1;        // коэффициент, на который множим ATR, чтобы получить стоплосс (при ATR_X=1 стоп будер размещен на расстоянии в 1 ATR, при ATR_X=1.5 - на расстоянии в полтора ATR и т.д.)
extern   int      ATR_Step = 3;     // шаг изменения стопа

extern int Repids=3;             //колличество повторов

/////////////////////////
// Внутренние переменные (общие)
/////////////////////////

//---- общие переменные
int i, n;
int Spread;
double TickValue, MinLot, MaxLot, LotsDigits;

//---- переменные индикаторов
double RedChannelHiger, RedChannelLower, GreenChannelHiger, GreenChannelLower, BlueChannelHiger, BlueChannelLower, ATR;

//---- переменные ордеров
int Operation;
uchar OpenBuy, OpenSell, BuyLimit, BuyStop, SellLimit, SellStop;
double BuySLPrice, BuyTPPrice, BuyStopOPPrice, BuyStopSLPrice, BuyStopTPPrice, BuyLimitOPPrice, BuyLimitSLPrice, BuyLimitTPPrice;
double SellSLPrice, SellTPPrice, SellStopOPPrice, SellStopSLPrice, SellStopTPPrice, SellLimitOPPrice, SellLimitSLPrice, SellLimitTPPrice;
string CommentOrder = "DonchianEA";

//---- переменные функции вывода информации на график
string InfoParametrs, InfoLots, ErrorsList;


/////////////////////////
// Инициализация
/////////////////////////

int init()
 {
  Spread = MarketInfo(Symbol(),MODE_SPREAD);
  TickValue = MarketInfo(Symbol(),MODE_TICKVALUE);
  MinLot = MarketInfo(Symbol(),MODE_MINLOT);
  MaxLot = MarketInfo(Symbol(),MODE_MAXLOT);
  if (MinLot == 1) LotsDigits = 0;
  if (MinLot == 0.1) LotsDigits = 1;
  if (MinLot == 0.01) LotsDigits = 2;
  return(0);
 }

/////////////////////////
// Деинициализация
/////////////////////////

int deinit()
 {
  return(0);
 }


double LotsOptimized(double _equity, double _risk, double _opprice, double _slprice)
 {
  if (Авторасчёт_лотов)
  {
   if (MathAbs(_opprice - _slprice) != 0)
   {
    //ОКРВНИЗ((Средства / 100 * Риск в %)  /  (ABS(Цена открытия - Цена стоп-лосса) / Минимальный размер тика * Стоимость тика))
    //Print("MathAbs(_opprice - _slprice)=",MathAbs(_opprice - _slprice));
    Print("Point * TickValue=",Point * TickValue);
    double _lots = NormalizeDouble((_equity / 100 * _risk) / (MathAbs(_opprice - _slprice) / Point * TickValue), LotsDigits);
   }
  }
  else _lots = Количество_лотов;  
  if(_lots > MaxLot) _lots = MaxLot;
  if(_lots < MinLot) _lots = MinLot;
  return(_lots);
 }


int start()
 {
   long tick_volume = iVolume(NULL,PERIOD_M1, 0);
   if(tick_volume > 1.0) return(0);
   
/////////////////////////
// Получение данных из индикаторов
/////////////////////////
   if (TralMode   == True) 
      {
      if (TralType == True) SimpleTral();
      if (TralType == False) TralByATR();
      }
  RedChannelHiger = NormalizeDouble(iCustom(NULL, Work, "Канал_Дончиана", Период_красного_канала, Корр_ширины_красного_канала, 1, 1), Digits);
  RedChannelLower = NormalizeDouble(iCustom(NULL, Work, "Канал_Дончиана", Период_красного_канала, Корр_ширины_красного_канала, 0, 1), Digits);
  GreenChannelHiger = NormalizeDouble(iCustom(NULL, Work, "Канал_Дончиана", Период_зелёного_канала, Корр_ширины_зелёного_канала, 1, 1), Digits);
  GreenChannelLower = NormalizeDouble(iCustom(NULL, Work, "Канал_Дончиана", Период_зелёного_канала, Корр_ширины_зелёного_канала, 0, 1), Digits);
//  BlueChannelHiger = NormalizeDouble(iCustom(NULL, Work, "Канал_Дончиана", Период_синего_канала, Корр_ширины_синего_канала, 1, 1), Digits);
//  BlueChannelLower = NormalizeDouble(iCustom(NULL, Work, "Канал_Дончиана", Период_синего_канала, Корр_ширины_синего_канала, 0, 1), Digits);
                                                    
  if (Период_АТР == 0)
  {
   ATR = (NormalizeDouble(iATR(NULL, Work, 1, 2), Digits) * 19 + NormalizeDouble(iATR(NULL, 0, 1, 1), Digits)) / 20;
  }
  else
  {
   ATR = NormalizeDouble(iATR(NULL, Work, Период_АТР, 1), Digits);
  }


/////////////////////////
// Определение цен
/////////////////////////
   
  BuySLPrice       = NormalizeDouble(RedChannelLower - 1 * Point, Digits);
  BuyStopOPPrice   = NormalizeDouble(GreenChannelHiger + 1 * Point, Digits);
  BuyStopSLPrice   = NormalizeDouble(RedChannelLower - 1 * Point, Digits);
  BuyStopTPPrice   = 0;
   
  SellSLPrice      = NormalizeDouble(RedChannelHiger + 1 * Point, Digits);
  SellStopOPPrice  = NormalizeDouble(GreenChannelLower - 1 * Point, Digits);
  SellStopSLPrice  = NormalizeDouble(RedChannelHiger + 1 * Point, Digits);
  SellStopTPPrice  = 0;


/////////////////////////
// Фильтр входа по двум средним скользящим
/////////////////////////

  int DontBuy, DontSell;
  if (Фильтр_MA)
  {
   if (iMA(NULL,Work,Период_быстрой_MA,0,MODE_SMA,PRICE_CLOSE,0) > iMA(NULL,Work,Период_медленной_MA,0,MODE_SMA,PRICE_CLOSE,0)) DontSell = 1;
   if (iMA(NULL,Work,Период_быстрой_MA,0,MODE_SMA,PRICE_CLOSE,0) < iMA(NULL,Work,Период_медленной_MA,0,MODE_SMA,PRICE_CLOSE,0)) DontBuy = 1;
  }



/////////////////////////
// Фильтр входа по времени
/////////////////////////

  if (Фильтр_времени_работы)
  {
   if (!(StrToTime(Время_начала_работы) <= TimeCurrent() && TimeCurrent() <= StrToTime(Время_окончания_работы)))
   {
    DontBuy = 1;
    DontSell = 1;
   }
  }


/////////////////////////
// Фильтр выхода по времени (тайм-аут)
/////////////////////////

  if (СтопЛосс_в_барах > 0)
  {
   //определение времени открытия сделки
   for (i = OrdersTotal(); i >= 0; i--)
   {
    OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
    if (OrderSymbol() == Symbol() && OrderMagicNumber() == Магик_номер)
    {
     if (OrderType() == OP_BUY || OrderType() == OP_SELL)
     {
      break;
     }
    }
   }
    
   //определение количества баров, прошедших с момента открытия
   for (n = 0; n < Bars; n++)
   {
    if (OrderOpenTime() >= iTime(NULL, 0, n))
    {
     break;
    }
   }
    
   //закрытие сделки, если количество баров больше или равно отведённому
   if (n >= СтопЛосс_в_барах)
   {
    if (OrderType() == OP_BUY)
    {
     OrderClose(OrderTicket(), OrderLots(), Bid, 5, Red);
    }
    if (OrderType() == OP_SELL)
    {
     OrderClose(OrderTicket(), OrderLots(), Ask, 5, Red);
    }
   }
  }
  
// закрытие ордера по касанию быстрого канала

   if(closedonch) {
      for (i = OrdersTotal(); i >= 0; i--)
   {
    OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
    if (OrderSymbol() == Symbol() && OrderMagicNumber() == Магик_номер)
    {
     if (OrderType() == OP_BUY)
     {
     if (Bid < RedChannelLower) {OrderClose(OrderTicket(), OrderLots(), Bid, 5, Red);}
     }
      if (OrderType() == OP_SELL)
     {
     if (Bid > RedChannelHiger) {OrderClose(OrderTicket(), OrderLots(), Ask, 5, Red);}
     }
    }
   }
    
   } 

//корректировка стоп-лосса
  if (СтопЛосс_в_АТР > 0)
  {
   BuyStopSLPrice   = NormalizeDouble(BuyStopOPPrice - ATR * СтопЛосс_в_АТР, Digits);
   SellStopSLPrice  = NormalizeDouble(SellStopOPPrice + ATR * СтопЛосс_в_АТР, Digits);
   for(i = 0; i < OrdersTotal(); i++)
   {
    OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
    if (OrderSymbol() == Symbol() && OrderMagicNumber() == Магик_номер)
    {
     if (OrderType() == OP_BUY)
     {
      //if (BuySLPrice < NormalizeDouble(OrderOpenPrice(), Digits)) BuySLPrice = NormalizeDouble(OrderOpenPrice() - ATR * СтопЛосс_в_АТР, Digits); //выход по красному каналу только с прибылью
      if (BuySLPrice < NormalizeDouble(OrderOpenPrice() - ATR * СтопЛосс_в_АТР, Digits)) BuySLPrice = NormalizeDouble(OrderOpenPrice() - ATR * СтопЛосс_в_АТР, Digits);
      //if (BuySLPrice > OrderOpenPrice() - MarketInfo(Symbol(),MODE_STOPLEVEL) * Point) BuySLPrice = OrderOpenPrice() - MarketInfo(Symbol(),MODE_STOPLEVEL) * Point;
     }
     if (OrderType() == OP_BUYSTOP)
     {
      //if (BuyStopSLPrice < NormalizeDouble(BuyStopOPPrice, Digits)) BuyStopSLPrice   = NormalizeDouble(BuyStopOPPrice - ATR * СтопЛосс_в_АТР, Digits); //выход по красному каналу только с прибылью
      if (BuyStopSLPrice < NormalizeDouble(BuyStopOPPrice - ATR * СтопЛосс_в_АТР, Digits)) BuyStopSLPrice = NormalizeDouble(BuyStopOPPrice - ATR * СтопЛосс_в_АТР, Digits);
      if (BuyStopSLPrice > BuyStopOPPrice - MarketInfo(Symbol(),MODE_STOPLEVEL) * Point) BuyStopSLPrice = BuyStopOPPrice - MarketInfo(Symbol(),MODE_STOPLEVEL) * Point;
     }
     if (OrderType() == OP_SELL)
     {
      //if (SellSLPrice > NormalizeDouble(OrderOpenPrice(), Digits)) SellSLPrice = NormalizeDouble(OrderOpenPrice() + ATR * СтопЛосс_в_АТР, Digits); //выход по красному каналу только с прибылью
      if (SellSLPrice > NormalizeDouble(OrderOpenPrice() + ATR * СтопЛосс_в_АТР, Digits)) SellSLPrice = NormalizeDouble(OrderOpenPrice() + ATR * СтопЛосс_в_АТР, Digits);
      //if (SellSLPrice < OrderOpenPrice() + MarketInfo(Symbol(),MODE_STOPLEVEL) * Point) SellSLPrice = OrderOpenPrice() + MarketInfo(Symbol(),MODE_STOPLEVEL) * Point;
     }
     if (OrderType() == OP_SELLSTOP)
     {
      //if (SellStopSLPrice > NormalizeDouble(SellStopOPPrice, Digits)) SellStopSLPrice = NormalizeDouble(SellStopOPPrice + ATR * СтопЛосс_в_АТР, Digits); //выход по красному каналу только с прибылью
      if (SellStopSLPrice > NormalizeDouble(SellStopOPPrice + ATR * СтопЛосс_в_АТР, Digits)) SellStopSLPrice = NormalizeDouble(SellStopOPPrice + ATR * СтопЛосс_в_АТР, Digits);
      if (SellStopSLPrice < SellStopOPPrice + MarketInfo(Symbol(),MODE_STOPLEVEL) * Point) SellStopSLPrice = SellStopOPPrice + MarketInfo(Symbol(),MODE_STOPLEVEL) * Point;
     }
    }
   }
  }

//корректировка тейк-профита
  if (ТейкПрофит_в_АТР > 0 )
  {
   BuyStopTPPrice   = NormalizeDouble(BuyStopOPPrice + ATR * ТейкПрофит_в_АТР, Digits);
   SellStopTPPrice  = NormalizeDouble(SellStopOPPrice - ATR * ТейкПрофит_в_АТР, Digits);
   for(i = 0; i < OrdersTotal(); i++)
   {
    OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
    if (OrderSymbol() == Symbol() && OrderMagicNumber() == Магик_номер)
    {
     if (OrderType() == OP_BUY)
     {
      BuyTPPrice = NormalizeDouble(OrderOpenPrice() + ATR * ТейкПрофит_в_АТР, Digits);
      if (BuyTPPrice > OrderOpenPrice() - MarketInfo(Symbol(),MODE_STOPLEVEL) * Point) BuyTPPrice = OrderOpenPrice() - MarketInfo(Symbol(),MODE_STOPLEVEL) * Point;
     }
     if (OrderType() == OP_BUYSTOP)
     {
      if (BuyStopTPPrice > OrderOpenPrice() - MarketInfo(Symbol(),MODE_STOPLEVEL) * Point) BuyStopTPPrice = OrderOpenPrice() - MarketInfo(Symbol(),MODE_STOPLEVEL) * Point;
     }
     if (OrderType() == OP_SELL)
     {
      SellTPPrice = NormalizeDouble(OrderOpenPrice() - ATR * ТейкПрофит_в_АТР, Digits);
      if (SellStopTPPrice != 0 && SellStopTPPrice > OrderOpenPrice() - MarketInfo(Symbol(),MODE_STOPLEVEL) * Point) SellStopTPPrice = OrderOpenPrice() - MarketInfo(Symbol(),MODE_STOPLEVEL) * Point;
     }
     if (OrderType() == OP_SELLSTOP)
     {
      if (SellStopTPPrice > OrderOpenPrice() - MarketInfo(Symbol(),MODE_STOPLEVEL) * Point) SellStopTPPrice = OrderOpenPrice() - MarketInfo(Symbol(),MODE_STOPLEVEL) * Point;
     }
    }
   }
  }
  

/////////////////////////
// Работа с ордерами
/////////////////////////
//Print("BuySLPrice=", BuySLPrice, " SellSLPrice=", SellSLPrice);
//Print("SellSLPrice=", SellSLPrice, " SellStopOPPrice=", SellStopOPPrice, " SellStopSLPrice=", SellStopSLPrice, " SellStopTPPrice=", SellStopTPPrice);
//Print("BuySLPrice=", BuySLPrice, " BuyStopOPPrice=", BuyStopOPPrice, " BuyStopSLPrice=", BuyStopSLPrice, " BuyStopTPPrice=", BuyStopTPPrice);

// Скрипт корректировки ордеров
   for(i = 0; i < OrdersTotal(); i++)
   {
    OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
    if (OrderSymbol() == Symbol() && OrderMagicNumber() == Магик_номер)
    {
     if (OrderType() == OP_BUY)
     {
      if (NormalizeDouble(OrderStopLoss(), Digits) != BuySLPrice &&
          BuySLPrice < Bid - MarketInfo(Symbol(),MODE_STOPLEVEL) * Point)
      {
       //OrderModify(OrderTicket(),OrderOpenPrice(),BuySLPrice,OrderTakeProfit(),0,CLR_NONE);
      }
     }

     if (OrderType() == OP_BUYSTOP)
     {
      if ((NormalizeDouble(OrderOpenPrice(), Digits) != BuyStopOPPrice || NormalizeDouble(OrderStopLoss(), Digits) != BuyStopSLPrice || NormalizeDouble(OrderTakeProfit(), Digits) != BuyStopTPPrice) &&
          BuyStopOPPrice > Ask + MarketInfo(Symbol(),MODE_STOPLEVEL) * Point)
      {
       //OrderModify(OrderTicket(),BuyStopOPPrice,BuyStopSLPrice,BuyStopTPPrice,0,CLR_NONE);
      }
      Количество_лотов = LotsOptimized(Выделенные_средства, Процент_риска, OrderOpenPrice(), BuyStopSLPrice);
      if (Количество_лотов != OrderLots() && SellStopOPPrice < BuyStopOPPrice > Ask + MarketInfo(Symbol(),MODE_STOPLEVEL) * Point)
      {
       OrderDelete(OrderTicket(),CLR_NONE);
      }
     }

     if (OrderType() == OP_SELL)
     {
      if (NormalizeDouble(OrderStopLoss(), Digits) != SellSLPrice &&
          SellSLPrice > Ask + MarketInfo(Symbol(),MODE_STOPLEVEL) * Point)
      {
       //OrderModify(OrderTicket(),OrderOpenPrice(),SellSLPrice,OrderTakeProfit(),0,CLR_NONE);
      }
     }

     if (OrderType() == OP_SELLSTOP)
     {
      if ((NormalizeDouble(OrderOpenPrice(), Digits) != SellStopOPPrice || NormalizeDouble(OrderStopLoss(), Digits) != SellStopSLPrice || NormalizeDouble(OrderTakeProfit(), Digits) != SellStopTPPrice) &&
          SellStopOPPrice < Bid - MarketInfo(Symbol(),MODE_STOPLEVEL) * Point)
      {
      // OrderModify(OrderTicket(),SellStopOPPrice,SellStopSLPrice,SellStopTPPrice,0,CLR_NONE);
      }
      Количество_лотов = LotsOptimized(Выделенные_средства, Процент_риска, OrderOpenPrice(), SellStopSLPrice);
      if (Количество_лотов != OrderLots() && SellStopOPPrice < Bid - MarketInfo(Symbol(),MODE_STOPLEVEL) * Point)
      {
       OrderDelete(OrderTicket(),CLR_NONE);
      }
     }
    }
   }

  OpenBuy = 0;
  BuyStop = 0;
  BuyLimit = 0;
  OpenSell = 0;
  SellStop = 0;
  SellLimit = 0; 

// Скрипт расчёта ордеров
   for(i = 0; i < OrdersTotal(); i++)
   {
    OrderSelect(i,SELECT_BY_POS,MODE_TRADES);
    if (OrderSymbol() == Symbol() && OrderMagicNumber() == Магик_номер)
    {
     if (OrderType() == OP_BUY)
     {
      OpenBuy = OpenBuy+1;
     }

     if (OrderType() == OP_BUYSTOP)
     {
      BuyStop = BuyStop+1;
     }

     if (OrderType() == OP_SELL)
     {
      OpenSell = OpenSell+1;
     }

     if (OrderType() == OP_SELLSTOP)
     {
      SellStop = SellStop+1;
     }
    }
   }
   
if(!IsTradeContextBusy()) {
   Comment(BuyStop,"\n", SellStop,"\n",OpenSell,"\n",OpenBuy);
   if ( BuyStop <= 4 && OpenBuy <= 4 && Bid < GreenChannelHiger - 0.0005)
   {
    Количество_лотов = LotsOptimized(Выделенные_средства, Процент_риска, BuyStopOPPrice, BuyStopSLPrice);
    OrderSend(Symbol(),OP_BUYSTOP,Количество_лотов,BuyStopOPPrice,3,BuyStopSLPrice,BuyStopTPPrice,CommentOrder,Магик_номер,0,Blue);
   
   }

   if (SellStop <= 4 && OpenSell <= 4 && Bid > GreenChannelLower + 0.0005)
   {
    Количество_лотов = LotsOptimized(Выделенные_средства, Процент_риска, SellStopOPPrice, SellStopSLPrice);
    OrderSend(Symbol(),OP_SELLSTOP,Количество_лотов,SellStopOPPrice,3,SellStopSLPrice,SellStopTPPrice,CommentOrder,Магик_номер,0,Red);
   }
   }
  


/////////////////////////
// Вывод данных на график
/////////////////////////
   
//   if (Вывод_комментариев)
//   {
           
 //  Comment(
 //         );
 //  }
  return(0);
 }//+--------------------Трал позиций------------------------------------------------+

void SimpleTral() // Это обычный трал позиции
   {
   int i, k;//объявляем переменные цикла
   for (i=0; i<OrdersTotal(); i++) //начинаем перебирать ордера
      {
      if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) //выбираем ордер
         {
         if (OrderSymbol()==Symbol() && OrderMagicNumber()==Магик_номер) //проверяем наш ли он
            {
            if (OrderType()==OP_BUY) //На покупку ли ордер
               {
               if (TralProfitOnly==False || Bid-OrderOpenPrice()>TralBuySize*Point) //какой выбран режим трала
                  {
                  if (OrderStopLoss()<Bid-(TralBuySize+TrailStep-1)*Point || OrderStopLoss()==0)//прошел ли расстояние в условиях трала 
                     {
                     for (k=1;k<Repids;k++)//защита от зацикливания
                        {
                        if (OrderModify(OrderTicket(), OrderOpenPrice(), Bid-TralBuySize*Point, OrderTakeProfit(), 0, NULL)) break;//если оттралили то выход
                        Sleep(1);//если нет то подождем
                        }
                     }
                  }
               }
            if (OrderType()==OP_SELL) //на Продажу Ли ордер
               {
               if (TralProfitOnly==False || OrderOpenPrice()-Ask>TralSellSize*Point) //какой выбран режим трала
                  {
                  if (OrderStopLoss()>Ask+(TralSellSize+TrailStep+1)*Point || OrderStopLoss()==0) //прошел ли расстояние в условиях трала 
                     {
                     for (k=1;k<Repids;k++)//защита от зацикливания
                        {
                        if (OrderModify(OrderTicket(), OrderOpenPrice(), Ask+TralSellSize*Point, OrderTakeProfit(), 0, NULL)) break;//если оттралили то выход
                        Sleep(1);//если нет то подождем
                        }
                     }
                  }
               }
            }
         }
      }
   return;//выход
   }// ---------------------Конец функции трала позиции------------------------------------
void TralByATR()//это режим трала по АТР
   {      
   if (ATR_T_1<1 || ATR_T_2<1 || ATR_X<=0)//проверяем все ли пораметры указаны правильно
      {
      Print("Трейлинг ATR непашет из-за неправильных параметров");//если нет то сообщим альтернативно одаренным
      return;//выйдем от греха
      }
   double Val_ATR1, Val_ATR2, ATR_On_X, New_Stop_First, New_Stop_Second; //объявим нужные переменные
   Val_ATR1 = iATR(Symbol(),Work,ATR_T_1,ATR_Sh_1);//получим первое значение АТР
   Val_ATR2 = iATR(Symbol(),Work,ATR_T_2,ATR_Sh_2);//получим второе значение АТР
   ATR_On_X = MathMax(Val_ATR1,Val_ATR2) * ATR_X;//максимальное из них помножим на множитель
   int i, k;//объявим переменные циклов
   for (i=0; i<OrdersTotal(); i++) //начнем перебирать ордера
      {
      if (OrderSelect(i, SELECT_BY_POS, MODE_TRADES)) //выбираем ордер
         {
         if (OrderSymbol()==Symbol() && OrderMagicNumber()==Магик_номер) //проверяем наш ли он
            {
            if (OrderType()==OP_BUY) //На покупку ли он
               {   
               New_Stop_First = NormalizeDouble(Bid - ATR_On_X,Digits); //расчитываем Стоп
               New_Stop_Second = NormalizeDouble(New_Stop_First - ATR_Step*Point,Digits);//Добавляем к нему еще и шаг
               if (TralProfitOnly==False || OrderOpenPrice()<New_Stop_First) //проверяем режим ТРала
                  {
                  if (OrderStopLoss()<New_Stop_Second || OrderStopLoss()==0) //проверяем пора ли тралить позицию
                     {
                     for (k=1;k<Repids;k++)//защита от зацикливания
                        {
                        if (OrderModify(OrderTicket(), OrderOpenPrice(), New_Stop_First, OrderTakeProfit(), 0, NULL)==true) break;//если оттраллили то выход
                        Print ("Оттраллино по АТР");
                        Sleep(1);//если нет то ждем
                        }
                     }
                  }
               }
            if (OrderType()==OP_SELL) //На продажу ли он
               {  
               New_Stop_First = NormalizeDouble(Ask + ATR_On_X,Digits);//расчитываем Стоп
               New_Stop_Second = NormalizeDouble(New_Stop_First + ATR_Step*Point,Digits); //Добавляем к нему еще и шаг
               if (TralProfitOnly==False || OrderOpenPrice()>New_Stop_First) //проверяем режим ТРала
                  {
                  if (OrderStopLoss()>New_Stop_Second || OrderStopLoss()==0) //проверяем пора ли тралить позицию
                     {
                     for (k=1;k<Repids;k++)//защита от зацикливания
                        {
                        if (OrderModify(OrderTicket(), OrderOpenPrice(), New_Stop_First, OrderTakeProfit(), 0, NULL)==true) break;//если оттраллили то выход
                        Print ("Оттраллино по АТР");
                        Sleep(1);//если нет то ждем
                        }
                     }
                  }
               }
            }
         }
      }
   return;
   }