English
preview
Как обнаруживать и нормализовать объекты графика в MQL5 (Часть 3): Оповещения и автоматическая торговля на основе объектов, построенных вручную

Как обнаруживать и нормализовать объекты графика в MQL5 (Часть 3): Оповещения и автоматическая торговля на основе объектов, построенных вручную

MetaTrader 5 — Примеры |
61 0
Clemence Benjamin
Clemence Benjamin

Содержание

  1. В продолжение Частей 1 и 2
  2. Почему одной только нормализации недостаточно
  3. Конвейер для обнаружения взаимодействий
  4. Шаг 1 — Внесение исправлений в сборщик данных сложных объектов
  5. Шаг 2 — Создание детектора взаимодействий (InteractionDetector.mqh)
  6. Шаг 3 — Создание менеджера оповещений (AlertManager.mqh)
  7. Шаг 4 — Создание модуля исполнения торговых операций (TradeExecutor.mqh)
  8. Шаг 5 — Создание тестового советника (TestInteractionEA.mq5)
  9. Тестирование и валидация
  10. Прилагаемые файлы и краткое руководство по установке
  11. Заключение


Рассмотрим типичную торговую сессию: трейдер построил вилы Эндрюса на графике H1, коррекцию Фибоначчи на графике M15 и равноудаленный канал на графике M5. В ходе наблюдения цена приближается к срединной линии вил Эндрюса, касается уровня Фибоначчи 61,8%, а затем пробивает границу канала. Трейдер ненадолго отвлекается, а к моменту его возвращения торговая возможность уже упущена либо цена уже прошла уровень стоп-лосса. Такая ситуация не является исключительным случаем; она регулярно возникает у любого технического аналитика, который использует нарисованные вручную инструменты. Эти ограничения носят не только теоретический характер: они ежедневно проявляются в виде пропущенных входов в рынок, непреднамеренных срабатываний стоп-лоссов и нестабильной динамики средств на счете.

Ручной мониторинг имеет три основных ограничения, которые напрямую влияют на прибыльность и управление рисками:

  • Задержка: даже дисциплинированный трейдер, проверяющий рынок каждые несколько минут, реагирует медленнее, чем автоматизированная система. Взаимодействия цены с объектами, длящиеся всего несколько тиков, могут остаться совершенно незамеченными.
  • Масштабируемость: по мере роста числа нанесенных на графики объектов (на разных таймфреймах и по нескольким торговым инструментам, с десятками вил Эндрюса и уровней Фибоначчи) трейдер уже не может одновременно отслеживать все границы.
  • Субъективность: при ручном анализе оценка того, "коснулась" ли цена линии, "закрылась за пределами" прямоугольника или "отскочила" от границы канала, различается у разных трейдеров и даже у одного трейдера в разные торговые сессии. Непоследовательные правила приводят к непоследовательным результатам.

Основная проблема заключается в том, что графические объекты задаются статическими геометрическими параметрами, тогда как цена непрерывно меняется. Раньше для преодоления этого разрыва требовались либо постоянное внимание со стороны человека, либо дорогостоящие сторонние инструменты. В предыдущих частях этой серии (Часть 1 и Часть 2) мы заложили прочную основу: создали систему, способную обнаруживать любой графический объект на графике и нормализовать его координаты, приводя их к единому внутреннему представлению, которое хранится в структурах SChartObjectInfo и SComplexObjectInfo. Это позволило нам ответить на вопросы "Какие объекты существуют?" и "Где находятся их опорные точки?". Однако мы не затронули действительно важный вопрос: "Когда и как цена взаимодействует с этими объектами?"

Эта статья замыкает круг. Мы расширяем механизм обнаружения и нормализации, превращая его в полностью автоматизированный слой мониторинга и исполнения торговых операций. Цель — превратить все нанесенные на график вилы Эндрюса, инструменты Фибоначчи, каналы, трендовые линии, прямоугольники, горизонтальные линии и дуги в триггеры, способные генерировать оповещения или даже отправлять рыночные ордера. И всё это без единой ручной проверки. Трейдер может отлучиться, будучи уверенным, что каждое взаимодействие цены с границей будет зафиксировано и обработано в режиме реального времени.

Для этого нам необходимо решить четыре задачи. Во-первых, определить объективные критерии взаимодействия для каждого типа объектов (например, "касание", "закрытие выше", "пробой"). Во-вторых, создать эффективный цикл опроса, который не снижает производительность графика. В-третьих, реализовать конечный автомат, предотвращающий появление дублирующихся сигналов. В-четвертых, обеспечить простой и понятный интерфейс к торговым функциям MQL5 для автоматического исполнения торговых операций. В оставшейся части статьи рассматривается каждый компонент и приводится полностью прокомментированный код, готовый к компиляции. В ней также объясняются основные компромиссы (например, использование флага занятости для предотвращения повторного входа). В результате получается модульная система, которую можно интегрировать в ваши советники или скрипты.



Правильное размещение аналитических объектов для надежного обнаружения

Прежде чем советник сможет отслеживать нарисованные вами объекты, их необходимо разместить так, чтобы алгоритмы обнаружения могли однозначно их интерпретировать. Платформа MetaTrader 5 предлагает широкий набор инструментов для рисования, однако для того, чтобы логика взаимодействия работала должным образом, необходимо соблюдать несколько простых правил:

  • Трендовые линии — всегда размещайте первую точку на более раннем локальном минимуме или максимуме (начальной точке разворота), а вторую — на более позднем локальном экстремуме. Трендовая линия должна быть продолжена за пределы текущего ценового движения, чтобы можно было точно вычислить ее ценовую координату в текущий момент времени. Избегайте вертикальных трендовых линий и линий, у которых опорные точки имеют одинаковые временные координаты, поскольку их нельзя использовать для обнаружения пересечения линии ценой.
  • Горизонтальные линии — расположите линию точно на том уровне, который необходимо контролировать. Детектор считывает только ценовую координату; время игнорируется. Убедитесь, что линия не скрыта и не находится за другими объектами.
  • Прямоугольники — рисуйте от левого верхнего угла к правому нижнему углу (или наоборот). Процедура нормализации автоматически отсортирует координаты таким образом, чтобы прямоугольник определялся его максимальной и минимальной ценами. Прямоугольник рассматривается как зона: система выдает оповещение, когда цена входит в эту зону или совершает пробой ее границы.
  • Коррекция Фибоначчи — рисуйте от начала ценового колебания до его конца. Советник извлекает из свойств объекта все уровни, заданные коэффициентами (0,236, 0,382 и т. д.). Вы можете настроить уровни в диалоговом окне свойств объекта, и детектор автоматически их считает.
  • Равноудаленные каналы — используйте инструмент построения канала по трем точкам. Первые два щелчка определяют базовую линию, а третий щелчок — противоположную границу. Детектор взаимодействий вычисляет текущую цену каждой из двух линий и проверяет наличие касаний. Для достижения наилучших результатов проведите базовую линию вдоль трендовой линии, соединяющей основные точки ценовых колебаний.
  • Вилы Эндрюса — щелчком задайте первую точку на исходном разворотном экстремуме, вторую — на первом противоположном экстремуме, третью — на следующем экстремуме. Детектор автоматически рассчитает срединную линию. Вы также можете добавить дополнительные уровни (например, линии 61,8%) через свойства объекта. Они будут считываться как смещения относительно срединной линии и отображаться в оповещениях.

Соблюдая эти рекомендации по размещению, вы обеспечите соответствие нормализованных координат, полученных механизмом обнаружения, геометрическому смыслу, заложенному в алгоритмах взаимодействия. В следующих разделах мы создадим компоненты, которые превращают эти корректно сформированные объекты в торговые сигналы, на основе которых можно принимать решения.



В продолжение Частей 1 и 2

В Части 1 мы создали ChartObjectDetector.mqh — базовый класс для повторного использования, который перебирает все аналитические объекты на графике и заполняет массив структур SChartObjectInfo данными о двух основных опорных точках каждого объекта. В Части 2 мы расширили эту функциональность с помощью ComplexObjectDataCollector.mqh, который наследуется от базового детектора и добавляет извлечение массивов уровней Фибоначчи, опорных точек каналов и геометрии вил Эндрюса. Результат сохраняется в расширенной структуре SComplexObjectInfo, которая содержит всю необходимую информацию для алгоритмической торговли. Эти ранее созданные модули служат основой, на которой мы теперь строим слои взаимодействия и исполнения торговых операций. Они прошли тщательное тестирование и не требуют изменений.

