Разработка инструментария для анализа Price Action (Часть 65): Создание системы для мониторинга и анализа построенных вручную уровней Фибоначчи

Содержание

• Введение
• Знакомство с концепцией
• Реализация на MQL5
• Тестирование и взаимодействие с системой
• Заключение

Введение

Инструмент коррекции Фибоначчи остается одним из самых надежных средств для выявления потенциальных зон реакции в Price Action. На практике эти уровни редко полностью передают автоматизированной системе. Их наносят вручную, опираясь на структуру рынка, интерпретацию свингов и контекст. Такая дискреционность не случайна – эффективность сетапа по Фибоначчи зависит от понимания рынка трейдером, а не от жестких правил.

Проблема возникает после завершения построения. По мере того как на графиках и таймфреймах накапливается все больше структур Фибоначчи, постоянное наблюдение становится непрактичным. Цена может подойти к уровню, коснуться его, пробить или отбиться от него в тот момент, когда внимание направлено на другие задачи (переключение графиков, анализ новых сетапов) или когда трейдер просто отошел от терминала. Такие пропущенные взаимодействия вызваны не слабым анализом, а естественным ограничением отслеживания множества уровней в реальном времени.

В этой статье предлагается решение данной проблемы: ручные построения Фибоначчи сохраняются как основа анализа, а наблюдение за уровнями автоматизируется. Решение состоит в том, чтобы обнаруживать вручную построенные объекты OBJ_FIBO, преобразовывать их уровни в ценовые ориентиры, обрабатывать их жизненный цикл (создание/изменение/удаление) и в реальном времени оценивать поведение цены у каждого уровня.

Знакомство с концепцией

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

В этой статье тот же принцип переносится на еще один важный инструмент анализа Price Action – коррекцию Фибоначчи. Вместо автоматизации самого построения система сохраняет ручное определение структуры и добавляет автоматизацию только на этапе мониторинга. Трейдер задает структуру, а система ее отслеживает.

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

Коррекция Фибоначчи

Инструмент коррекции Фибоначчи основан на последовательности Фибоначчи – числовом ряду, введенном Леонардо из Пизы, в котором каждое число равно сумме двух предыдущих. Соотношения, выведенные из этой последовательности, прежде всего 23,6%, 38,2%, 50%, 61,8% и 78,6%, образуют основу уровней коррекции, используемых в торговле. В анализе Price Action этот инструмент применяют, выбирая на графике две значимые точки – обычно максимум и минимум свинга. Затем между этими точками проецируются уровни коррекции, выделяя потенциальные зоны, где цена может остановиться, развернуться или продолжить движение.

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

Рисунок 1. Построенные вручную уровни коррекции Фибоначчи

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

Ограничения ручного мониторинга

Хотя ручное построение уровней коррекции Фибоначчи обеспечивает гибкость и точность, непрерывный мониторинг этих уровней создает практические трудности.

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

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

От ручного построения к мониторингу советником

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

Рисунок 2. Схема работы системы

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

Так формируется единый рабочий процесс:

• Ручной ввод задает структуру
• Автоматический мониторинг обеспечивает последовательность и непрерывность отслеживания

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

Обзор системы

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

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

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

Реализация на MQL5

В этом разделе показано, как концепция мониторинга построенных вручную уровней коррекции Фибоначчи реализуется на языке MQL5 в виде структурированной событийно-ориентированной системы в терминале MetaTrader 5. Цель не в том, чтобы заменить усмотрение трейдера, а в том, чтобы усилить его – каждый вручную заданный уровень Фибоначчи непрерывно отслеживается, оценивается, а при необходимости система на него реагирует.

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

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

Идентификация советника и параметры компиляции

Реализация начинается с задания параметров идентификации советника и его компиляции. Этот шаг может показаться простым, но он закладывает основу для удобства сопровождения, управления версиями и надежности выполнения.

