Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-05-13· OpenAIAi2 WildChat-4.8M (AI2)

//±-----------------------------------------------------------------+ // MAA.mq5 //…

  1. User

    //±-----------------------------------------------------------------+ //| MAA.mq5 | //| Copyright 2024, MetaQuotes Ltd. | //| https://www.mql5.com | //±-----------------------------------------------------------------+ #property copyright "Copyright 2024, MetaQuotes Ltd." #property link "https://www.mql5.com" #property version "1.00" #property indicator_separate_window #property indicator_buffers 6 #property indicator_plots 5

    // Plot settings for MA difference #property indicator_label1 "MADiff" #property indicator_type1 DRAW_LINE #property indicator_color1 clrRed #property indicator_style1 STYLE_SOLID #property indicator_width1 1

    // Plot settings for Mean + StdDev #property indicator_label2 "Mean + StdDev" #property indicator_type2 DRAW_LINE #property indicator_color2 clrGreen #property indicator_style2 STYLE_DOT #property indicator_width2 1

    // Plot settings for Mean - StdDev #property indicator_label3 "Mean - StdDev" #property indicator_type3 DRAW_LINE #property indicator_color3 clrGreen #property indicator_style3 STYLE_DOT #property indicator_width3 1

    // Plot settings for Mean + 2StdDev #property indicator_label4 "Mean + 2StdDev" #property indicator_type4 DRAW_LINE #property indicator_color4 clrBlue #property indicator_style4 STYLE_DASH #property indicator_width4 1

    // Plot settings for Mean - 2StdDev #property indicator_label5 "Mean - 2StdDev" #property indicator_type5 DRAW_LINE #property indicator_color5 clrBlue #property indicator_style5 STYLE_DASH #property indicator_width5 1

    // Input parameters int PeriodForStats(ENUM_TIMEFRAMES tf) { switch(tf) { case PERIOD_M1 : return 10; case PERIOD_M5 : return 10; case PERIOD_M15 : return 588; case PERIOD_M30 : return 294; case PERIOD_H1 : return 147; case PERIOD_H4 : return 42; case PERIOD_D1 : return 1610; case PERIOD_W1 : return 230; case PERIOD_MN1 : return 124; default : return 14; // Default period } }

    input int periodM1 = 10; input int periodM5 = 10; input int periodM15 = 84; input int periodM30 = 42; input int periodH1 = 21; input int periodH4 = 6; input int periodD1 = 252; input int periodW1 = 55; input int periodMN1 = 12;

    // Indicator buffers double MAaBuffer[]; double MADiffBuffer[]; double MeanPlusStdDevBuffer[]; double MeanMinusStdDevBuffer[]; double MeanPlus2StdDevBuffer[]; double MeanMinus2StdDevBuffer[];

    // Define periods for different timeframes int PeriodForTimeframe(ENUM_TIMEFRAMES tf) { switch(tf) { case PERIOD_M1 : return periodM1; case PERIOD_M5 : return periodM5; case PERIOD_M15 : return periodM15; case PERIOD_M30 : return periodM30; case PERIOD_H1 : return periodH1; case PERIOD_H4 : return periodH4; case PERIOD_D1 : return periodD1; case PERIOD_W1 : return periodW1; case PERIOD_MN1 : return periodMN1; default : return 14; // Default period } }

    // Current period based on timeframe int period; int periodForStats;

    //±-----------------------------------------------------------------+ //| Custom indicator initialization function | //±-----------------------------------------------------------------+ int OnInit() { // Indicator buffers mapping SetIndexBuffer(0, MADiffBuffer, INDICATOR_DATA); SetIndexBuffer(5, MAaBuffer, INDICATOR_CALCULATIONS); SetIndexBuffer(1, MeanPlusStdDevBuffer, INDICATOR_DATA); SetIndexBuffer(2, MeanMinusStdDevBuffer, INDICATOR_DATA); SetIndexBuffer(3, MeanPlus2StdDevBuffer, INDICATOR_DATA); SetIndexBuffer(4, MeanMinus2StdDevBuffer, INDICATOR_DATA);

    // Initialization done return(INIT_SUCCEEDED); }

    //±-----------------------------------------------------------------+ //| Custom indicator iteration function | //±-----------------------------------------------------------------+ int OnCalculate(const int rates_total, const int prev_calculated, const datetime &time[], const double &open[], const double &high[], const double &low[], const double &close[], const long &tick_volume[], const long &volume[], const int &spread[]) { // Adjust the period dynamically if needed period = PeriodForTimeframe(Period()); periodForStats = PeriodForStats(Period());

    // Check if there are enough bars for calculation if(rates_total < period || rates_total < periodForStats) return 0;

    // Starting point for calculation int start = prev_calculated > 0 ? prev_calculated - 1 : period - 1;

    // Calculate moving average and MADiff for(int i = start; i < rates_total; i++) { double sum = 0.0; for(int j = 0; j < period; j++) { sum += close[i - j]; } MAaBuffer[i] = sum / period; MADiffBuffer[i] = -((MAaBuffer[i] - close[i]) / close[i]) * 100; }

    double stddev = 0.0; double mean = 0.0;

    // Calculate mean and standard deviation for MADiffBuffer for(int i = start; i < rates_total; i++) { if(i >= periodForStats - 1) { double mean_sum = 0.0; double stddev_sum = 0.0;

         // Calculate mean over the periodForStats
         for(int j = 0; j < periodForStats; j++)
           {
            mean_sum += MADiffBuffer[i - j];
           }
         mean = mean_sum / periodForStats;
    
         // Calculate standard deviation over the periodForStats
         for(int j = 0; j < periodForStats; j++)
           {
            stddev_sum += MathPow(MADiffBuffer[i - j] - mean, 2);
           }
         stddev = MathSqrt(stddev_sum / periodForStats);
        }
     }
     
    

    for(int i = period - 1; i < rates_total; i++) { // Populate buffer values MeanPlusStdDevBuffer[i] = mean + stddev; MeanMinusStdDevBuffer[i] = mean - stddev; MeanPlus2StdDevBuffer[i] = mean + 2 * stddev; MeanMinus2StdDevBuffer[i] = mean - 2 * stddev; }

    Comment(StringFormat("Mean: %.5f, StdDev: %.5f, MA Period: %d, Stats Period: %d", mean, stddev, period, periodForStats));

    // Return value of prev_calculated for next call return rates_total; } //±-----------------------------------------------------------------+ //+------------------------------------------------------------------+ у меня есть такой индикатор мне нужен советник который будет заходить в sell если цена выше линии MeanPlus2StdDevBuffer и в buy если цена ниже н

  2. Assistant

    Для создания советника (Expert Advisor) на основе вашего индикатора, нам потребуется использовать значения буферов индикатора внутри советника и задать условия для входа в сделки. Ниже представлен пример кода совеника на языке MQL5, который реализует выполнение продаж (sell), если цена выше линии MeanPlus2StdDevBuffer и покупок (buy), если цена ниже линии MeanMinus2StdDevBuffer.

    Создадим файл MyExpertAdvisor.mq5:

    //+------------------------------------------------------------------+
    //|                                                    MyExpertAdvisor.mq5 |
    //|                   © 2024 Ваше имя                                  |
    //|                                                                  |
    //+------------------------------------------------------------------+
    #property strict
    #include <Trade\Trade.mqh>
    
    // Инстанс торгового объекта
    CTrade trade;
    
    // Индикаторные хэндлы
    int handleMAA;
    
    // Буферы для индикатора
    double meanPlus2StdDev[];
    double meanMinus2StdDev[];
    
    // Период для обратного пересчета буферов индикатора
    int BarsToCalculate = 100;
    
    //+------------------------------------------------------------------+
    //| Expert initialization function                                   |
    //+------------------------------------------------------------------+
    int OnInit()
      {
       // Параметры индикатора
       const string indicator_name = "MAA";
       const int period = 14;
    
       // Создаем хэндл для индикатора
       handleMAA = iCustom(_Symbol, PERIOD_CURRENT, indicator_name, period);
       if(handleMAA == INVALID_HANDLE)
         {
          Print("Error creating indicator handle: ", GetLastError());
          return INIT_FAILED;
         }
    
       // Устанавливаем размер буферов
       ArraySetAsSeries(meanPlus2StdDev, true);
       ArraySetAsSeries(meanMinus2StdDev, true);
    
       // Успешная инициализация
       return INIT_SUCCEEDED;
      }
    
    //+------------------------------------------------------------------+
    //| Expert deinitialization function                                 |
    //+------------------------------------------------------------------+
    void OnDeinit(const int reason)
      {
       // Удаляем хэндл индикатора
       IndicatorRelease(handleMAA);
      }
    
    //+------------------------------------------------------------------+
    //| Expert tick function                                             |
    //+------------------------------------------------------------------+
    void OnTick()
      {
       // Проверяем наличие индикаторного хэндла
       if(handleMAA == INVALID_HANDLE)
          return;
    
       // Получаем количество баров
       int bars = Bars(_Symbol, PERIOD_CURRENT);
    
       // Проверяем наличие достаточного количества баров для расчета
       if(bars < BarsToCalculate)
          return;
    
       // Копируем индикаторные буферы
       if(CopyBuffer(handleMAA, 3, 0, BarsToCalculate, meanPlus2StdDev) < 0 ||
          CopyBuffer(handleMAA, 4, 0, BarsToCalculate, meanMinus2StdDev) < 0)
         {
          Print("Error copying indicator buffer: ", GetLastError());
          return;
         }
    
       // Получаем текущую цену
       double price = iClose(_Symbol, PERIOD_CURRENT, 0);
    
       // Флаг позиции
       bool hasPosition = false;
    
       // Проверяем наличие открытой позиции
       for(int i = 0; i < OrdersTotal(); i++)
         {
          if(OrderSelect(i, SELECT_BY_POS) && OrderSymbol() == _Symbol)
            {
             hasPosition = true;
             break;
            }
         }
    
       // Условия для входа в сделки
       if(price > meanPlus2StdDev[0] && !hasPosition)
         {
          // Открываем позицию на продажу
          trade.Sell(0.1);
          Print("Sell Order placed at price: ", price);
         }
       else if(price < meanMinus2StdDev[0] && !hasPosition)
         {
          // Открываем позицию на покупку
          trade.Buy(0.1);
          Print("Buy Order placed at price: ", price);
         }
      }
    //+------------------------------------------------------------------+
    

    Этот код делает следующее:

    1. Создает хэндл для индикатора MAA и инициализирует буферы в функции OnInit.
    2. Освобождает ресурсы (удаляет хэндл для индикатора) в функции OnDeinit.
    3. Выполняет проверку на каждый тик рынка в функции OnTick.
    4. Копирует данные индикаторных буферов и проверяет, есть ли достаточно баров для корректной работы.
    5. Проверяет условия входа: цена выше значения MeanPlus2StdDevBuffer для продаж и ниже значения MeanMinus2StdDevBuffer для покупок. Открытие позиции выполняется только в случае, если на текущий момент нет открытых позиций.

    Этот советник базируется на предположении, что ваша стратегия в точности соответствует описанному правилу: вход в сделку происходит при пересечении ценовых уровней индикаторных линий. Вы можете настраивать дополнительные параметры, такие как объем лота, в структуре вызовов trade.Sell() и trade.Buy().

  3. User

    //+------------------------------------------------------------------+ //| ProjectName | //| Copyright 2020, CompanyName | //| http://www.companyname.net | //+------------------------------------------------------------------+ #property strict #include <Trade\Trade.mqh>

    // Инстанс торгового объекта CTrade trade; // Индикаторные хэндлы int handleMAA;

    // Буферы для индикатора double meanPlus2StdDev[]; double meanMinus2StdDev[];

    // Период для обратного пересчета буферов индикатора int BarsToCalculate = 100;

    //±-----------------------------------------------------------------+ //| Expert initialization function | //±-----------------------------------------------------------------+ int OnInit() { // Параметры индикатора const string indicator_name = "MAA"; const int period = 14;

    // Создаем хэндл для индикатора handleMAA = iCustom(_Symbol, PERIOD_CURRENT, indicator_name, period); if(handleMAA == INVALID_HANDLE) { Print("Error creating indicator handle: ", GetLastError()); return INIT_FAILED; }

    // Устанавливаем размер буферов ArraySetAsSeries(meanPlus2StdDev, true); ArraySetAsSeries(meanMinus2StdDev, true);

    // Успешная инициализация return INIT_SUCCEEDED; }

    //±-----------------------------------------------------------------+ //| Expert deinitialization function | //±-----------------------------------------------------------------+ void OnDeinit(const int reason) { // Удаляем хэндл индикатора IndicatorRelease(handleMAA); }

    //±-----------------------------------------------------------------+ //| Expert tick function | //±-----------------------------------------------------------------+ void OnTick() { // Проверяем наличие индикаторного хэндла if(handleMAA == INVALID_HANDLE) return;

    // Получаем количество баров int bars = Bars(_Symbol, PERIOD_CURRENT);

    // Проверяем наличие достаточного количества баров для расчета if(bars < BarsToCalculate) return;

    // Копируем индикаторные буферы if(CopyBuffer(handleMAA, 3, 0, BarsToCalculate, meanPlus2StdDev) < 0 || CopyBuffer(handleMAA, 4, 0, BarsToCalculate, meanMinus2StdDev) < 0) { Print("Error copying indicator buffer: ", GetLastError()); return; }

    // Получаем текущую цену double price = iClose(_Symbol, PERIOD_CURRENT, 0);

    // Флаг позиции bool hasPosition = false;

    // Проверяем наличие открытой позиции for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of current positions { if(m_position.SelectByIndex(i)) // selects the position by index for further access to its properties { if(m_position.Symbol()==m_symbol.Name()) { hasPosition = true; break; } } }

    // Условия для входа в сделки if(price > meanPlus2StdDev[0] && !hasPosition) { // Открываем позицию на продажу trade.Sell(0.1); Print("Sell Order placed at price: ", price); } else if(price < meanMinus2StdDev[0] && !hasPosition) { // Открываем позицию на покупку trade.Buy(0.1); Print("Buy Order placed at price: ", price); } } //±-----------------------------------------------------------------+

    //+------------------------------------------------------------------+ 'm_position' - undeclared identifier Exp_MAA.mq5 88 10 ';' - unexpected token Exp_MAA.mq5 92 31 expression not boolean Exp_MAA.mq5 92 25 '(' - unbalanced left parenthesis Exp_MAA.mq5 88 9 empty controlled statement found Exp_MAA.mq5 92 31

  4. Assistant

    Ошибки, о которых вы указали, связаны с неправильным использованием и недекларированием объекта m_position. Предполагается, что m_position принадлежит к классу CPositionInfo, который отвечает за доступ к информации о позициях. Также необходим объект символога для доступа к свойствам символов.

    Давайте исправим код, выполняя соответствующие исправления и добавляя необходимые объявления:

    1. Добавим объявление объектов CPositionInfo и CSymbolInfo.
    2. Перепишем функцию проверки наличия открытых позиций.
    3. Убедимся, что все структуры и синтаксис правильны и соответствуют стандартам MQL5.

    Исправленный код приведен ниже:

    //+------------------------------------------------------------------+
    //|                                                      ProjectName |
    //|                                      Copyright 2020, CompanyName |
    //|                                       http://www.companyname.net |
    //+------------------------------------------------------------------+
    #property strict
    #include <Trade\Trade.mqh>
    
    // Инстанс торгового объекта
    CTrade trade;
    // Объекты для получения информации о позициях и символах
    CPositionInfo m_position;
    CSymbolInfo m_symbol(_Symbol);
    
    // Индикаторные хэндлы
    int handleMAA;
    
    // Буферы для индикатора
    double meanPlus2StdDev[];
    double meanMinus2StdDev[];
    
    // Период для обратного пересчета буферов индикатора
    int BarsToCalculate = 100;
    
    //±-----------------------------------------------------------------+
    //| Expert initialization function                                   |
    //±-----------------------------------------------------------------+
    int OnInit()
      {
    // Параметры индикатора
       const string indicator_name = "MAA";
       const int period = 14;
    
    // Создаем хэндл для индикатора
       handleMAA = iCustom(_Symbol, PERIOD_CURRENT, indicator_name, period);
       if(handleMAA == INVALID_HANDLE)
         {
          Print("Error creating indicator handle: ", GetLastError());
          return INIT_FAILED;
         }
    
    // Устанавливаем размер буферов
       ArraySetAsSeries(meanPlus2StdDev, true);
       ArraySetAsSeries(meanMinus2StdDev, true);
    
    // Успешная инициализация
       return INIT_SUCCEEDED;
      }
    
    //±-----------------------------------------------------------------+
    //| Expert deinitialization function                                 |
    //±-----------------------------------------------------------------+
    void OnDeinit(const int reason)
      {
    // Удаляем хэндл индикатора
       IndicatorRelease(handleMAA);
      }
    
    //±-----------------------------------------------------------------+
    //| Expert tick function                                             |
    //±-----------------------------------------------------------------+
    void OnTick()
      {
    // Проверяем наличие индикаторного хэндла
       if(handleMAA == INVALID_HANDLE)
          return;
    
    // Получаем количество баров
       int bars = Bars(_Symbol, PERIOD_CURRENT);
    
    // Проверяем наличие достаточного количества баров для расчета
       if(bars < BarsToCalculate)
          return;
    
    // Копируем индикаторные буферы
       if(CopyBuffer(handleMAA, 3, 0, BarsToCalculate, meanPlus2StdDev) < 0 ||
          CopyBuffer(handleMAA, 4, 0, BarsToCalculate, meanMinus2StdDev) < 0)
         {
          Print("Error copying indicator buffer: ", GetLastError());
          return;
         }
    
    // Получаем текущую цену
       double price = iClose(_Symbol, PERIOD_CURRENT, 0);
    
    // Флаг позиции
       bool hasPosition = false;
    
    // Проверяем наличие открытой позиции
       for(int i = PositionsTotal() - 1; i >= 0; i--) // возвращает количество текущих позиций
         {
          if(m_position.SelectByIndex(i))             // выбираем позицию по индексу для дальнейшего доступа к ее свойствам
            {
             if(m_position.Symbol() == m_symbol.Name())
               {
                hasPosition = true;
                break;
               }
            }
         }
    
    // Условия для входа в сделки
       if(price > meanPlus2StdDev[0] && !hasPosition)
         {
          // Открываем позицию на продажу
          trade.Sell(0.1);
          Print("Sell Order placed at price: ", price);
         }
       else if(price < meanMinus2StdDev[0] && !hasPosition)
         {
          // Открываем позицию на покупку
          trade.Buy(0.1);
          Print("Buy Order placed at price: ", price);
         }
      }
    //±-----------------------------------------------------------------+
    

    Теперь код должен корректно компилироваться и работать. Мы добавили объявление объектов CPositionInfo и CSymbolInfo для обеспечения правильной работы с позициями и символами. Кроме того, мы исправили цикл проверки позиций и улучшили структуру кода, чтобы устранить все ошибки, на которые указывал компилятор.

  5. User

    //+------------------------------------------------------------------+ //| ProjectName | //| Copyright 2020, CompanyName | //| http://www.companyname.net | //+------------------------------------------------------------------+ #property strict #include <Trade\Trade.mqh>

    // Инстанс торгового объекта CTrade trade;

    CPositionInfo m_position; // Индикаторные хэндлы int handleMAA;

    // Буферы для индикатора double meanPlus2StdDev[]; double meanMinus2StdDev[]; double MAADiff[];

    // Период для обратного пересчета буферов индикатора int BarsToCalculate = 100; input int period = 12;

    //±-----------------------------------------------------------------+ //| Expert initialization function | //±-----------------------------------------------------------------+ int OnInit() { // Параметры индикатора const string indicator_name = "MAAtest";

    // Создаем хэндл для индикатора handleMAA = iCustom(_Symbol, PERIOD_CURRENT, indicator_name, period); if(handleMAA == INVALID_HANDLE) { Print("Error creating indicator handle: ", GetLastError()); return INIT_FAILED; }

    // Устанавливаем размер буферов ArraySetAsSeries(meanPlus2StdDev, true); ArraySetAsSeries(meanMinus2StdDev, true); ArraySetAsSeries(MAADiff, true);

    // Успешная инициализация return INIT_SUCCEEDED; }

    //±-----------------------------------------------------------------+ //| Expert deinitialization function | //±-----------------------------------------------------------------+ void OnDeinit(const int reason) { // Удаляем хэндл индикатора IndicatorRelease(handleMAA); }

    //±-----------------------------------------------------------------+ //| Expert tick function | //±-----------------------------------------------------------------+ void OnTick() { // Проверяем наличие индикаторного хэндла if(handleMAA == INVALID_HANDLE) return;

    // Получаем количество баров int bars = Bars(_Symbol, PERIOD_CURRENT);

    // Проверяем наличие достаточного количества баров для расчета if(bars < BarsToCalculate) return;

    // Копируем индикаторные буферы if(CopyBuffer(handleMAA, 3, 0, BarsToCalculate, meanPlus2StdDev) < 0 || CopyBuffer(handleMAA, 4, 0, BarsToCalculate, meanMinus2StdDev) < 0 || CopyBuffer(handleMAA, 0, 0, BarsToCalculate, MAADiff) < 0) { Print("Error copying indicator buffer: ", GetLastError()); return; }

    // Флаг позиции bool hasPosition = false;

    // Проверяем наличие открытой позиции for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of current positions { Print(i); string deal_symbol=PositionGetSymbol(i);

      if(deal_symbol==_Symbol)
        {
         hasPosition = true;
         break;
        }
     }
    

    // Условия для входа в сделки if(MAADiff[0] > meanPlus2StdDev[0] && !hasPosition) { // Открываем позицию на продажу trade.Sell(0.1); Print("Sell Order placed at price: ", price); } else if(MAADiff[0] < meanMinus2StdDev[0] && !hasPosition) { // Открываем позицию на покупку trade.Buy(0.1); Print("Buy Order placed at price: ", price); } } //±-----------------------------------------------------------------+

    //+------------------------------------------------------------------+ нужно что бы упозиций были TP и SL

  6. Assistant

    Добавление тейк-профита (Take Profit) и стоп-лосса (Stop Loss) к сделкам в советнике может значительно улучшить управление рисками. Для этого необходимо использовать методы trade.Sell() и trade.Buy(), включив параметры sl и tp в соответствующие вызовы.

    Давайте адаптируем ваш код для включения стоп-лосса и тейк-профита, добавив соответствующие входные параметры и откорректировав методы открытия позиций.

    Обновленный код советника будет выглядеть следующим образом:

    //+------------------------------------------------------------------+
    //|                                                      ProjectName |
    //|                                      Copyright 2020, CompanyName |
    //|                                       http://www.companyname.net |
    //+------------------------------------------------------------------+
    #property strict
    #include <Trade\Trade.mqh>
    
    // Инстанс торгового объекта
    CTrade trade;
    
    CPositionInfo m_position;
    // Индикаторные хэндлы
    int handleMAA;
    
    // Буферы для индикатора
    double meanPlus2StdDev[];
    double meanMinus2StdDev[];
    double MAADiff[];
    
    // Период для обратного пересчета буферов индикатора
    int BarsToCalculate = 100;
    
    // Период для кастомного индикатора
    input int period = 12;
    
    // Входные параметры для TP и SL
    input double takeProfit = 50;   // Тейк-профит в пунктах
    input double stopLoss = 20;     // Стоп-лосс в пунктах
    
    //±-----------------------------------------------------------------+
    //| Expert initialization function                                   |
    //±-----------------------------------------------------------------+
    int OnInit()
      {
    // Параметры индикатора
       const string indicator_name = "MAAtest";
    
    // Создаем хэндл для индикатора
       handleMAA = iCustom(_Symbol, PERIOD_CURRENT, indicator_name, period);
       if(handleMAA == INVALID_HANDLE)
         {
          Print("Error creating indicator handle: ", GetLastError());
          return INIT_FAILED;
         }
    
    // Устанавливаем размер буферов
       ArraySetAsSeries(meanPlus2StdDev, true);
       ArraySetAsSeries(meanMinus2StdDev, true);
       ArraySetAsSeries(MAADiff, true);
    
    // Успешная инициализация
       return INIT_SUCCEEDED;
      }
    
    //±-----------------------------------------------------------------+
    //| Expert deinitialization function                                 |
    //±-----------------------------------------------------------------+
    void OnDeinit(const int reason)
      {
    // Удаляем хэндл индикатора
       IndicatorRelease(handleMAA);
      }
    
    //±-----------------------------------------------------------------+
    //| Expert tick function                                             |
    //±-----------------------------------------------------------------+
    void OnTick()
      {
    // Проверяем наличие индикаторного хэндла
       if(handleMAA == INVALID_HANDLE)
          return;
    
    // Получаем количество баров
       int bars = Bars(_Symbol, PERIOD_CURRENT);
    
    // Проверяем наличие достаточного количества баров для расчета
       if(bars < BarsToCalculate)
          return;
    
    // Копируем индикаторные буферы
       if(CopyBuffer(handleMAA, 3, 0, BarsToCalculate, meanPlus2StdDev) < 0 ||
          CopyBuffer(handleMAA, 4, 0, BarsToCalculate, meanMinus2StdDev) < 0 ||
          CopyBuffer(handleMAA, 0, 0, BarsToCalculate, MAADiff) < 0)
         {
          Print("Error copying indicator buffer: ", GetLastError());
          return;
         }
    
    // Флаг позиции
       bool hasPosition = false;
    
    // Проверяем наличие открытой позиции
       for(int i=PositionsTotal()-1; i>=0; i--) // returns the number of current positions
         {
          Print(i);
          string deal_symbol=PositionGetSymbol(i);
    
          if(deal_symbol==_Symbol)
            {
             hasPosition = true;
             break;
            }
         }
    
    // Текущая цена рынка
       double price = NormalizeDouble(SymbolInfoDouble(_Symbol, SYMBOL_BID), _Digits);
    
    // Рассчитываем значения TP и SL
       double sl, tp;
    
       if(MAADiff[0] > meanPlus2StdDev[0] && !hasPosition)
         {
          // Открываем позицию на продажу
          sl = price + stopLoss * _Point;
          tp = price - takeProfit * _Point;
    
          if(trade.Sell(0.1, _Symbol, price, sl, tp))
            Print("Sell Order placed at price: ", price, ", SL: ", sl, ", TP: ", tp);
          else
            Print("Failed to place Sell Order: ", GetLastError());
         }
       else if(MAADiff[0] < meanMinus2StdDev[0] && !hasPosition)
         {
          // Открываем позицию на покупку
          sl = price - stopLoss * _Point;
          tp = price + takeProfit * _Point;
    
          if(trade.Buy(0.1, _Symbol, price, sl, tp))
            Print("Buy Order placed at price: ", price, ", SL: ", sl, ", TP: ", tp);
          else
            Print("Failed to place Buy Order: ", GetLastError());
         }
      }
    //±-----------------------------------------------------------------+
    

    В этом обновленном коде:

    1. Входные параметры takeProfit и stopLoss добавлены, чтобы пользователь мог устанавливать значения тейк-профита и стоп-лосса в пунктах (пипсах).
    2. Рассчитываем значения sl и tp (стоп-лосс и тейк-профит) на основе текущей цены рынка.
    3. Используем методы trade.Sell() и trade.Buy(), передавая параметры цены, стоп-лосса и тейк-профита для каждой сделки.
    4. Добавили дополнительные проверки на успех или провал установки ордеров, с выведением соответствующих сообщений в журнал.

    Теперь советник будет открывать позиции с указанными значениями для тейк-профита и стоп-лосса.

  7. User

    нужен индикатор который считает ATR по 10 таймфреймам

  8. Assistant

    Создание индикатора, который рассчитывает средний истинный диапазон (ATR) по нескольким таймфреймам, может быть полезным для анализа волатильности рынка на разных временных интервалах. Давайте разобьем эту задачу на несколько шагов.

    1. Создание функции для расчета ATR на заданном таймфрейме.
    2. Определение необходимых таймфреймов.
    3. Изменение индикатора для расчета и отображения ATR для каждого из этих таймфреймов.

    Ниже представлен пример кода для индикатора, который будет вычислять ATR для 10 различных таймфреймов и отображать их в отдельном подокне.

    //+------------------------------------------------------------------+
    //|                                                      ATRMultiTF.mq5 |
    //|                        Copyright 2024, MetaQuotes Ltd.           |
    //|                             https://www.mql5.com                 |
    //+------------------------------------------------------------------+
    #property indicator_separate_window
    #property indicator_buffers 10
    #property indicator_plots   10
    
    // Таймфреймы для расчета
    input ENUM_TIMEFRAMES timeframes[] = { PERIOD_M1, PERIOD_M5, PERIOD_M15, PERIOD_M30, PERIOD_H1, PERIOD_H4, PERIOD_D1, PERIOD_W1, PERIOD_MN1 };
    input int atrPeriod = 14;
    
    // Буферы для индикаторных линий
    double atrBuffers[10][];
    string   atrLabels[10] = {"ATR_M1", "ATR_M5", "ATR_M15", "ATR_M30", "ATR_H1", "ATR_H4", "ATR_D1", "ATR_W1", "ATR_MN1"};
    
    // Присваиваем параметры каждой линии
    #property indicator_label1  "ATR_M1"
    #property indicator_type1   DRAW_LINE
    #property indicator_color1  clrRed
    
    #property indicator_label2  "ATR_M5"
    #property indicator_type2   DRAW_LINE
    #property indicator_color2  clrOrange
    
    #property indicator_label3  "ATR_M15"
    #property indicator_type3   DRAW_LINE
    #property indicator_color3  clrYellow
    
    #property indicator_label4  "ATR_M30"
    #property indicator_type4   DRAW_LINE
    #property indicator_color4  clrGreen
    
    #property indicator_label5  "ATR_H1"
    #property indicator_type5   DRAW_LINE
    #property indicator_color5  clrBlue
    
    #property indicator_label6  "ATR_H4"
    #property indicator_type6   DRAW_LINE
    #property indicator_color6  clrMagenta
    
    #property indicator_label7  "ATR_D1"
    #property indicator_type7   DRAW_LINE
    #property indicator_color7  clrViolet
    
    #property indicator_label8  "ATR_W1"
    #property indicator_type8   DRAW_LINE
    #property indicator_color8  clrWhite
    
    #property indicator_label9  "ATR_MN1"
    #property indicator_type9   DRAW_LINE
    #property indicator_color9  clrDodgerBlue
    
    //+------------------------------------------------------------------+
    //| Custom indicator initialization function                         |
    //+------------------------------------------------------------------+
    int OnInit()
      {
       // Выделяем буферы
       for(int i=0; i<ArraySize(timeframes); i++)
         {
          SetIndexBuffer(i, atrBuffers[i], INDICATOR_DATA);
          PlotIndexSetInteger(i, PLOT_DRAW_BEGIN, atrPeriod);
          IndicatorSetString(INDICATOR_SHORTNAME, "ATR MultiTF (" + IntegerToString(atrPeriod) + ")");
          PlotIndexSetString(i, PLOT_LABEL, atrLabels[i]);
         }
       return(INIT_SUCCEEDED);
      }
    
    //+------------------------------------------------------------------+
    //|                                                                  |
    //+------------------------------------------------------------------+
    int OnCalculate(const int rates_total,
                    const int prev_calculated,
                    const datetime &time[],
                    const double &open[],
                    const double &high[],
                    const double &low[],
                    const double &close[],
                    const long &tick_volume[],
                    const long &volume[],
                    const int &spread[])
      {
       // Проверка на наличие достаточного количества баров для расчета
       if(rates_total<atrPeriod)
          return(0);
    
       // Вычисляем ATR для каждого таймфрейма
       for(int tfIdx = 0; tfIdx < ArraySize(timeframes); tfIdx++)
         {
          int tf = timeframes[tfIdx];
          double atr = iATR(Symbol(), tf, atrPeriod, 0);
          if (atr < 0)
          {
             return prev_calculated; //если ошибка, вернуть prev_calculated
          }
    
          // Заполнение буфера
          int barIndex = rates_total - 1;
          atrBuffers[tfIdx][barIndex] = atr;
          while (barIndex >= 1)
            {
             atrBuffers[tfIdx][barIndex] = atrBuffers[tfIdx][barIndex + 1];
             barIndex--;
            }
         }
        
       return(rates_total);
      }
    //+------------------------------------------------------------------+
    

    Описание кода:

    1. Настройка индикатора:

      • #property indicator_separate_window: Указывает, что индикатор будет отображаться в отдельном подокне.
      • #property indicator_buffers 10: Определяет, что будет использоваться 10 буферов для отображения значений ATR на разных таймфреймах.
      • #property indicator_plots 10: Определяет, что будет использоваться 10 линий для отображения значений ATR.
    2. Входные параметры:

      • timeframes: Список таймфреймов, для которых будут рассчитываться значения ATR.
      • atrPeriod: Период для расчета ATR.
    3. Инициализация индикатора:

      • OnInit(): Функция инициализации индикатора, которая настраивает буферы и присваивает имена линий.
    4. Расчет значений ATR:

      • OnCalculate(): Основная функция расчета индикатора, которая выполняется для каждого тика. В этой функции рассчитывается значение ATR для каждого указанного таймфрейма и записывается в соответствующий буфер.

    Этот индикатор будет отображать значения ATR для 10 различных таймфреймов в одном подокне, что позволит вам анализировать волатильность на разных временных интервалах.