Теперь, в Части 3, мы продолжим развивать эту основу, сохранив существующий код. Наши новые модули будут подключать существующие файлы и добавлять логику взаимодействия, оповещения и исполнение торговых операций. Архитектура предусматривает разделение задач между четырьмя новыми файлами, расположенными в одной папке MQL5/Include/ChartObjectsAlgorithms/:

  • ComplexObjectDataCollector.mqh — исправленная версия файла из Части 2; единственное изменение заключается в том, что теперь фильтр IsAnalyticalObject также принимает горизонтальные и вертикальные линии. Этот небольшой патч обеспечивает видимость всех аналитических объектов для детектора взаимодействий.
  • InteractionDetector.mqh — новый класс, наследующийся от CComplexObjectDetector и добавляющий методы для сравнения текущих цен с геометрией каждого объекта. Он возвращает список взаимодействий (касание, пересечение, пробой) с информацией о направлении и уровне, которого коснулась цена. Благодаря наследованию мы повторно используем уже проделанную работу по нормализации.
  • AlertManager.mqh — принимает данные о взаимодействиях и выдает уведомления (всплывающие окна, push-уведомления, звуковые сигналы), предотвращая повторные оповещения с помощью массива записей, хранящих состояния. Сообщение оповещения содержит имя объекта, его тип, вид взаимодействия и точное описание уровня, благодаря чему сразу становится ясно, какого именно уровня коснулась цена.
  • TradeExecutor.mqh — преобразует взаимодействие в рыночный или отложенный ордер. При касаниях он использует сторону подхода для определения направления сделки (покупка при касании сверху — поддержка; продажа при касании снизу — сопротивление). Уровни стоп-лосса и тейк-профита определяются на основе геометрии объекта, а не фиксированного количества пипсов.

Тестовый советник TestInteractionEA.mq5 объединяет все эти компоненты воедино. Он создаёт экземпляры детектора взаимодействий, менеджера оповещений и торгового модуля, а затем запускает цикл обнаружения при каждом тике (с ограничением частоты в соответствии с заданным пользователем интервалом). Флаг занятости внутри детектора взаимодействий предотвращает повторный вход, а отдельный флаг занятости в торговом модуле предотвращает отправку дублирующих ордеров. Такая модульная архитектура позволяет заменять компоненты независимо друг от друга. Например, вы можете заменить менеджер оповещений модулем отправки уведомлений в Telegram, реализовав новый класс.

В приведенном ниже фрагменте кода показан заголовок нового класса детектора взаимодействий. Обратите внимание, что он наследуется от существующего сборщика сложных объектов — переписывать процедуры перебора или нормализации не требуется.

//--- File: InteractionDetector.mqh – interaction detection module
#include "ComplexObjectDataCollector.mqh"

//+------------------------------------------------------------------+
//| Interaction types                                                |
//+------------------------------------------------------------------+
enum ENUM_INTERACTION
  {
   INTERACTION_NONE,              // no interaction
   INTERACTION_TOUCH,             // price is near a line/level
   INTERACTION_CROSS_UP,          // crossed above the line
   INTERACTION_CROSS_DOWN,        // crossed below the line
   INTERACTION_BREAKOUT_ABOVE,    // closed above a rectangle/channel
   INTERACTION_BREAKOUT_BELOW     // closed below a rectangle/channel
  };

//+------------------------------------------------------------------+
//| Interaction descriptor                                           |
//+------------------------------------------------------------------+
struct SInteraction
  {
   string            objName;        // object name as seen on the chart
   int               objType;        // ENUM_OBJECT type constant
   double            levelPrice;     // the price of the line/level touched
   ENUM_INTERACTION  action;         // type of interaction
   int               direction;      // 1=bullish, -1=bearish, 0=neutral
   string            side;           // "above" or "below" the line/level at touch moment
   string            levelText;      // e.g., "0.618" for Fibonacci, "Median" for pitchfork
  };

//+------------------------------------------------------------------+
//| Interaction detector class                                       |
//+------------------------------------------------------------------+
class CInteractionDetector : public CComplexObjectDetector
  {
private:
   bool              m_busy;             // re‑entrancy guard
   SInteraction      m_interactions[];   // list of detected interactions
   int               m_interactionCount; // number of detected interactions

   //--- State tracking by object name
   string            m_stateNames[];     // object names for state map
   int               m_stateValues[];    // -1=below, 1=above, 0=unknown, 2=touching
   int               m_stateCount;       // number of state entries

   int               FindState(const string &name);
   void              SetState(const string &name,int value);

   void              CheckTrendline(const SComplexObjectInfo &obj,double bid,double ask,datetime now);
   void              CheckHorizontalLine(const SComplexObjectInfo &obj,double bid,double ask);
   void              CheckRectangle(const SComplexObjectInfo &obj,double bid,double ask,datetime now);
   void              CheckFibonacci(const SComplexObjectInfo &obj,double bid,double ask);
   void              CheckChannel(const SComplexObjectInfo &obj,double bid,double ask,datetime now);
   void              CheckPitchfork(const SComplexObjectInfo &obj,double bid,double ask,datetime now);

   double            LineValueAtTime(datetime t,datetime t0,double p0,datetime t1,double p1);
   bool              IsValidObject(const SComplexObjectInfo &obj,double currentPrice,datetime now);

public:
   CInteractionDetector();
   int               DetectInteractions(double bid,double ask,datetime now);
   bool              GetInteraction(int index,SInteraction &out) const;
   int               InteractionCount() const { return(m_interactionCount); }
  };

Каждый метод Check* использует нормализованные данные из SComplexObjectInfo для расчета соответствующих ценовых уровней: для трендовой линии — текущего значения линии; для коррекции Фибоначчи — цены каждого уровня; для вил Эндрюса — срединной линии и, при необходимости, дополнительных уровней. Взаимодействие фиксируется только в случае обнаружения изменения состояния (например, цена была выше линии, а теперь находится ниже), что позволяет исключить дублирующиеся сигналы. Флаг занятости m_busy гарантирует, что во время выполнения сканирования невозможно повторно войти в цикл обнаружения.

Компромисс: почему бы не использовать отдельный таймер или очередь событий?
Простой флаг занятости требует мало ресурсов, а его логику легко понять. В системе, работающей в реальных условиях с сотнями объектов, более сложная очередь событий могла бы сократить количество пропущенных событий, однако для обычного внутридневного трейдера такое усложнение не оправдано. Использование флага занятости создаёт небольшой риск пропустить быстрое изменение цены, если выполнение обработчика занимает больше нескольких миллисекунд, однако условия взаимодействия с объектами (например, пересечение ценой трендовой линии) обычно проверяются на каждом тике, поэтому событие будет зафиксировано на следующем тике.

Все новые файлы будут находиться в той же папке MQL5/Include/ChartObjectsAlgorithms/, что и существующие файлы детекторов. В следующем разделе мы рассмотрим технические сложности, из-за которых простое сравнение цены с объектом ненадёжно, и объясним, почему унаследованный слой нормализации необходим.



Почему одной только нормализации недостаточно

Автоматизация на основе графических объектов, нарисованных вручную, открывает значительные возможности, однако разрыв между статическим рисунком и текущей ценой оказывается гораздо глубже, чем кажется на первый взгляд. В первых двух статьях была решена проблема считывания и нормализации этих объектов. Следующая сложность связана с интерпретацией: как на основе набора нормализованных координат программно определить, что взаимодействие произошло? Без точного определения любая автоматизированная система будет страдать от ложных срабатываний и пропущенных сигналов.

Повернутые объекты — первая из возможных трудностей. Трендовая линия (OBJ_TREND) определяется двумя опорными точками. Соединяющая их линия наклонена относительно осей времени и цены графика. Простой скрипт, сравнивающий текущую цену Bid с ценой первой опорной точки, выберет цену, соответствующую времени этой точки, а не текущему времени. Ошибка может составлять десятки пипсов. Такая же проблема возникает для любого объекта, геометрия которого предполагает наклон: вил Эндрюса, каналов и даже некоторых дуг Фибоначчи. Наш детектор, описанный в Частях 1 и 2, корректно извлекает две (или три) пары "время — цена"; теперь наш детектор взаимодействий должен использовать эти пары, чтобы получить уравнение прямой и вычислить по нему цену на текущий момент времени. Один этот шаг превращает исходный рисунок в динамический опорный уровень.

Использование смешанных систем координат ещё больше усугубляет путаницу. Горизонтальная линия (OBJ_HLINE) имеет только цену; время в данном случае не имеет значения. Вертикальная линия (OBJ_VLINE) имеет только временную координату. Уровни коррекции Фибоначчи хранятся в отдельном массиве свойств (OBJPROP_LEVELVALUE), а не в виде отдельных опорных точек. Детектор сложных объектов из Части 2 уже хранит эти уровни в SComplexObjectInfo; нам остается лишь сравнить текущую цену с каждым уровнем в массиве. Обрабатывая все объекты с помощью единой структуры данных, мы избегаем чреватой ошибками условной логики, которая приводит к сбоям в работе большинства скриптов мониторинга объектов.

Привязка по нескольким опорным точкам — наиболее сложный случай. Вилы Эндрюса (OBJ_PITCHFORK) используют три опорные точки: начало рукоятки, конец рукоятки и срединную точку. Наш детектор уже сохраняет эти значения в переменных pitchfork_handle_time[2], pitchfork_handle_price[2], pitchfork_median_time и pitchfork_median_price. Затем детектор взаимодействий вычисляет текущую цену срединной линии с помощью той же линейной интерполяции, что и для трендовой линии. Дополнительные уровни вил Эндрюса (если они добавлены пользователем) хранятся в массивах pitchfork_level_values[] и pitchfork_level_texts[]; каждый из них задает ценовое смещение относительно срединной линии, поэтому текущая цена линии равна median_now + offset. Именно такой единообразный подход к обработке объектов различной геометрии обеспечивает расширяемость системы.