//+------------------------------------------------------------------+
//|                                             FibonacciMonitor.mq5 |
//|                                               Christian Benjamin |
//|                          https://www.mql5.com/ru/users/lynnchris |
//+------------------------------------------------------------------+
#property copyright "Copyright 2026, Christian Benjamin"
#property link      "https://www.mql5.com/ru/users/lynnchris"
#property version   "1.0"
#property strict

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

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

Настраиваемые входные параметры (слой управления системой)

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

//--- Input parameters
input bool   AlertPopup=true;          // Show popup alert on events
input bool   AlertSound=true;          // Play sound on events
input string SoundFile="alert.wav";    // Sound file name
input bool   PushNotifications=true;   // Send push notification to mobile
input color  MonitorColor=clrBlue;     // Color for monitored lines
input int    LineWidth=2;              // Line thickness after syncing
input color  PendingColor=clrGray;     // Color for newly drawn Fibonacci
input double TouchTolerancePips=0.5;   // Touch tolerance (pips)
input double ApproachZonePips=10.0;    // Approach zone (pips)
input int    PipMultiplier=1;          // Points per pip (10 for forex, 1 for indices/commodities)
input bool   NormalizeLevels=false;    // true: 0% = lowest price, 100% = highest; false: follow drawing direction
input bool   InvertMapping=true;       // true: first anchor = 100%, second anchor = 0% (only when NormalizeLevels=false)
input bool   ShowLabels=true;          // Show labels on the chart
//--- Panel settings
input int    PanelX=10;
input int    PanelY=150;
input color  PanelBgColor=clrWhite;
input color  PanelHeaderColor=clrLightGray;
input color  PanelTextColor=clrBlack;
input int    PanelPadding=4;

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

Параметр ApproachZonePips добавляет слой раннего предупреждения. Вместо реакции только на касание уровня система может сигнализировать уже при подходе цены к зоне интереса. Это особенно полезно для подготовки – можно заранее занять позицию или дождаться подтверждения до фактического взаимодействия.

Параметр PipMultiplier обеспечивает корректное масштабирование для разных инструментов (10 для большинства валютных пар Forex, 1 для индексов и сырьевых товаров). Параметры сопоставления, такие как NormalizeLevels и InvertMapping , обеспечивают корректную интерпретацию уровней Фибоначчи независимо от того, как именно трейдер их построил. Поскольку трейдеры могут строить уровни Фибоначчи в разных направлениях в зависимости от контекста тренда, эти параметры поддерживают логическую согласованность при расчете уровней.

Управление состоянием и структуры данных

Для эффективного мониторинга нескольких уровней Фибоначчи в системе используется структурированное хранение данных с отслеживанием состояния. Это позволяет оценивать каждый уровень по отдельности и последовательно с течением времени.

//--- State management and data structures
enum EMode { MODE_IDLE, MODE_DRAWING, MODE_SYNC_READY };

enum EAlertState 
{ 
   ALERT_NONE, 
   ALERT_APPROACH_SENT, 
   ALERT_TOUCH_SENT,
   ALERT_BREAKOUT_SENT, 
   ALERT_REVERSAL_SENT 
};

struct SMonitoredLevel 
{
   string      name;
   double      levelPercentage;
   string      levelLabel;
   int         lastSide;
   int         sideBeforeTouch;
   bool        alertedBreak;
   datetime    lastTouchBarTime;
   EAlertState alertState;
};

EMode g_mode=MODE_IDLE;
string g_pendingFibo="";
SMonitoredLevel g_monitored[];
int g_panelX,g_panelY;
string g_panelBGName="";