Используя уже нормализованный объект SComplexObjectInfo, детектор взаимодействий позволяет избежать повторного считывания исходных значений свойств. Он просто применяет геометрические формулы к координатам, которые уже находятся в памяти. Такое разделение задач — извлечение данных в Части 2, интерпретация в Части 3 — является залогом удобства обслуживания и расширяемости системы.



Конвейер для обнаружения взаимодействий

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

  1. Перечисление и нормализация — выполняются существующим методом CComplexObjectDetector::Detect() (унаследованным из Частей 1 и 2), который заполняет массив SComplexObjectInfo.
  2. Проверка взаимодействий цены с объектами — выполняется новым методом CInteractionDetector::DetectInteractions(), который принимает массив объектов, текущие цены Bid и Ask и текущее время, а затем возвращает массив объектов типа SInteraction.
  3. Оповещение и уведомление — CAlertManager получает массив взаимодействий и формирует оповещения, но только для тех взаимодействий, которые означают изменение состояния.
  4. Исполнение торговых операций — CTradeExecutor получает дескриптор взаимодействия и размещает рыночный или отложенный ордер с динамическими уровнями стоп-лосса и тейк-профита.

В приведенной ниже таблице указаны поддерживаемые типы объектов и способы, которыми детектор взаимодействий вычисляет соответствующую цену для каждого из них.

Тип объектаПроверяемое взаимодействиеОснова расчета цены
Трендовая линия (OBJ_TREND)Пересечение вверх/вниз, касаниеУравнение линии: коэффициент наклона × (now – time1) + price1
Горизонтальная линия (OBJ_HLINE)Пересечение вверх/вниз, касаниеprice1 (константа)
Прямоугольник (OBJ_RECTANGLE)Вход в зону, пробой верхней/нижней границыprice1 и price2 определяют границы зоны
Фибоначчи (OBJ_FIBO и т. д.)Касание/пересечение каждого уровняМассив fibo_prices[], вычисленный в Части 2
Канал (OBJ_CHANNEL)Пересечение базовой линии и противоположной границыchannel_price[0] и channel_price[1] определяют базовую линию; channel_price[2] используется для вычисления противоположной границы
Вилы Эндрюса (OBJ_PITCHFORK)Касание/пересечение срединной линии и дополнительных уровнейСрединная линия: проходит через handle[0] и срединную точку; дополнительные уровни: срединная линия + смещение



Шаг 1 — Внесение исправлений в сборщик данных сложных объектов

Файл ComplexObjectDataCollector.mqh из Части 2 уже содержит стандартный заголовок MQL5 с директивами copyright и link, подключает файл ChartObjectDetector.mqh, а также определяет функцию IsAnalyticalObject, расширенную структуру SComplexObjectInfo и класс CComplexObjectDetector. Для наших целей нам нужно лишь изменить глобальную функцию фильтрации таким образом, чтобы горизонтальные и вертикальные линии распознавались как аналитические объекты. Остальная часть файла остаётся без изменений.

Функция IsAnalyticalObject

Эта функция возвращает true для всех типов объектов, которые должен обрабатывать детектор взаимодействий. Мы добавляем OBJ_HLINE и OBJ_VLINE в существующий список, чтобы горизонтальные и вертикальные линии больше не пропускались. Замените существующую функцию IsAnalyticalObject следующей версией.

//+------------------------------------------------------------------+
//| Checks if an object type is analytical (used for filtering)      |
//+------------------------------------------------------------------+
bool IsAnalyticalObject(int type)
  {
   switch(type)
     {
      case OBJ_FIBO:      // Fibonacci retracement
      case OBJ_FIBOTIMES: // Fibonacci time zones
      case OBJ_FIBOFAN:   // Fibonacci fan
      case OBJ_FIBOARC:   // Fibonacci arc
      case OBJ_CHANNEL:   // equidistant channel
      case OBJ_PITCHFORK: // Andrews pitchfork
      case OBJ_TREND:     // trendline
      case OBJ_RECTANGLE: // rectangle
      case OBJ_HLINE:     // horizontal line (added)
      case OBJ_VLINE:     // vertical line (added)
         return(true);
      default:
         return(false);
     }
  }

Кроме того, базовый детектор (ChartObjectDetector.mqh) должен извлекать первые две опорные точки вил Эндрюса, иначе фильтр проверки отклонит эти объекты. Добавьте OBJ_PITCHFORK в список типов объектов в функции ExtractProperties, как показано в окончательной версии файла ChartObjectDetector.mqh, доступной во вложениях.



Шаг 2 — Создание детектора взаимодействий (InteractionDetector.mqh)

Создайте новый файл InteractionDetector.mqh в папке MQL5/Include/ChartObjectsAlgorithms/. Файл начинается со стандартного заголовка MQL5, содержащего имя файла, информацию об авторских правах и ссылку. В нем подключается файл ComplexObjectDataCollector.mqh, благодаря чему становятся доступны все определения из этого файла.

//+------------------------------------------------------------------+
//|                                        InteractionDetector.mqh   |
//|                          Copyright 2026, Clemence Benjamin       |
//|                                         https://www.mql5.com     |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Clemence Benjamin"
#property link      "https://www.mql5.com"

#include "ComplexObjectDataCollector.mqh"
Перечисление типов взаимодействий

Это перечисление определяет возможные взаимодействия, о которых может сообщать детектор. Оно включает отсутствие взаимодействия, касание, пересечение вверх или вниз, а также пробой верхней или нижней границы прямоугольника или канала.

//+------------------------------------------------------------------+
//| Interaction types                                                |
//+------------------------------------------------------------------+
enum ENUM_INTERACTION
  {
   INTERACTION_NONE,              // no interaction
   INTERACTION_TOUCH,             // price is near a line/level
   INTERACTION_CROSS_UP,          // crossed above the line
   INTERACTION_CROSS_DOWN,        // crossed below the line
   INTERACTION_BREAKOUT_ABOVE,    // closed above a rectangle/channel
   INTERACTION_BREAKOUT_BELOW     // closed below a rectangle/channel
  };
Структура дескриптора взаимодействия

SInteraction содержит всю информацию об обнаруженном взаимодействии: имя и тип объекта, цену уровня, на котором произошло взаимодействие, действие, указание направления, сторону подхода ("сверху"/"снизу") и строку с описанием уровня (например, "0.618" для Фибоначчи, "Median" для вил Эндрюса).

//+------------------------------------------------------------------+
//| Interaction descriptor                                           |
//+------------------------------------------------------------------+
struct SInteraction
  {
   string            objName;        // object name as seen on the chart
   int               objType;        // ENUM_OBJECT type constant
   double            levelPrice;     // the price of the line/level touched
   ENUM_INTERACTION  action;         // type of interaction
   int               direction;      // 1=bullish, -1=bearish, 0=neutral
   string            side;           // "above" or "below" the line/level at touch moment
   string            levelText;      // e.g., "0.618" for Fibonacci, "Median" for pitchfork
  };
Объявление класса

Класс CInteractionDetector публично наследуется от класса CComplexObjectDetector. Он содержит флаг занятости, массив взаимодействий и карту состояний с привязкой к именам объектов. В закрытом разделе объявлены вспомогательные методы управления состояниями, методы проверки взаимодействий для отдельных типов объектов, а также вспомогательные методы геометрических расчетов. В открытом разделе объявлены конструктор, основной метод обнаружения, метод доступа и метод подсчета.

//+------------------------------------------------------------------+
//| Interaction detector class                                       |
//+------------------------------------------------------------------+
class CInteractionDetector : public CComplexObjectDetector
  {
private:
   bool              m_busy;             // re‑entrancy guard
   SInteraction      m_interactions[];   // list of detected interactions
   int               m_interactionCount; // number of detected interactions

   //--- State tracking by object name
   string            m_stateNames[];     // object names for state map
   int               m_stateValues[];    // -1=below, 1=above, 0=unknown, 2=touching
   int               m_stateCount;       // number of state entries

   int               FindState(const string &name);
   void              SetState(const string &name,int value);

   void              CheckTrendline(const SComplexObjectInfo &obj,double bid,double ask,datetime now);
   void              CheckHorizontalLine(const SComplexObjectInfo &obj,double bid,double ask);
   void              CheckRectangle(const SComplexObjectInfo &obj,double bid,double ask,datetime now);
   void              CheckFibonacci(const SComplexObjectInfo &obj,double bid,double ask);
   void              CheckChannel(const SComplexObjectInfo &obj,double bid,double ask,datetime now);
   void              CheckPitchfork(const SComplexObjectInfo &obj,double bid,double ask,datetime now);

   double            LineValueAtTime(datetime t,datetime t0,double p0,datetime t1,double p1);
   bool              IsValidObject(const SComplexObjectInfo &obj,double currentPrice,datetime now);

public:
   CInteractionDetector();
   int               DetectInteractions(double bid,double ask,datetime now);
   bool              GetInteraction(int index,SInteraction &out) const;
   int               InteractionCount() const { return(m_interactionCount); }
  };
Конструктор

Конструктор инициализирует флаг занятости и карту состояний. Флаг занятости m_busy устанавливается в значение false, счетчики взаимодействий и состояний обнуляются.

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CInteractionDetector::CInteractionDetector() : m_busy(false),
                                               m_interactionCount(0),
                                               m_stateCount(0)
  {
  }
FindState

Этот вспомогательный метод выполняет поиск по имени объекта во внутренней карте состояний. Функция возвращает индекс записи о состоянии, если она найдена, или -1, если для объекта состояние не зарегистрировано. Метод используется в SetState и в каждом методе проверки для получения предыдущего положения цены относительно объекта.

//+------------------------------------------------------------------+
//| Find state index by name; return -1 if not found                 |
//+------------------------------------------------------------------+
int CInteractionDetector::FindState(const string &name)
  {
   for(int i=0; i<m_stateCount; i++)
     {
      if(m_stateNames[i]==name)
         return(i);
     }
   return(-1);
  }
SetState

Этот метод обновляет значение состояния для объекта с заданным именем. Если такого имени еще нет в карте состояний, создается новая запись: для этого изменяется размер массивов и увеличивается счетчик. Благодаря этому механизм отслеживания состояний по именам объектов остается динамическим и поддерживается в актуальном состоянии автоматически.

//+------------------------------------------------------------------+
//| Set state for an object; create new entry if needed              |
//+------------------------------------------------------------------+
void CInteractionDetector::SetState(const string &name,int value)
  {
   int idx=FindState(name);
   if(idx<0)
     {
      //--- Create new state entry
      idx=m_stateCount;
      ArrayResize(m_stateNames,idx+1);
      ArrayResize(m_stateValues,idx+1);
      m_stateCount=idx+1;
      m_stateNames[idx]=name;
     }
   m_stateValues[idx]=value;
  }
DetectInteractions

Это основная открытая точка входа, вызываемая при каждом срабатывании таймера. Сначала проверяется флаг занятости, чтобы предотвратить повторный вход, а затем обновляется список объектов с помощью унаследованного детектора. Каждый объект проходит валидацию; объекты, прошедшие ее, передаются в соответствующий метод проверки. После завершения цикла из карты состояний удаляются устаревшие записи об объектах, которые больше не существуют.

//+------------------------------------------------------------------+
//| Main detection loop                                              |
//+------------------------------------------------------------------+
int CInteractionDetector::DetectInteractions(double bid,double ask,datetime now)
  {
   if(m_busy)
      return(0);
   m_busy=true;

   //--- Use inherited detector to get normalized objects
   SComplexObjectInfo objects[];
   int objCount=CComplexObjectDetector::Detect(objects);

   ArrayResize(m_interactions,objCount);
   m_interactionCount=0;

   double currentPrice=(bid+ask)/2.0;

   for(int i=0; i<objCount; i++)
     {
      //--- Skip objects that fail validation (too old, unrealistic line)
      if(!IsValidObject(objects[i],currentPrice,now))
         continue;

      //--- Dispatch to the correct checker based on object type
      switch(objects[i].type)
        {
         case OBJ_TREND:      CheckTrendline(objects[i],bid,ask,now); break;
         case OBJ_HLINE:      CheckHorizontalLine(objects[i],bid,ask); break;
         case OBJ_RECTANGLE:  CheckRectangle(objects[i],bid,ask,now); break;
         case OBJ_FIBO:
         case OBJ_FIBOTIMES:
         case OBJ_FIBOFAN:
         case OBJ_FIBOARC:    CheckFibonacci(objects[i],bid,ask); break;
         case OBJ_CHANNEL:    CheckChannel(objects[i],bid,ask,now); break;
         case OBJ_PITCHFORK:  CheckPitchfork(objects[i],bid,ask,now); break;
         default: break;
        }
     }

   //--- Clean up state entries for objects that no longer exist
   for(int i=m_stateCount-1; i>=0; i--)
     {
      bool found=false;
      for(int j=0; j<objCount; j++)
        {
         if(objects[j].name==m_stateNames[i])
           {
            found=true;
            break;
           }
        }
      if(!found)
        {
         //--- Remove stale state entry by swapping with last
         m_stateNames[i]=m_stateNames[m_stateCount-1];
         m_stateValues[i]=m_stateValues[m_stateCount-1];
         ArrayResize(m_stateNames,m_stateCount-1);
         ArrayResize(m_stateValues,m_stateCount-1);
         m_stateCount--;
        }
     }

   m_busy=false;
   return(m_interactionCount);
  }
IsValidObject

Перед проверкой объектов этот метод отбрасывает те из них, у которых первая опорная точка находится более чем на 1000 баров в прошлом или расчетная цена на продолжении линии выходит за пределы реалистичного диапазона (менее 0,1 текущей цены или более 10 текущих цен). Этот фильтр удаляет шумовые объекты, например очень короткие трендовые линии, продолжение которых дает нереалистичные цены.

//+------------------------------------------------------------------+
//| Validate object: ignore if times are too old or line price huge  |
//+------------------------------------------------------------------+
bool CInteractionDetector::IsValidObject(const SComplexObjectInfo &obj,double currentPrice,datetime now)
  {
   string symbol=ChartSymbol(m_chart_id);
   if(symbol=="")
      return(false);

   //--- Reject objects whose first anchor is older than 1000 bars
   if(obj.time1!=0)
     {
      int barShift=iBarShift(symbol,Period(),obj.time1,false);
      if(barShift<0 || barShift>1000)
         return(false);
     }

   //--- For sloped objects, check if the projected line price is realistic
   if(obj.type==OBJ_TREND || obj.type==OBJ_CHANNEL || obj.type==OBJ_PITCHFORK)
     {
      if(obj.time1!=0 && obj.time2!=0)
        {
         double linePrice=LineValueAtTime(now,obj.time1,obj.price1,obj.time2,obj.price2);
         if(MathAbs(linePrice)>MathAbs(currentPrice)*10 || MathAbs(linePrice)<MathAbs(currentPrice)*0.1)
            return(false);
        }
     }
   return(true);
  }
LineValueAtTime

Для всех наклонных объектов используется эта общая процедура линейной интерполяции, вычисляющая цену на текущий момент времени. Она принимает две опорные точки (время и цену для каждой) и возвращает цену в момент времени t на прямой, соединяющей эти точки.

//+------------------------------------------------------------------+
//| Helper: line value at given time (linear interpolation)           |
//+------------------------------------------------------------------+
double CInteractionDetector::LineValueAtTime(datetime t,datetime t0,double p0,datetime t1,double p1)
  {
   if(t1==t0)
      return(p0);
   double slope=(p1-p0)/(double)(t1-t0);
   return(p0+slope*(double)(t-t0));
  }
CheckTrendline

Этот метод проверяет корректность двух опорных точек трендовой линии, вычисляет цену на линии в текущий момент времени, а затем определяет, касается ли цена линии (с допуском в 5 пунктов) или пересекла ее. Он использует карту состояний, чтобы не сообщать многократно об одном и том же касании и выявлять фактические пересечения (например, сверху вниз). Для трендовых линий поле levelText оставляется пустым.

//+------------------------------------------------------------------+
//| Trendline check                                                  |
//+------------------------------------------------------------------+
void CInteractionDetector::CheckTrendline(const SComplexObjectInfo &obj,double bid,double ask,datetime now)
  {
   //--- Validate anchor points
   if(obj.time1==0 || obj.time2==0)
      return;
   double t1=(double)obj.time1;
   double t2=(double)obj.time2;
   if(t2==t1)
      return;

   //--- Compute the line's price at the current time
   double linePrice=LineValueAtTime(now,obj.time1,obj.price1,obj.time2,obj.price2);
   double midPrice=(bid+ask)/2.0;
   double tolerance=5.0*SymbolInfoDouble(_Symbol,SYMBOL_POINT);

   int state=FindState(obj.name);
   int prev=(state>=0) ? m_stateValues[state] : 0;

   bool isTouching=(MathAbs(midPrice-linePrice)<=tolerance);
   if(isTouching)
     {
      //--- Only report if not already touching
      if(prev!=2)
        {
         SInteraction inter;
         inter.objName    =obj.name;
         inter.objType    =obj.type;
         inter.levelPrice =linePrice;
         inter.action     =INTERACTION_TOUCH;
         inter.direction  =(linePrice>obj.price1) ? 1 : -1;
         inter.side       =(midPrice>linePrice) ? "above" : "below";
         inter.levelText  ="";
         m_interactions[m_interactionCount++]=inter;
         SetState(obj.name,2);
        }
      return;
     }

   //--- Reset touch state if price moved away
   if(prev==2)
      SetState(obj.name,0);

   //--- Detect cross if previous state was opposite
   int curr=(midPrice>linePrice) ? 1 : -1;

   if(prev!=0 && prev!=curr)
     {
      SInteraction inter;
      inter.objName    =obj.name;
      inter.objType    =obj.type;
      inter.levelPrice =linePrice;
      inter.action     =(curr==1) ? INTERACTION_CROSS_UP : INTERACTION_CROSS_DOWN;
      inter.direction  =curr;
      inter.side       =(curr==1) ? "above" : "below";
      inter.levelText  ="";
      m_interactions[m_interactionCount++]=inter;
     }
   SetState(obj.name,curr);
  }
CheckFibonacci

Этот метод перебирает заранее рассчитанные ценовые уровни Фибоначчи. Когда отклонение цены от уровня не превышает установленного допуска, метод регистрирует взаимодействие типа "касание". В качестве описания уровня используется коэффициент (например, "0.618"): сохраненный коэффициент преобразуется в строку с тремя знаками после десятичной точки. Карта состояний предотвращает повторную регистрацию касаний одного и того же уровня.