Эта структура – ключевое архитектурное решение. В ней каждый уровень Фибоначчи отслеживается отдельно, что упрощает обнаружение и интерпретацию переходов (касаний, пробоев и разворотов). Вместо того чтобы рассматривать Фибоначчи как единый объект, система разбивает его на отдельные уровни, у каждого из которых есть собственный идентификатор и состояние. С точки зрения торговли это важно, потому что разные уровни Фибоначчи ведут себя по-разному. Уровень 38,2% может выступать точкой продолжения, тогда как 61,8% может указывать на более глубокую коррекцию или разворот. Такое раздельное отслеживание каждого уровня сохраняет это аналитическое различие. С точки зрения программирования наличие таких полей, как lastSide, sideBeforeTouch, alertedBreak и alertState, позволяет обнаруживать переходы, а не только статические состояния. Это позволяет делать более сложные выводы, например подтверждать подлинные пробои или выявлять развороты после ложного движения.

Инициализация и деинициализация советника

Функция OnInit() подготавливает рабочую среду системы и создает интерактивный интерфейс.

//+------------------------------------------------------------------+
//| Expert advisor initialization                                    |
//+------------------------------------------------------------------+
int OnInit() 
  {
   ChartSetInteger(0,CHART_EVENT_OBJECT_CREATE,true);
   ChartSetInteger(0,CHART_EVENT_OBJECT_DELETE,true);

   CreateStyledButton("DrawBtn","Draw Fibo",10,20,120,35,clrGreen,false);
   CreateStyledButton("SynchBtn","Convert & Monitor",10,60,140,35,clrGray,false);
   CreateStyledButton("ClearAllBtn","Clear All Levels",10,100,140,35,clrOrange,false);

   ObjectSetInteger(0,PREFIX+"SynchBtn",OBJPROP_BGCOLOR,clrGray);
   ObjectSetInteger(0,PREFIX+"ClearAllBtn",OBJPROP_BGCOLOR,clrOrange);

   g_panelX=PanelX;
   g_panelY=PanelY;
   ChartRedraw();
   UpdatePanel();
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+

Функция OnDeinit() обеспечивает корректную очистку всех объектов при удалении советника.

//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason) 
  {
   ObjectDelete(0,PREFIX+"DrawBtn");
   ObjectDelete(0,PREFIX+"SynchBtn");
   ObjectDelete(0,PREFIX+"ClearAllBtn");
   DeletePanelObjects();
  }
//+------------------------------------------------------------------+

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

Обработка событий графика (обнаружение объектов, управление кнопками)

Функция OnChartEvent() служит интерфейсом между действиями пользователя и логикой системы.

//+------------------------------------------------------------------+
//| Chart event handler                                              |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,const long &lparam,const double &dparam,const string &sparam)
  {
   if(id==CHARTEVENT_OBJECT_CLICK)
     {
      if(sparam==PREFIX+"DrawBtn")
        {
         if(g_mode==MODE_IDLE)
           {
            g_mode=MODE_DRAWING;
            ObjectSetInteger(0,PREFIX+"DrawBtn",OBJPROP_STATE,true);
            ObjectSetString(0,PREFIX+"DrawBtn",OBJPROP_TEXT,"Draw Fibo (Active)");
            ObjectSetInteger(0,PREFIX+"DrawBtn",OBJPROP_BGCOLOR,clrLightBlue);
            ObjectSetInteger(0,PREFIX+"SynchBtn",OBJPROP_BGCOLOR,clrGray);
            ObjectSetString(0,PREFIX+"SynchBtn",OBJPROP_TEXT,"Convert & Monitor");
           }
         else if(g_mode==MODE_DRAWING)
           {
            g_mode=MODE_IDLE;
            ObjectSetInteger(0,PREFIX+"DrawBtn",OBJPROP_STATE,false);
            ObjectSetString(0,PREFIX+"DrawBtn",OBJPROP_TEXT,"Draw Fibo");
            ObjectSetInteger(0,PREFIX+"DrawBtn",OBJPROP_BGCOLOR,clrGreen);
           }
         ChartRedraw();
        }
      else if(sparam==PREFIX+"SynchBtn")
        {
         if(g_mode==MODE_SYNC_READY && g_pendingFibo!="")
           {
            ProcessFibonacciObject(g_pendingFibo);
            ObjectDelete(0,g_pendingFibo);
            g_mode=MODE_IDLE;
            g_pendingFibo="";
            ObjectSetInteger(0,PREFIX+"DrawBtn",OBJPROP_BGCOLOR,clrGreen);
            ObjectSetInteger(0,PREFIX+"SynchBtn",OBJPROP_BGCOLOR,clrGray);
            ObjectSetString(0,PREFIX+"SynchBtn",OBJPROP_TEXT,"Convert & Monitor");
            ChartRedraw();
            UpdateClearAllButtonState();
            UpdatePanel();
           }
        }
      else if(sparam==PREFIX+"ClearAllBtn")
        {
         ClearAllMonitoredLines();
        }
     }
   else if(id==CHARTEVENT_OBJECT_CREATE)
     {
      if(g_mode==MODE_DRAWING)
        {
         ENUM_OBJECT objType=(ENUM_OBJECT)ObjectGetInteger(0,sparam,OBJPROP_TYPE);
         if(objType==OBJ_FIBO)
           {
            g_pendingFibo=sparam;
            g_mode=MODE_SYNC_READY;
            ObjectSetInteger(0,sparam,OBJPROP_COLOR,PendingColor);
            ObjectSetInteger(0,PREFIX+"SynchBtn",OBJPROP_BGCOLOR,clrOrange);
            ObjectSetString(0,PREFIX+"SynchBtn",OBJPROP_TEXT,"Convert Ready");
            ObjectSetInteger(0,PREFIX+"DrawBtn",OBJPROP_BGCOLOR,clrGreen);
            ObjectSetString(0,PREFIX+"DrawBtn",OBJPROP_TEXT,"Draw Fibo");
            ChartRedraw();
           }
        }
     }
   else if(id==CHARTEVENT_OBJECT_DELETE)
     {
      string objName=sparam;
      for(int i=0; i<ArraySize(g_monitored); i++)
        {
         if(g_monitored[i].name==objName)
           {
            string labelName=objName+"_label";
            if(ObjectFind(0,labelName)>=0) ObjectDelete(0,labelName);
            for(int j=i; j<ArraySize(g_monitored)-1; j++) g_monitored[j]=g_monitored[j+1];
            ArrayResize(g_monitored,ArraySize(g_monitored)-1);
            UpdateClearAllButtonState();
            UpdatePanel();
            break;
           }
        }
      if(g_pendingFibo==objName)
        {
         g_pendingFibo="";
         g_mode=MODE_IDLE;
         ObjectSetInteger(0,PREFIX+"SynchBtn",OBJPROP_BGCOLOR,clrGray);
         ObjectSetString(0,PREFIX+"SynchBtn",OBJPROP_TEXT,"Convert & Monitor");
         ChartRedraw();
        }
     }
   else if(id==CHARTEVENT_OBJECT_DRAG)
     {
      if(sparam==g_panelBGName)
        {
         long newX=ObjectGetInteger(0,g_panelBGName,OBJPROP_XDISTANCE);
         long newY=ObjectGetInteger(0,g_panelBGName,OBJPROP_YDISTANCE);
         int deltaX=(int)newX-g_panelX;
         int deltaY=(int)newY-g_panelY;
         if(deltaX!=0 || deltaY!=0)
           {
            for(int i=ObjectsTotal(0)-1; i>=0; i--)
              {
               string objName=ObjectName(0,i);
               if(StringFind(objName,PANEL_PREFIX)==0)
                 {
                  long objX=ObjectGetInteger(0,objName,OBJPROP_XDISTANCE);
                  long objY=ObjectGetInteger(0,objName,OBJPROP_YDISTANCE);
                  ObjectSetInteger(0,objName,OBJPROP_XDISTANCE,objX+deltaX);
                  ObjectSetInteger(0,objName,OBJPROP_YDISTANCE,objY+deltaY);
                 }
              }
            g_panelX=(int)newX;
            g_panelY=(int)newY;
            ChartRedraw();
           }
        }
     }
  }
//+------------------------------------------------------------------+

Этот событийный механизм обеспечивает эффективность и точность. Вместо непрерывного сканирования объектов система реагирует только при наступлении значимых событий. С точки зрения торговли это сохраняет осознанный характер анализа. Советник не вмешивается в анализ – он лишь отслеживает события и готовится действовать, когда трейдер добавляет структуру Фибоначчи. Введение режимов (MODE_IDLE, MODE_DRAWING, MODE_SYNC_READY) обеспечивает управляемую последовательность работы системы и предотвращает случайный или непреднамеренный мониторинг.

Обработка объектов Фибоначчи и преобразование уровней

После подтверждения объект Фибоначчи нужно преобразовать в набор измеримых уровней.

//+------------------------------------------------------------------+
//| Process Fibonacci object and convert levels                      |
//+------------------------------------------------------------------+
void ProcessFibonacciObject(string fiboName) 
  {
   double price1 = ObjectGetDouble(0,fiboName,OBJPROP_PRICE,0);
   double price2 = ObjectGetDouble(0,fiboName,OBJPROP_PRICE,1);

   int levels = (int)ObjectGetInteger(0,fiboName,OBJPROP_LEVELS);

   for(int i=0; i<levels; i++) 
     {
      double ratio = ObjectGetDouble(0,fiboName,OBJPROP_LEVELVALUE,i);
      double levelPrice = price1 + (price2 - price1) * ratio;

      string lineName = "FiboLevel_" + IntegerToString(i);

      ObjectCreate(0,lineName,OBJ_HLINE,0,0,levelPrice);

      AddMonitoredLevel(lineName,ratio,DoubleToString(ratio*100,1)+"%");
     }
  }
//+------------------------------------------------------------------+

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

Модуль непрерывного мониторинга (выполнение в OnTick)

Процесс мониторинга работает непрерывно в функции OnTick().

//+------------------------------------------------------------------+
//| OnTick event handler                                             |
//+------------------------------------------------------------------+
void OnTick() 
  {
   CheckPriceInteractions();
  }
//+------------------------------------------------------------------+

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

Расширенная оценка ценовых взаимодействий

Функция CheckPriceInteractions() реализует полноценную машину состояний с обнаружением подхода, фиксацией касания на каждом тике, отслеживанием пробоя и логикой разворота после касания. Она также поддерживает масштабирование с учетом особенностей инструмента через PipMultiplier.

//+------------------------------------------------------------------+
//| Check price interactions with monitored levels                   |
//+------------------------------------------------------------------+
void CheckPriceInteractions() 
  {
   double bid = SymbolInfoDouble(_Symbol,SYMBOL_BID);

   for(int i=0; i<ArraySize(g_monitored); i++) 
     {
      double levelPrice = ObjectGetDouble(0,g_monitored[i].name,OBJPROP_PRICE);
      double distance   = MathAbs(bid-levelPrice);

      // Approach zone
      if(distance <= ApproachZonePips * _Point && g_monitored[i].alertState==ALERT_NONE)
        {
         SendNotification("Approaching level",levelPrice);
         g_monitored[i].alertState=ALERT_APPROACH_SENT;
        }

      // Touch
      if(distance <= TouchTolerancePips * _Point && g_monitored[i].alertState!=ALERT_TOUCH_SENT)
        {
         SendNotification("Touch detected",levelPrice);
         g_monitored[i].alertState=ALERT_TOUCH_SENT;
         g_monitored[i].lastTouchBarTime=TimeCurrent();
        }

      // Breakout / Reversal logic (simplified – full version in attached file)
      if(bid > levelPrice && !g_monitored[i].alertedBreak)
        {
         SendNotification("Breakout above",levelPrice);
         g_monitored[i].alertedBreak=true;
        }
      if(bid < levelPrice && !g_monitored[i].alertedBreak)
        {
         SendNotification("Breakout below",levelPrice);
         g_monitored[i].alertedBreak=true;
        }
     }
  }
//+------------------------------------------------------------------+

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

Система алертов и уведомлений

//+------------------------------------------------------------------+
//| Send alert notification                                          |
//+------------------------------------------------------------------+
void SendNotification(string msg,double price) 
  {
   string fullMsg = StringFormat("%s at %G",msg,price);

   if(AlertPopup) Alert(fullMsg);
   if(AlertSound) PlaySound(SoundFile);

   Print(fullMsg);
  }
//+------------------------------------------------------------------+

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

Панель визуального мониторинга

//+------------------------------------------------------------------+
//| Update visual monitoring panel                                   |
//+------------------------------------------------------------------+
void UpdatePanel() 
  {
   string text = "Fibonacci Monitor\n";

   for(int i=0; i<ArraySize(g_monitored); i++) 
     {
      text += g_monitored[i].levelLabel + " : " +
              IntegerToString(g_monitored[i].alertState) + "\n";
     }

   ObjectCreate(0,"Panel",OBJ_LABEL,0,0,0);
   ObjectSetString(0,"Panel",OBJPROP_TEXT,text);
  }
//+------------------------------------------------------------------+

Панель представляет состояние системы в наглядном виде. Вместо визуального просмотра множества уровней трейдер получает структурированную сводку взаимодействий.

Управление жизненным циклом и очистка

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

//+------------------------------------------------------------------+
//| Clear all monitored lines                                        |
//+------------------------------------------------------------------+
void ClearAllMonitoredLines() 
  {
   for(int i=ArraySize(g_monitored)-1; i>=0; i--) 
     {
      ObjectDelete(0,g_monitored[i].name);
     }
   ArrayResize(g_monitored,0);
  }
//+------------------------------------------------------------------+

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

Тестирование и взаимодействие с системой

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

Рисунок 3. Интерфейс советника

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

• Draw Fibo – активирует режим обнаружения и позволяет системе распознать новый вручную построенный объект Фибоначчи. Это гарантирует, что отслеживаются только намеренно построенные вручную структуры.
• Convert & Monitor – преобразует обнаруженную коррекцию Фибоначчи в отдельные горизонтальные уровни и регистрирует их для активного мониторинга. Этот шаг гарантирует, что все уровни будут непрерывно оцениваться по мере изменения цены.
• Clear All Levels – удаляет с графика все отслеживаемые уровни и сбрасывает внутреннюю структуру отслеживания, подготавливая чистое состояние для последующих тестов или нового анализа.

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

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

Тест в реальном времени: мониторинг Фибоначчи на Step Index M1

Ниже приведен тест, который я выполнил на Step Index M1, чтобы проверить интеграцию ручного построения Фибоначчи с автоматическим мониторингом советника:

1. Кнопка Draw Fibo

• Нажата кнопка Draw Fibo.
• Функция успешно выполнена.

2. Ручное построение Фибоначчи

• Совершен переход в меню Вставка → Объекты → Фибоначчи → Линии Фибоначчи.
• Коррекция Фибоначчи была построена вручную на графике.

3. Синхронизация

• Нажата кнопка Convert & Monitor.
• Система обнаружила построенный объект Фибоначчи и запустила непрерывный мониторинг.

4. Мониторинг и алерты

• Когда цена приблизилась к уровню Фибоначчи и коснулась его:
• Сработал алерт.
• График был обновлен, чтобы отразить текущее состояние в реальном времени.

Рисунок 4. Мониторинг в реальном времени на Step Index M1

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

Заключение

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

Следуя шагам, описанным в этой статье, вы создадите полностью работоспособный шаблон советника для MT5, который обеспечивает:

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

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