//+------------------------------------------------------------------+
//| Fibonacci level check                                            |
//+------------------------------------------------------------------+
void CInteractionDetector::CheckFibonacci(const SComplexObjectInfo &obj,double bid,double ask)
  {
   int levels=ArraySize(obj.fibo_prices);
   if(levels==0)
      return;
   double midPrice=(bid+ask)/2.0;
   double tolerance=5.0*SymbolInfoDouble(_Symbol,SYMBOL_POINT);

   int state=FindState(obj.name);
   int prev=(state>=0) ? m_stateValues[state] : 0;

   for(int l=0; l<levels; l++)
     {
      double levelPrice=obj.fibo_prices[l];
      bool isTouching=(MathAbs(midPrice-levelPrice)<=tolerance);
      if(isTouching)
        {
         if(prev!=2)
           {
            SInteraction inter;
            inter.objName    =obj.name;
            inter.objType    =obj.type;
            inter.levelPrice =levelPrice;
            inter.action     =INTERACTION_TOUCH;
            inter.direction  =0;
            inter.side       =(midPrice>levelPrice) ? "above" : "below";
            //--- Include the ratio as level description (e.g., "0.618")
            inter.levelText  =DoubleToString(obj.fibo_ratios[l],3);
            m_interactions[m_interactionCount++]=inter;
            SetState(obj.name,2);
           }
         return;
        }
     }

   if(prev==2)
      SetState(obj.name,0);
  }
CheckPitchfork

Этот метод сначала вычисляет цену на срединной линии в текущий момент времени, используя начало рукоятки вил Эндрюса и срединную точку. Если цена находится вблизи срединной линии, метод регистрирует касание со значением "Median" в поле levelText. В противном случае метод перебирает все дополнительные уровни, заданные пользователем (сохраненные как смещения относительно срединной линии), и проверяет каждый из них. В качестве описания уровня используется текст, заданный пользователем (например, "61.8"). Карта состояний обеспечивает однократное сообщение о касании при каждом входе цены в область уровня.

//+------------------------------------------------------------------+
//| Pitchfork check (median line and additional levels)               |
//+------------------------------------------------------------------+
void CInteractionDetector::CheckPitchfork(const SComplexObjectInfo &obj,double bid,double ask,datetime now)
  {
   if(obj.pitchfork_handle_time[0]==0 || obj.pitchfork_median_time==0)
      return;
   //--- Compute the current price of the median line
   double medianNow=LineValueAtTime(now,
                                   obj.pitchfork_handle_time[0],
                                   obj.pitchfork_handle_price[0],
                                   obj.pitchfork_median_time,
                                   obj.pitchfork_median_price);
   double midPrice=(bid+ask)/2.0;
   double tolerance=5.0*SymbolInfoDouble(_Symbol,SYMBOL_POINT);

   int state=FindState(obj.name);
   int prev=(state>=0) ? m_stateValues[state] : 0;

   //--- Median line touch
   if(MathAbs(midPrice-medianNow)<=tolerance)
     {
      if(prev!=2)
        {
         SInteraction inter;
         inter.objName    =obj.name;
         inter.objType    =obj.type;
         inter.levelPrice =medianNow;
         inter.action     =INTERACTION_TOUCH;
         inter.direction  =0;
         inter.side       =(midPrice>medianNow) ? "above" : "below";
         inter.levelText  ="Median";
         m_interactions[m_interactionCount++]=inter;
         SetState(obj.name,2);
        }
      return;
     }

   //--- Additional pitchfork levels (user‑defined)
   int levels=ArraySize(obj.pitchfork_level_values);
   for(int l=0; l<levels; l++)
     {
      double levelPrice=medianNow+obj.pitchfork_level_values[l];
      if(MathAbs(midPrice-levelPrice)<=tolerance)
        {
         if(prev!=2)
           {
            SInteraction inter;
            inter.objName    =obj.name;
            inter.objType    =obj.type;
            inter.levelPrice =levelPrice;
            inter.action     =INTERACTION_TOUCH;
            inter.direction  =0;
            inter.side       =(midPrice>levelPrice) ? "above" : "below";
            //--- Use the text label set by the user (e.g., "61.8")
            inter.levelText  =obj.pitchfork_level_texts[l];
            m_interactions[m_interactionCount++]=inter;
            SetState(obj.name,2);
           }
         return;
        }
     }

   if(prev==2)
      SetState(obj.name,0);
  }

Остальные методы проверки (CheckHorizontalLine, CheckRectangle, CheckChannel) построены по тому же шаблону и включены в файл исходного кода, доступный для скачивания.



Шаг 3 — Создание менеджера оповещений (AlertManager.mqh)

Менеджер оповещений — это автономная утилита, которая принимает массив дескрипторов взаимодействия SInteraction. Файл AlertManager.mqh начинается со стандартного заголовка и подключает файл InteractionDetector.mqh, что обеспечивает доступ к типам взаимодействий и дескриптору взаимодействия. В нём определены структура записи для подавления дубликатов и класс CAlertManager.

//+------------------------------------------------------------------+
//|                                              AlertManager.mqh    |
//|                          Copyright 2026, Clemence Benjamin       |
//|                                         https://www.mql5.com     |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Clemence Benjamin"
#property link      "https://www.mql5.com"

#include "InteractionDetector.mqh"
Структура записи оповещения

SAlertRecord содержит имя объекта, последнее действие, о котором было отправлено оповещение, цену на тот момент и временную метку оповещения. Эта структура используется для подавления повторяющихся одинаковых оповещений.

//+------------------------------------------------------------------+
//| Alert record for duplicate suppression                           |
//+------------------------------------------------------------------+
struct SAlertRecord
  {
   string            objName;        // chart object name
   ENUM_INTERACTION  lastAction;     // last action alerted
   double            lastLevelPrice; // price of last alert
   datetime          lastAlertTime;  // time of last alert
  };
Объявление класса

Класс CAlertManager содержит динамический массив записей, а также счетчики и флаги для каждого способа уведомления. Открытые методы настройки позволяют включать или отключать оповещения, push-уведомления и звук. Основным методом обработки является ProcessInteractions, который принимает массив взаимодействий и их количество.

//+------------------------------------------------------------------+
//| Alert manager class                                              |
//+------------------------------------------------------------------+
class CAlertManager
  {
private:
   SAlertRecord      m_records[];        // list of alert records
   int               m_recordCount;      // number of records
   bool              m_useAlert;         // enable terminal alerts
   bool              m_useNotification;  // enable push notifications
   bool              m_useSound;         // enable sound
   string            m_soundFile;        // sound file name

   int               FindRecord(const string &objName);
   void              AddOrUpdateRecord(const string &objName,ENUM_INTERACTION action,double price);

public:
   CAlertManager();
   void              SetAlertUse(bool flag)           { m_useAlert=flag; }
   void              SetNotificationUse(bool flag)    { m_useNotification=flag; }
   void              SetSoundUse(bool flag)           { m_useSound=flag; }
   void              SetSoundFile(const string &file) { m_soundFile=file; }

   void              ProcessInteractions(const SInteraction &interList[],int count);
  };
Конструктор

Конструктор обнуляет счетчик записей и задает настройки уведомлений по умолчанию: оповещения в терминале включены, push-уведомления и звук отключены, задано имя звукового файла по умолчанию.

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CAlertManager::CAlertManager() : m_recordCount(0),
                                 m_useAlert(true),
                                 m_useNotification(false),
                                 m_useSound(false),
                                 m_soundFile("alert.wav")
  {
  }
FindRecord

Эта вспомогательная функция выполняет поиск в списке существующих записей по имени объекта. Функция возвращает индекс записи, если она найдена, или -1, если запись отсутствует. Эта функция используется методами AddOrUpdateRecord и ProcessInteractions, чтобы определить, было ли уже отправлено оповещение для данного объекта.

//+------------------------------------------------------------------+
//| Find a record by object name; returns index or -1                |
//+------------------------------------------------------------------+
int CAlertManager::FindRecord(const string &objName)
  {
   for(int i=0; i<m_recordCount; i++)
     {
      if(m_records[i].objName==objName)
         return(i);
     }
   return(-1);
  }
AddOrUpdateRecord

Этот метод либо создает новую запись оповещения, либо обновляет существующую, записывая последнее действие, цену уровня и текущее время. Если имени объекта еще нет в списке записей, метод изменяет размер массива и добавляет новую запись. Это позволяет поддерживать список подавления повторных оповещений в актуальном состоянии и отфильтровывать дубликаты.

//+------------------------------------------------------------------+
//| Add or update a record                                            |
//+------------------------------------------------------------------+
void CAlertManager::AddOrUpdateRecord(const string &objName,ENUM_INTERACTION action,double price)
  {
   int idx=FindRecord(objName);
   if(idx<0)
     {
      //--- Create a new record if not found
      idx=m_recordCount;
      ArrayResize(m_records,idx+1);
      m_recordCount=idx+1;
      m_records[idx].objName=objName;
     }
   m_records[idx].lastAction    =action;
   m_records[idx].lastLevelPrice=price;
   m_records[idx].lastAlertTime =TimeCurrent();
  }
ProcessInteractions

Основной метод перебирает элементы массива дескрипторов взаимодействия. Для каждого взаимодействия метод проверяет список записей и решает, нужно ли отправлять оповещение. Оповещение отправляется, если выполняется хотя бы одно из условий: предыдущая запись отсутствует; действие изменилось с момента последнего оповещения; с момента последнего идентичного оповещения прошло более десяти секунд. При срабатывании оповещения формируется сообщение, содержащее имя объекта, его тип, действие, сторону подхода и описание уровня, после чего применяются выбранные способы уведомления. Наконец, запись обновляется, чтобы подавить повторы, возникающие сразу после оповещения.

//+------------------------------------------------------------------+
//| Process interactions and fire alerts if new                       |
//+------------------------------------------------------------------+
void CAlertManager::ProcessInteractions(const SInteraction &interList[],int count)
  {
   for(int i=0; i<count; i++)
     {
      SInteraction inter=interList[i];

      int idx=FindRecord(inter.objName);

      //--- Determine if we should alert: no record, new action, or old alert >10 sec
      bool shouldAlert=false;
      if(idx<0)
         shouldAlert=true;
      else
        {
         if(m_records[idx].lastAction!=inter.action)
            shouldAlert=true;
         else if(TimeCurrent()-m_records[idx].lastAlertTime>10)
            shouldAlert=true;
        }

      if(shouldAlert)
        {
         //--- Build message with side and level description
         string sideStr =(inter.side!="") ? " from "+inter.side : "";
         string levelStr=(inter.levelText!="") ? " ("+inter.levelText+")" : "";
         string msg=StringFormat("Object '%s' [%s] – %s%s%s at %.5f",
                               inter.objName,
                               ObjectTypeToString(inter.objType),
                               EnumToString(inter.action),
                               sideStr,
                               levelStr,
                               inter.levelPrice);
         //--- Fire notifications
         if(m_useAlert)
            Alert(msg);
         if(m_useNotification)
            SendNotification(msg);
         if(m_useSound)
            PlaySound(m_soundFile);

         AddOrUpdateRecord(inter.objName,inter.action,inter.levelPrice);
        }
     }
  }
//+------------------------------------------------------------------+


Шаг 4 — Создание модуля исполнения торговых операций (TradeExecutor.mqh)

Модуль исполнения преобразует SInteraction в реальный ордер с помощью объекта CTrade из стандартной библиотеки MQL5. Файл TradeExecutor.mqh содержит стандартный заголовок и подключает библиотеку Trade и файл InteractionDetector.mqh.

//+------------------------------------------------------------------+
//|                                            TradeExecutor.mqh     |
//|                          Copyright 2026, Clemence Benjamin       |
//|                                         https://www.mql5.com     |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Clemence Benjamin"
#property link      "https://www.mql5.com"

#include <Trade/Trade.mqh>
#include "InteractionDetector.mqh"
Объявление класса и конструктор

Класс CTradeExecutor определяет объект CTrade, флаг занятости, метку времени последнего ордера и минимальный интервал. Конструктор принимает минимальный интервал в секундах, устанавливает для него нижнюю границу в 1 секунду и инициализирует магический номер объекта CTrade нулем.

class CTradeExecutor
  {
private:
   CTrade            m_trade;            // Standard Library trade object
   bool              m_busy;             // busy flag to avoid duplicate orders
   datetime          m_lastOrderTime;    // timestamp of last order
   int               m_intervalSec;      // minimum seconds between orders

   double            ComputeStopLoss(const SInteraction &inter,double entryPrice,ENUM_ORDER_TYPE orderType);
   double            ComputeTakeProfit(double entryPrice,double slPrice,ENUM_ORDER_TYPE orderType);

public:
   CTradeExecutor(int minIntervalSec=2);
   bool              PlaceOrder(const SInteraction &inter,double lotSize,uint magic=0);
   void              ResetBusyFlag() { m_busy=false; }
  };

//+------------------------------------------------------------------+
//| Constructor                                                      |
//+------------------------------------------------------------------+
CTradeExecutor::CTradeExecutor(int minIntervalSec)
   : m_busy(false),
     m_lastOrderTime(0),
     m_intervalSec(minIntervalSec)
  {
   if(m_intervalSec<1)
      m_intervalSec=1;
   m_trade.SetExpertMagicNumber(0);
  }
PlaceOrder

Этот метод является ядром торгового модуля. Сначала он предотвращает отправку дублирующих ордеров, проверяя флаг занятости и время, прошедшее с момента последнего ордера. Затем определяет тип ордера по действию, указанному во взаимодействии. Для касаний метод использует поле side, указывающее сторону подхода: касание сверху приводит к покупке (проверка поддержки), а касание снизу — к продаже. Если цена уже находится вблизи этого уровня, используется рыночный ордер; в противном случае на этом уровне размещается лимитный ордер. Значения стоп-лосса и тейк-профита вычисляются с помощью закрытых вспомогательных методов, проверяются на корректность и передаются объекту CTrade. Результат записывается в журнал, а в случае успешного выполнения устанавливается флаг занятости.

//+------------------------------------------------------------------+
//| Place order based on interaction                                  |
//+------------------------------------------------------------------+
bool CTradeExecutor::PlaceOrder(const SInteraction &inter,double lotSize,uint magic=0)
  {
   //--- Guard: busy flag and minimum interval
   if(m_busy)
      return(false);
   if(TimeCurrent()-m_lastOrderTime<m_intervalSec)
      return(false);

   ENUM_ORDER_TYPE orderType;
   bool isMarket=false;
   double pendingPrice=0.0;

   //--- Determine order type and direction from interaction
   switch(inter.action)
     {
      case INTERACTION_CROSS_UP:
      case INTERACTION_BREAKOUT_ABOVE:
         orderType=ORDER_TYPE_BUY;
         isMarket=true;
         break;

      case INTERACTION_CROSS_DOWN:
      case INTERACTION_BREAKOUT_BELOW:
         orderType=ORDER_TYPE_SELL;
         isMarket=true;
         break;

      case INTERACTION_TOUCH:
         //--- Buy if touched from above (support), sell if from below (resistance)
         if(inter.side=="above")
           {
            orderType=ORDER_TYPE_BUY;
            double ask=SymbolInfoDouble(_Symbol,SYMBOL_ASK);
            if(ask<=inter.levelPrice+SymbolInfoDouble(_Symbol,SYMBOL_POINT)*5)
               isMarket=true;
            else
               pendingPrice=inter.levelPrice;
           }
         else if(inter.side=="below")
           {
            orderType=ORDER_TYPE_SELL;
            double bid=SymbolInfoDouble(_Symbol,SYMBOL_BID);
            if(bid>=inter.levelPrice-SymbolInfoDouble(_Symbol,SYMBOL_POINT)*5)
               isMarket=true;
            else
               pendingPrice=inter.levelPrice;
           }
         else
            return(false);
         break;

      default:
         return(false);
     }

   //--- Entry price
   double entryPrice;
   if(isMarket)
      entryPrice=(orderType==ORDER_TYPE_BUY) ? SymbolInfoDouble(_Symbol,SYMBOL_ASK)
                                                   : SymbolInfoDouble(_Symbol,SYMBOL_BID);
   else
      entryPrice=pendingPrice;

   //--- Compute SL and TP
   double sl=ComputeStopLoss(inter,entryPrice,orderType);
   double tp=(sl>0) ? ComputeTakeProfit(entryPrice,sl,orderType) : 0.0;

   //--- Validate SL/TP ordering
   if(sl>0 && tp>0)
     {
      if(orderType==ORDER_TYPE_BUY || orderType==ORDER_TYPE_BUY_STOP || orderType==ORDER_TYPE_BUY_LIMIT)
        {
         if(sl>=entryPrice)
            sl=entryPrice-SymbolInfoDouble(_Symbol,SYMBOL_POINT)*10;
         if(tp<=entryPrice)
            tp=0;
        }
      else
        {
         if(sl<=entryPrice)
            sl=entryPrice+SymbolInfoDouble(_Symbol,SYMBOL_POINT)*10;
         if(tp>=entryPrice)
            tp=0;
        }
     }

   //--- Send order
   m_trade.SetExpertMagicNumber(magic);
   bool result=false;

   if(isMarket)
      result=m_trade.PositionOpen(_Symbol,orderType,lotSize,entryPrice,sl,tp,"Interaction");
   else
     {
      if(orderType==ORDER_TYPE_BUY)
         result=m_trade.BuyLimit(lotSize,pendingPrice,_Symbol,sl,tp,ORDER_TIME_GTC,0);
      else
         result=m_trade.SellLimit(lotSize,pendingPrice,_Symbol,sl,tp,ORDER_TIME_GTC,0);
     }

   //--- Log result and set busy flag
   if(result)
     {
      m_busy=true;
      m_lastOrderTime=TimeCurrent();
      Print("Order placed: ",EnumToString(orderType)," Entry=",entryPrice," SL=",sl," TP=",tp);
     }
   else
      Print("Order failed: ",m_trade.ResultRetcodeDescription());

   return(result);
  }
ComputeStopLoss

Этот вспомогательный метод размещает стоп-лосс за уровнем, которого коснулась цена, с небольшим отступом в пять пунктов. Для ордера на покупку стоп-уровень устанавливается чуть ниже данного уровня; для ордера на продажу — чуть выше него. Благодаря этому риск тесно привязан к геометрии объекта, а не к фиксированному расстоянию в пипсах.

//+------------------------------------------------------------------+
//| Compute stop-loss relative to object geometry                     |
//+------------------------------------------------------------------+
double CTradeExecutor::ComputeStopLoss(const SInteraction &inter,double entryPrice,ENUM_ORDER_TYPE orderType)
  {
   double buffer=5.0*SymbolInfoDouble(_Symbol,SYMBOL_POINT);
   bool isBuy=(orderType==ORDER_TYPE_BUY || orderType==ORDER_TYPE_BUY_LIMIT || orderType==ORDER_TYPE_BUY_STOP);

   //--- Place SL just beyond the touched level
   if(isBuy)
      return(inter.levelPrice-buffer);    // SL just below the support
   else
      return(inter.levelPrice+buffer);    // SL just above the resistance
  }
ComputeTakeProfit

Тейк-профит устанавливается на расстоянии от цены входа, равном удвоенному расстоянию до стоп-лосса. Если расстояние до стоп-лосса равно нулю или отрицательно, функция возвращает ноль, чтобы избежать выставления некорректных ордеров. Направление (покупка/продажа) определяет, будет ли уровень тейк-профита выше или ниже цены входа.

//+------------------------------------------------------------------+
//| Compute take-profit (default risk-reward 2:1)                    |
//+------------------------------------------------------------------+
double CTradeExecutor::ComputeTakeProfit(double entryPrice,double slPrice,ENUM_ORDER_TYPE orderType)
  {
   double risk=MathAbs(entryPrice-slPrice);
   if(risk<=0)
      return(0.0);
   bool isBuy=(orderType==ORDER_TYPE_BUY || orderType==ORDER_TYPE_BUY_LIMIT || orderType==ORDER_TYPE_BUY_STOP);
   return(isBuy ? entryPrice+2.0*risk : entryPrice-2.0*risk);
  }
//+------------------------------------------------------------------+

Полная версия файла TradeExecutor.mqh доступна во вложениях.



Шаг 5 — Создание тестового советника (TestInteractionEA.mq5)

Тестовый советник объединяет все модули. Его код начинается со стандартного заголовка MQL5, подключает три новых модуля и определяет входные параметры для оповещений, торговли, размера лота, интервала сканирования и фильтра исключений. Глобальные экземпляры детектора, менеджера оповещений и торгового модуля объявлены в области видимости файла.

//+------------------------------------------------------------------+
//|                                             TestInteractionEA.mq5|
//|                          Copyright 2026, Clemence Benjamin       |
//|                                         https://www.mql5.com     |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Clemence Benjamin"
#property link      "https://www.mql5.com"
#property version   "1.00"
#property strict

#include <ChartObjectsAlgorithms/InteractionDetector.mqh>
#include <ChartObjectsAlgorithms/AlertManager.mqh>
#include <ChartObjectsAlgorithms/TradeExecutor.mqh>

//--- Input parameters
input bool   EnableAlerts     =true;   // enable visual/log alerts
input bool   EnableTrading    =false;  // enable auto trade entry
input double TradeLotSize     =0.01;  // lot size for trades
input int    TimerIntervalSec =2;     // seconds between scans
input string ExcludeNameSubstring="autotrade,#"; // comma-separated substrings to skip

//--- Global objects
CInteractionDetector detector;
CAlertManager        alertManager;
CTradeExecutor       tradeExecutor(2);
SInteraction         interactions[];
int                  interactionCount=0;
Инициализация советника

Эта функция инициализирует детектор для текущего графика, настраивает менеджер оповещений (включает оповещения, отключает push-уведомления и звуковые сигналы) и записывает в журнал сообщение о готовности.

//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
   detector.Init(0);
   alertManager.SetAlertUse(EnableAlerts);
   alertManager.SetNotificationUse(false);
   alertManager.SetSoundUse(false);

   Print("Test Interaction EA Initialized – monitoring all analytical objects");
   return(INIT_SUCCEEDED);
  }
ShouldExclude

Эта вспомогательная функция разбивает строку исключений по запятым и проверяет, содержит ли имя объекта какую-либо из полученных подстрок. Она используется для исключения автоматически созданных объектов (например, торговых меток) перед формированием оповещений и выполнением торговых операций.

//+------------------------------------------------------------------+
//| Helper: check if object name should be excluded                   |
//+------------------------------------------------------------------+
bool ShouldExclude(const string &name)
  {
   if(ExcludeNameSubstring=="")
      return(false);
   string excludeList[];
   StringSplit(ExcludeNameSubstring,',',excludeList);
   for(int i=0; i<ArraySize(excludeList); i++)
     {
      if(StringFind(name,excludeList[i])>=0)
         return(true);
     }
   return(false);
  }
OnTick

Основной обработчик тиков выполняет обнаружение взаимодействий с заданным интервалом, получает текущие цены Bid и Ask и текущее время, затем вызывает DetectInteractions. Полученные данные о взаимодействиях проходят фильтрацию, записываются в журнал "Эксперты" и передаются в модули оповещений и торговли. Касания также включены в условие выполнения торговой операции, что позволяет модулю исполнения торговых операций определять направление сделки на основе стороны подхода.

//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
   static datetime lastRun=0;
   //--- Throttle detection to the configured interval
   if(TimeCurrent()-lastRun<TimerIntervalSec)
      return;
   lastRun=TimeCurrent();

   double bid=SymbolInfoDouble(_Symbol,SYMBOL_BID);
   double ask=SymbolInfoDouble(_Symbol,SYMBOL_ASK);
   datetime now=TimeCurrent();

   //--- Run interaction detection
   int rawCount=detector.DetectInteractions(bid,ask,now);

   //--- Filter out unwanted objects
   ArrayResize(interactions,rawCount);
   interactionCount=0;

   for(int i=0; i<rawCount; i++)
     {
      SInteraction inter;
      if(detector.GetInteraction(i,inter) && !ShouldExclude(inter.objName))
         interactions[interactionCount++]=inter;
     }

   //--- Print, alert, and optionally trade
   if(interactionCount>0)
     {
      Print("------ INTERACTIONS DETECTED: ",interactionCount," ------");
      for(int i=0; i<interactionCount; i++)
        {
         PrintFormat("  %s [%s] Action: %d Price: %.5f Dir: %d Side: %s Level: %s",
                     interactions[i].objName,ObjectTypeToString(interactions[i].objType),
                     interactions[i].action,interactions[i].levelPrice,
                     interactions[i].direction,interactions[i].side,
                     interactions[i].levelText);
        }

      //--- Send alerts if enabled
      if(EnableAlerts)
         alertManager.ProcessInteractions(interactions,interactionCount);

      //--- Execute trades (includes touches) if enabled
      if(EnableTrading)
        {
         for(int i=0; i<interactionCount; i++)
           {
            if(interactions[i].action==INTERACTION_CROSS_UP || interactions[i].action==INTERACTION_CROSS_DOWN ||
               interactions[i].action==INTERACTION_BREAKOUT_ABOVE || interactions[i].action==INTERACTION_BREAKOUT_BELOW ||
               interactions[i].action==INTERACTION_TOUCH)
               tradeExecutor.PlaceOrder(interactions[i],TradeLotSize);
           }
        }
     }
  }
//+------------------------------------------------------------------+


Тестирование и валидация

Скомпилируйте все файлы и добавьте советник TestInteractionEA на график. Нарисуйте трендовую линию, горизонтальную линию, прямоугольник, коррекцию Фибоначчи, равноудаленный канал и вилы Эндрюса (при желании — с дополнительными уровнями). Советник будет выводить в журнал информацию о взаимодействиях по мере приближения цены к каждому объекту. Для каждого взаимодействия в журнале указываются имя объекта, тип, действие (касание, пересечение вверх/вниз, пробой), точная цена, направление, сторона и описание уровня (например, "0.618" для уровня Фибоначчи). Менеджер оповещений будет выводить всплывающие оповещения только при возникновении нового взаимодействия или по истечении десяти секунд с момента последнего идентичного оповещения.

Если на вашем графике много автоматически созданных объектов (например, меток сделок), используйте входной параметр ExcludeNameSubstring, чтобы исключить их из обработки. Например, при вводе "autotrade,#" будут пропущены все объекты, в названии которых содержится любая из этих подстрок. Благодаря этому журнал взаимодействий не засоряется лишними записями и содержит только информацию об аналитических объектах, которые вы нарисовали вручную.

При включенной торговле советник будет размещать рыночные ордера при пересечениях и пробоях, а при касаниях — ордера на покупку или продажу в зависимости от направления подхода цены. Всегда сначала тестируйте на демо-счете.

тестирование советника

Советник TestInteractionEA тестировался на индексе Volatility 25 (M1).

Приведенные ниже журналы тестирования подтверждают, что разработанный программный каркас работает с различными торговыми инструментами и таймфреймами. На индексе Volatility 25 советник зафиксировал касание уровня расширения Фибоначчи 423,6%. На USDJPY он обнаружил касание базовой линии канала. В каждом случае дескриптор SInteraction содержал информацию о цене, стороне и описании уровня. Менеджер оповещений предотвращал дублирование уведомлений, но допускал повторные оповещения через десять секунд, благодаря чему трейдер своевременно получал информацию без перегрузки терминала. Эти результаты показывают, что конвейер корректно преобразует статические графические объекты в динамические сигналы, пригодные для автоматической торговли или дальнейшей настройки.

2026.06.16 18:28:50.032 TestInteractionEA (Volatility 25 Index,M1)      Test Interaction EA Initialized – monitoring all analytical objects
2026.06.16 18:35:50.205 TestInteractionEA (Volatility 25 Index,M1)      ------ INTERACTIONS DETECTED: 1 ------
2026.06.16 18:35:50.205 TestInteractionEA (Volatility 25 Index,M1)        M1 Fibo 17345 [FIBO] Action: 1 Price: 2696.35373 Dir: 0 Side: below Level: 4.236
2026.06.16 18:35:50.205 TestInteractionEA (Volatility 25 Index,M1)      Alert: Object 'M1 Fibo 17345' [FIBO] – INTERACTION_TOUCH from below (4.236) at 2696.35373
2026.06.16 18:36:22.243 TestInteractionEA (Volatility 25 Index,M1)      ------ INTERACTIONS DETECTED: 1 ------
2026.06.16 18:36:22.243 TestInteractionEA (Volatility 25 Index,M1)        M1 Fibo 17345 [FIBO] Action: 1 Price: 2696.35373 Dir: 0 Side: below Level: 4.236
2026.06.16 18:36:22.244 TestInteractionEA (Volatility 25 Index,M1)      Alert: Object 'M1 Fibo 17345' [FIBO] – INTERACTION_TOUCH from below (4.236) at 2696.35373
2026.06.16 18:40:32.016 TestInteractionEA (Volatility 25 Index,M1)      ------ INTERACTIONS DETECTED: 1 ------
2026.06.16 18:40:32.016 TestInteractionEA (Volatility 25 Index,M1)        M1 Fibo 17345 [FIBO] Action: 1 Price: 2696.35373 Dir: 0 Side: below Level: 4.236
2026.06.16 18:40:32.016 TestInteractionEA (Volatility 25 Index,M1)      Alert: Object 'M1 Fibo 17345' [FIBO] – INTERACTION_TOUCH from below (4.236) at 2696.35373
2026.06.16 18:52:09.844 TestInteractionEA (USDJPY,M1)   ------ INTERACTIONS DETECTED: 1 ------
2026.06.16 18:52:09.865 TestInteractionEA (USDJPY,M1)     M1 Equidistant Channel 13912 [CHANNEL] Action: 1 Price: 160.41272 Dir: 0 Side: below Level: Base
2026.06.16 18:52:09.909 TestInteractionEA (USDJPY,M1)   Alert: Object 'M1 Equidistant Channel 13912' [CHANNEL] – INTERACTION_TOUCH from below (Base) at 160.41272



Прилагаемые файлы и краткое руководство по установке

К данной статье прилагаются следующие файлы. Первые два файла — это базовые файлы из Частей 1 и 2, оставленные без изменений (за исключением небольшого исправления в ComplexObjectDataCollector.mqh и добавления извлечения опорных точек вил Эндрюса в ChartObjectDetector.mqh).

Имя файлаТипОписание
ChartObjectDetector.mqhПодключаемый файлБазовый детектор из Части 1, теперь с извлечением опорных точек вил Эндрюса.
ComplexObjectDataCollector.mqhПодключаемый файлСборщик данных сложных объектов из Части 2, дополненный поддержкой HLINE и VLINE.
InteractionDetector.mqhПодключаемый файлНовый детектор взаимодействий с отслеживанием состояний по именам объектов, проверкой объектов и описанием уровня.
AlertManager.mqhПодключаемый файлМенеджер оповещений с подавлением повторных оповещений и описанием уровня.
TradeExecutor.mqhПодключаемый файлМодуль исполнения с торговлей при касании с учетом направления и SL/TP, определяемыми по объекту.
TestInteractionEA.mq5СоветникТестовый советник, объединяющий все модули.

Порядок установки:

  1. Поместите все файлы с расширением .mqh в папку MQL5/Include/ChartObjectsAlgorithms/ (если папка отсутствует, создайте её).
  2. Поместите файл TestInteractionEA.mq5 в папку MQL5/Experts/.
  3. Скомпилируйте все файлы (F7 в MetaEditor).
  4. Прикрепите советник к любому графику с нанесенными аналитическими объектами.
  5. Следите за вкладкой "Эксперты", где отображаются журналы взаимодействий и оповещения.



Заключение

Мы завершили переход от статических графических объектов к динамическим торговым сигналам. Используя механизм обнаружения и нормализации, реализованный в Частях 1 и 2, мы добавили слой обработки взаимодействий, менеджер оповещений с учетом состояния и модуль исполнения торговых операций, который определяет параметры риска на основе геометрии объекта. Вся система по-прежнему имеет модульную структуру: вы можете заменить менеджер оповещений собственной логикой уведомлений или модуль исполнения — другой стратегией размещения ордеров, не затрагивая детектор.

Флаги занятости, используемые во всей системе, предотвращают появление дублирующихся сигналов и повторный вход, а цикл OnTick с ограничением частоты выполнения позволяет свести загрузку ЦП к минимуму. Фильтр корректности и отслеживание состояния по именам гарантируют, что оповещения вызывают только актуальные объекты с реалистичными параметрами, а описание уровня позволяет сразу понять суть оповещения. Весь код полностью компилируется и протестирован на реальных графиках. Прилагаемые файлы готовы к использованию в ваших собственных советниках; достаточно подключить заголовочные файлы и создать экземпляры классов.

В следующей статье мы расширим возможности фреймворка, добавив поддержку обнаружения на основе событий через OnChartEvent, что позволит реагировать в режиме реального времени на создание, удаление и изменение объектов. Кроме того, мы добавим функции для программного построения и изменения аналитических объектов непосредственно из советника, что позволит замкнуть цикл между ручным анализом и автоматизированным исполнением.

Перевод с английского произведен MetaQuotes Ltd.
Оригинальная статья: https://www.mql5.com/en/articles/22662

Прикрепленные файлы |
MQL5.zip (13.07 KB)
Измеряем главное (Часть 2): Ковариационная матрица в MQL5 — построение, спектральное разложение и анализ факторов риска Измеряем главное (Часть 2): Ковариационная матрица в MQL5 — построение, спектральное разложение и анализ факторов риска
В Части 2 мы представляем класс CCovarianceMatrix для многократного использования, который вычисляет и сохраняет ковариационную матрицу на основе исходных рядов доходностей с помощью встроенного метода MQL5 Cov(). Мы проверяем симметричность, выводим матрицу в виде таблицы с подписями и вызываем метод Eig(), чтобы получить собственные значения и собственные векторы. Читатели увидят, как совместно изменяются торговые инструменты и какие факторы определяют дисперсию, что позволит нагляднее оценивать состояние портфеля и повторно использовать код в скриптах или советниках.
Разработка собственного торгового советника (Часть 2): Управление рисками и динамический расчет объема позиции Разработка собственного торгового советника (Часть 2): Управление рисками и динамический расчет объема позиции
В этой части реализуется расчет объема позиции для советника с учетом риска. Объем в лотах рассчитывается на основе баланса счета, выбранного процента риска и расстояния до стоп-лосса, определяемого по ATR, а затем ограничивается и округляется с учетом требований брокера к объему и минимальному расстоянию до стоп-лосса. Дополнительный механизм учета просадки снижает риск при уменьшении средств счета. Читатели получают воспроизводимую функцию расчета объема позиции, которая поддерживает стабильный уровень риска на сделку и обеспечивает соответствие ордеров требованиям сервера.
Построение моделей волатильности в MQL5 (Часть IV): Долгая память волатильности — диагностика и реализация FIGARCH и HARCH Построение моделей волатильности в MQL5 (Часть IV): Долгая память волатильности — диагностика и реализация FIGARCH и HARCH
В статье представлены реализации моделей FIGARCH и HARCH на языке MQL5, а также обновлена библиотека волатильности для процессов с долгой памятью. В статье представлен код для проведения тестов Херста и GPH, настройки параметров (усечения и горизонтов), а также скрипты для оценки параметров моделей, прогнозирования и моделирования. Читатели узнают, как применять и сравнивать модели на рыночных данных для выбора подходящей спецификации.
Метаразметка классических стратегий (Часть 3): Фильтрация и определение размера позиций при торговле по полосам Боллинджера Метаразметка классических стратегий (Часть 3): Фильтрация и определение размера позиций при торговле по полосам Боллинджера
Эффективность стратегии возврата к среднему на основе полос Боллинджера снижается в трендовых рыночных режимах, когда ADX высок, а ширина полос увеличивается. Мы отделяем выбор направления сделки от отбора сделок с помощью двухэтапного конвейера метаразметки: вторичный классификатор на основе градиентного бустинга, обученный с использованием PurgedKFold на признаках, характеризующих полосы Боллинджера (BBP, BBB, режим ширины полос), выдает вероятности действий, на основе которых выполняется определение размера позиции. Реализация на MQL5 загружает модель ONNX и определяет размер позиции в рамках архитектуры с двумя торговыми советниками, чтобы отфильтровывать касания полос, дающие сигналы низкого качества.