Showing posts with label Forex Technical analysis. Show all posts
Showing posts with label Forex Technical analysis. Show all posts

Wednesday, August 13, 2025

Money Flow Index Multi-Timeframe Indicator for MT5

August 13, 2025 by Forex Home ExpertNo comments

Introduction

The Money Flow Index Multi-Timeframe (MFI_MTF) Indicator for MetaTrader 5 calculates and scans the Money Flow Index (MFI) on all 21 standard MT5 timeframes (M1 … MN1) and displays per-timeframe signals directly on the chart. The indicator creates a native iMFI handle for every timeframe, draws Wingdings arrow labels per timeframe, and computes a single consensus summary signal (exported as PowerMove[]) when a dominant directional majority exists. An on-chart clickable panel allows instant timeframe switching without reattaching the indicator.

Key Features

  • 21-Timeframe MFI Scanning — MFI is calculated using iMFI(Symbol(), TFId[x], MFI_period, VOLUME_TICK) for each timeframe defined in TFIx[].
  • Per-timeframe Wingdings Arrow Overlay — per timeframe arrow uses windchar (char 108) and colored by inputs ArrowUp, ArrowDn, NTArrow.
  • Consensus Summary Signal — consensus computed in MFIMovementCalculation() and written to PowerMove[]. Condition: up > down + 1 → UP (1.0); down > up + 1 → DOWN (-1.0).
  • Interactive On-Chart Panel — clickable timeframe buttons (CreateButtonClick()) and panel position controls (artop / arbot), handled in OnChartEvent().
  • Customizable Appearance — control font via input f_model (Verdana or Bodoni MT Black), arrow sizes (windsize), and layout offsets (offsetX, offsetY).
  • Alerts — popup alerts plus optional email and push via UseEmailAlert and UseSendnotify. Alerts are sent in Do_Alerts() when curAlert changes.
  • EA-Friendly Output — consensus exported to index buffer: SetIndexBuffer(0, mi.PowerMove, INDICATOR_DATA) so EAs can read 1.0 / -1.0.
  • Clean resource management — all indicator handles are released in OnDeinit() with IndicatorRelease() and chart objects removed via DeletedMFIObject().
Implementation note: This article is faithful to the MFI_MTF.mq5 source (Roberto Jacobs, 2025-01-14). Variable names and behavior described below are taken directly from the source code.

Inputs and Parameters

InputDescription
BarCalcIndicator period for MFI calculation (validated; fallback to 14 if <1)
ArrowUpColor for Up arrow (default clrMediumSeaGreen)
ArrowDnColor for Down arrow (default clrDeepPink)
NTArrowColor for No-Signal arrow (default clrGold)
f_modelFont model enum (Verdana, Bodoni_MT_Black)
alertsPopup alerts toggle (enum YN)
UseEmailAlertEmail alert toggle (enum YN)
UseSendnotifyPush notification toggle (enum YN)

2. About This Indicator

The Money Flow Index Multi-Timeframe (MFI_MTF) Indicator for MetaTrader 5 utilizes a template and displays a panel on the chart.

Its function, operation, and usage are identical to the On Balance Volume Multi-Timeframe Indicator for MT5 (OBV_MTF) as detailed in the previous article. For a comprehensive guide on creating a multi-timeframe indicator, you can refer to the following resources: On Balance Volume Multi-Timeframe Indicator for MT5

🔁 Note: All multi-timeframe indicators developed by Forex Home Expert use this exact signal logic programs structure.

GBPUSDH1_MFI_MTF

How It Works (implementation details)

1. Initialization

OnInit() calls mi.MFI_MTF_Config(). The config routine defines the timeframe array TFIx[] and label array TFSc[], sets tfxar = ArraySize(TFIx), validates BarCalc to set MFI_period, computes ttlbars = BarCalc*3+3, and creates an iMFI handle for each timeframe:

hMFI[x] = iMFI(Symbol(), TFId[x], MFI_period, VOLUME_TICK);
2. Price and Buffer Management

The indicator keeps routines UpdatePrice() and RefreshPrice() to ensure arrays for OHLC, TIME, and VOLUME are prepared if needed. Crucially, MFI values are obtained from the indicator handles via CopyBuffer():

CopyBuffer(hMFI[index], 0, 0, br, MFI);
3. Per-timeframe Direction Scan

MFIDirectionScan(stf, shift) copies br = shift + 2 MFI points and compares MFI[shift] vs MFI[shift+1]:

if (MFI[shift] > MFI[shift+1]) ret = 1; // rise 
if (MFI[shift] < MFI[shift+1]) ret = -1; // down

This uses closed buffer values (historical indices), so past signals are based on confirmed data.

4. Consensus Calculation

MFIMovementCalculation(barCnt) loops through recent bars and for each bar it scans all tfxar timeframes:

  • Initialize up=0, dw=0, set Arwcolor[x] = NTArrow.
  • Call MFIDirectionScan() for each timeframe; increment up or dw and set per-timeframe arrow color.
  • After scanning all timeframes, if up > dw + 1 then PowerMove[i] = 1.0, TColor = ArrowUp, curAlert = 1. If dw > up + 1 then PowerMove[i] = -1.0, TColor = ArrowDn, curAlert = -1.

The consensus buffer PowerMove[] is written to indicator buffer index 0 so other programs (EAs) can read consensus signals.

5. Alerts

Alerts are handled in OnCalculate() after mi.MFIMovementCalculation(limit) runs. If alerts are enabled, the indicator compares current minute (mi.ThisTime(mi.min)) with the previously alerted minute and sends alerts only when the minute changes and curAlert differs from prvAlert. Messages are sent via Do_Alerts() and contain these texts:

  • "The strength of the MFI movement appears to be Rise."
  • "The strength of the MFI movement appears to be Down."
6. UI / Panel / Interaction

DrawMFIObject() draws the main rectangle template (panel), per-timeframe arrow labels (CreateArrowLabel()), and clickable timeframe buttons (CreateButtonClick()). The big consensus arrow uses Wingdings characters (tstar=217 or bstar=218) and the per-timeframe arrows use windchar=108. Clicking a timeframe button triggers OnChartEvent() and the indicator calls ChangeChartSymbol() which runs ChartSetSymbolPeriod(CI, Symbol(), stf) to change the chart timeframe while preserving the indicator display.

How to Trade (code-faithful guidance)

  1. Attach to any chart — the indicator scans all 21 timeframes regardless of the chart timeframe.
  2. Observe per-timeframe arrows — these show the short-term direction of MFI per timeframe as computed by MFIDirectionScan().
  3. Watch the consensus (PowerMove) — a large arrow appears in the panel if up > down + 1 or down > up + 1. The consensus is the main multi-timeframe trigger for trade consideration.
  4. Use alerts — enable alerts, UseEmailAlert, or UseSendnotify to be notified when consensus changes (note: alerts fire only once per minute per change).
  5. Switch timeframe via panel — click a timeframe label to instantly change the chart timeframe while the multi-timeframe scan remains active.
  6. Programmatic access — read PowerMove[] via iCustom() inside an EA to automate decisions based on consensus values (1.0 or -1.0).

Q/A Section

Q1: Which timeframes does the indicator scan?
A: All 21 standard MT5 timeframes declared in the code’s TFIx[] array: M1, M2, M3, M4, M5, M6, M10, M12, M15, M20, M30, H1, H2, H3, H4, H6, H8, H12, D1, W1, MN1.

Q2: How is the MFI period set?
A: The BarCalc input sets the MFI period. If BarCalc < 1 the code falls back to a default MFI_period = 14 and prints a warning.

Q3: Does the indicator repaint?
A: No. The indicator uses CopyBuffer() to read closed/historical MFI buffer values and compares MFI[shift] against MFI[shift+1], so past signals are based on confirmed buffer values.

Q4: When are alerts triggered?
A: Alerts are triggered only when alerts are enabled, the minute changed since the last alert, and curAlert differs from prvAlert. The messages are generated in Do_Alerts().

Q5: How does the consensus logic decide direction?
A: After scanning all timeframes the code counts up and dw. Consensus UP is set when up > dw + 1. Consensus DOWN is set when dw > up + 1. This requires a margin greater than 1 to avoid marginal-majority triggers.

Q6: Can I change where the panel is located?
A: Yes. Use the on-panel buttons (artop / arbot) to move the panel between top and bottom; this is handled by PanelPosChange().

Q7: Can an EA read the indicator output?
A: Yes — PowerMove[] is assigned to the indicator buffer (index 0) via SetIndexBuffer(0, mi.PowerMove, INDICATOR_DATA), so external EAs can read it with iCustom().

Q8: Are external libraries required?
A: No. The indicator uses native MT5 functions only: iMFI, CopyBuffer, object creation APIs, ChartSetSymbolPeriod, SendMail, and SendNotification.

Q9: Which characters are used for arrows?
A: Per-timeframe arrows use windchar = 108 (Wingdings char 108). The summary large arrows use tstar = 217 (up) and bstar = 218 (down).

Q10: What happens at deinit?
A: OnDeinit() releases all iMFI handles (IndicatorRelease(mi.hMFI[x])), deletes drawn objects via mi.DeletedMFIObject(), and calls ChartRedraw().

Final Words

The Money Flow Index Multi-Timeframe Indicator for MT5 indicator is a robust, non-repainting multi-timeframe MFI scanner designed for MT5. Its architecture separates per-timeframe signal extraction (MFIDirectionScan()) from consensus generation (MFIMovementCalculation()), exports the consensus buffer for EA integration, and offers an interactive panel for quick exploration. The indicator cleanly manages indicator handles and drawn objects on deinit and supports popup, email, and push notifications for live monitoring.

We hope that this article and the MFI_MTF or Money Flow Index Multi-Timeframe Indicator for MT5 program will be useful for traders in learning and generating new ideas for trading, who can ultimately make money from home by trading forex.

Thanks for reading this article.

Please download the MFI_MTF indicator: Money Flow Index Multi-Timeframe Indicator for MT5

If you are subscribed to my YouTube Channel, and would like to receive the source program of this article, please send a request via the Contact Us form page, and I will send it to your email, source code: Money Flow Index Multi-Timeframe Indicator for MT5

Don't forget to stop by and subscribe to Forex Home Experts YouTube Channel:

YouTube Channel: @ForexHomeExperts

YouTube Playlist: @ForexHomeExperts YouTube Playlist

Sunday, August 10, 2025

Commodity Channel Index Multi-Timeframe Indicator for MT5

August 10, 2025 by Forex Home ExpertNo comments

1. Introduction

The Commodity Channel Index Multi-Timeframe (CCI MTF) Indicator for MetaTrader 5 provides a comprehensive and compact way to read CCI momentum across all 21 standard timeframes (from M1 to MN1) on a single chart. Instead of switching charts and guessing whether shorter- or longer-term momentum supports your idea, this indicator calculates CCI on each timeframe independently and summarizes directional momentum with per-timeframe arrows plus a majority-based summary signal.

Each arrow corresponds to the directional assessment of the CCI for a particular timeframe:

  • 🟢 Green Arrow = Bullish momentum (CCI moving upward)
  • 🔴 Red Arrow = Bearish momentum (CCI moving downward)
  • ✨ Gold/Neutral Arrow = Neutral / weak/no dominant momentum

🚀 This tool is ideal for multi-timeframe traders, scalpers, and swing traders who want fast visual confirmation across the full timeframe (21 timeframes) spectrum before pulling the trigger.

2. About This Indicator

The Commodity Channel Index Multi-Timeframe Indicator for MT5 (CCI_MTF) utilizes a template and displays a panel on the chart.

Its function, operation, and usage are identical to the On Balance Volume Multi-Timeframe Indicator for MT5 (OBV_MTF) as detailed in the previous article. For a comprehensive guide on creating a multi-timeframe indicator, you can refer to the following resources: On Balance Volume Multi-Timeframe Indicator for MT5

🔁 Note: All multi-timeframe indicators developed by Forex Home Expert use this exact signal logic programs structure.

CCI_MTF

3. Key Features

✅ Full 21-timeframe CCI scanning (M1 → MN1) in one indicator.
✅ Per-timeframe arrow overlays for quick visual scanning.
✅ Majority-based summary signal that reduces noise (summary arrow appears when up > down + 1 or down > up + 1).
✅ Customizable parameters: CCI calculation period (BarCalc), arrow colors, fonts.
✅ On-screen alerts + optional email and push notifications.
✅ Lightweight and optimized for MT5 — uses indicator handles (iCCI) and CopyBuffer for efficient buffer reading.
✅ Non-repainting behavior — uses closed bar data via CopyBuffer() for stable historical signals.
✅ Graphical Interface Panel for Timeframe Switching (via `OnChartEvent`)

4. How It Works (Behind the Scenes)

Commodity Channel Index (CCI) in a Nutshell

CCI is a momentum oscillator that measures the difference between a typical price and its moving average, normalized by mean absolute deviation. Common interpretation:

  • CCI > +100 → strong bullish momentum / overbought region
  • CCI < -100 → strong bearish momentum / oversold region

5. Multi-Timeframe Signal Logic

The indicator operates in two main steps:

  1. Create a handle for the CCI on each timeframe using iCCI() and keep those handles in an array (one per timeframe).
  2. For each bar the indicator examines, read the most recent closed CCI value(s) using CopyBuffer() and determine whether the CCI is rising or falling on that timeframe. Count the timeframes that are rising (up) vs falling (down). When the count for one direction exceeds the other by more than one (up > down + 1 or down > up + 1) a summary arrow is shown.

6. Relevant Code Snippets

Technical Overview: How the Indicator Works


//--
enum YN
  {
   No,
   Yes
  };
//--
enum fonts
  {
   Verdana,
   Bodoni_MT_Black
  };
//--
//-- Input Parameter
//---
input group   "====  Indicator Period Calculation  ===="
input int                BarCalc = 14;                // Input Indicator Period
input group   "====  Indicator Color and Font   ===="
input color              ArrowUp = clrMediumSeaGreen; // Arrow Up Color
input color              ArrowDn = clrDeepPink;       // Arrow Down Color
input color              NTArrow = clrGold;           // Arrow No Signal
input fonts              f_model = Bodoni_MT_Black;   // Select Font Model
input group   "====  Input parameters for alerts  ===="
input YN                  alerts = Yes;               // Display Alerts Pop-up on Chart (Yes) or (No)
input YN           UseEmailAlert = No;                // Email Alert (Yes) or (No)
input YN           UseSendnotify = No;                // Send Notification (Yes) or (No)
//---

Timeframe Management

The indicator prepares and manages handles for all standard MT5 timeframes:


   virtual void      CCI_MTF_Config(void)
     {
      //--
      ENUM_TIMEFRAMES TFIx[]= {PERIOD_M1,PERIOD_M2,PERIOD_M3,PERIOD_M4,PERIOD_M5,PERIOD_M6,PERIOD_M10,PERIOD_M12,PERIOD_M15,
                               PERIOD_M20,PERIOD_M30,PERIOD_H1,PERIOD_H2,PERIOD_H3,PERIOD_H4,PERIOD_H6,PERIOD_H8,PERIOD_H12,
                               PERIOD_D1,PERIOD_W1,PERIOD_MN1};
      tfxar=ArraySize(TFIx);
      ArrayResize(TFId,tfxar,tfxar);
      ArrayResize(Arwcolor,tfxar,tfxar);
      ArrayCopy(TFId,TFIx,0,0,WHOLE_ARRAY);
      //--
      string TFxc[]= {"M1","M2","M3","M4","M5","M6","M10","M12","M15","M20","M30","H1",                   "H2","H3","H4","H6","H8","H12","D1","W1","MN1"}; // 21 Timeframes
      //--
      ArrayResize(hCCI,tfxar,tfxar);
      ArrayResize(TFSc,tfxar,tfxar);
      ArrayCopy(TFSc,TFxc,0,0,WHOLE_ARRAY);
      //--
      if(BarCalc<1)
        {
         CCI_period=14;
         PrintFormat("Incorrect value for input variable BarCalc = %d. Indicator will use value %d for calculations.",
                  BarCalc,CCI_period);
        }
      else
         CCI_period=BarCalc;
      //--
      ttlbars=BarCalc*3+3;
      //--
      for(int x=0; x<tfxar; x++)
        hCCI[x]=iCCI(Symbol(),TFId[x],CCI_period,PRICE_TYPICAL); // Handle of iCCI Indicator on each timeframe
      //--
      DeletedCCIObject();
      CCIMovementCalculation(25);
      PositionCore();
      //--
      if(display)
         DrawCCIObject();
      //---
     }
   //---

Signal Extraction Logic

Each timeframe is scanned using:


   //---
   //---
   int               CCIDirectionScan(const ENUM_TIMEFRAMES stf,int shift) // Scan OBV Direction
     {
      //--
      int ret=0;
      int rise=1,
          down=-1;
      //--
      int br=shift+2;
      double res=0.0;
      UpdatePrice(stf);
      //--
      double CCI[];
      ArrayResize(CCI,br,br);
      ArraySetAsSeries(CCI,true);
      //--
      int xx=TFIndexArray(stf);
      CopyBuffer(hCCI[xx],0,0,br,CCI);
      //--
      if(CCI[shift]>CCI[shift+1]) ret=rise;
      if(CCI[shift]<CCI[shift+1]) ret=down;
      //--
      return(ret);
      //---
     } //-end CCIDirectionScan()
   //---

Consensus Calculation Logic.


   //---
   void              CCIMovementCalculation(int barCnt) // Scan the direction of iCCI on each timeframe
     {
      //--
      ArrayResize(PowerMove,barCnt,barCnt);
      ArraySetAsSeries(PowerMove,true);
      //--
      for(int i=barCnt-1; i>=0; i--)
        {
         up=0;
         dw=0;
         //--
         for(int x=0; x<tfxar; x++)
           {
            Arwcolor[x]=NTArrow;
            PowerMove[i]=0.0;
            int PPM=CCIDirectionScan(TFId[x],0);
            if(PPM>0)
              {
               up++;
               Arwcolor[x]=ArrowUp;
              }
            if(PPM<0)
              {
               dw++;
               Arwcolor[x]=ArrowDn;
              }
            if(x==tfxar-1)
              {
               if(up>dw+1)
                 {
                  PowerMove[i]=1.0;
                  TColor=ArrowUp;
                  curAlert=1;
                 }
               if(dw>up+1)
                 {
                  PowerMove[i]=-1.0;
                  TColor=ArrowDn;
                  curAlert=-1;
                 }
              }
           }
        }
      //--
      return;
      //---
     } //-end CCIMovementCalculation()
   //---
/*
This logic ensures that only dominant directional consensus (not slight differences) triggers a clear summary signal.
*/

Indicator signal calculation starts from OnCalculate(...)


//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
   ResetLastError();
   //--
   int limit;
   limit=rates_total-prev_calculated;
   if(prev_calculated>0)
      limit++;
   if(limit>mi.ttlbars)
      limit=mi.ttlbars;
   if(limit-3<=1)
      limit=3;
   //--
   mi.CCIMovementCalculation(limit);
   //--
   if(alerts==Yes||UseEmailAlert==Yes||UseSendnotify==Yes)
     {
       mi.curmin=mi.ThisTime(mi.min);
       if(mi.curmin!=mi.prvmin && mi.curAlert==1 && mi.curAlert!=mi.prvAlert)
         {
           string AlertTxt="The strength of the CCI movement appears to be Rise.";
           mi.Do_Alerts(AlertTxt);
           mi.prvAlert=mi.curAlert;
           mi.prvmin=mi.curmin;
         }
       if(mi.curmin!=mi.prvmin && mi.curAlert==-1 && mi.curAlert!=mi.prvAlert)
         {
           string AlertTxt="The strength of the CCI movement appears to be Down.";
           mi.Do_Alerts(AlertTxt);
           mi.prvAlert=mi.curAlert;
           mi.prvmin=mi.curmin;
         }
     }
   //--
   if(mi.display)
     mi.DrawCCIObject();
   //---
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//---------//

Function DrawCCIObject() – Drawing multi-timeframe CCI results.


   //---
   void              DrawCCIObject(void)
     {
      //--
CreateButtonTemplate(CI,ObjName+"Template",397,66,STYLE_SOLID,9,BORDER_RAISED,clrMistyRose,clrLavenderBlush,clrWhite,bcor,corx,cory,true);
      for(int x=0; x<tfhalf; x++)
        {
         CreateArrowLabel(CI,ObjName+"_win_arrow_"+string(x),CharToString((uchar)windchar),"Wingdings",windsize,Arwcolor[x],bcor,
                             txttf+horizL1+(x*scaleX)+offsetX+x,vertiL1,true,"Arrow_"+TFSc[x]);
         CreateButtonClick(CI,TFSc[x],27,15,font_mode,fontSize,BORDER_FLAT,TFSc[x],clrBurlyWood,clrSilver,clrBlue,
                              bcor,txttf+horizL2+(x*scaleA)+offsetX,vertiL2,true,
                              "Change Timeframe to : "+TFSc[x]);
        }
      for(int x=tfhalf, x2=0; x<tfxar; x++, x2++)
        {
         CreateArrowLabel(CI,ObjName+"_win_arrow_"+string(x),CharToString((uchar)windchar),"Wingdings",windsize,Arwcolor[x],bcor,
                             txttf+horizL3+(x2*scaleX)+offsetX+x2,vertiL3,true,"Arrow_"+TFSc[x]);
         CreateButtonClick(CI,TFSc[x],27,15,font_mode,fontSize,BORDER_FLAT,TFSc[x],clrBurlyWood,clrSilver,clrBlue,
                              bcor,txttf+horizL4+(x2*scaleA)+offsetX,vertiL4,true,
                              "Change Timeframe to : "+TFSc[x]);
         //--
         if(x==20)
           {
            int arrowChar=TColor==ArrowUp ? 200 : TColor==ArrowDn ? 202 : windchar;
            CreateArrowLabel(CI,ObjName+"_tfx_arrow_"+string(x+1),"Move",font_mode,fontSize,clrBlue,bcor,
                                519+horizL5,vertiL5,true,"Move");
            CreateArrowLabel(CI,ObjName+"_win_arrow_"+string(x+1),CharToString((uchar)arrowChar),"Wingdings",15,TColor,bcor,
                                522+horizL6,vertiL6,true,"Arrow Indicator Movement");
           }
        }
      DisplayButtonClick("X");
      CreateButtonTemplate(CI,ObjName+"TemplateName1",17,15,STYLE_SOLID,1,BORDER_FLAT,clrMistyRose,clrLavenderBlush,clrWhite,bcor,TNamex,TNamey1,true);
      CreateButtonTemplate(CI,ObjName+"TemplateName2",17,15,STYLE_SOLID,1,BORDER_FLAT,clrMistyRose,clrLavenderBlush,clrWhite,bcor,TNamex,TNamey2,true);
      CreateButtonTemplate(CI,ObjName+"TemplateName3",17,15,STYLE_SOLID,1,BORDER_FLAT,clrMistyRose,clrLavenderBlush,clrWhite,bcor,TNamex,TNamey3,true);
      CreateArrowLabel(CI,ObjName+"_name1",hName1,font_mode,fontSize+1,clrBlue,bcor,TNamexn,TNamey1n,true,hName1);
      CreateArrowLabel(CI,ObjName+"_name2",hName2,font_mode,fontSize+1,clrBlue,bcor,TNamexn,TNamey2n,true,hName2);
      CreateArrowLabel(CI,ObjName+"_name3",hName3,font_mode,fontSize+1,clrBlue,bcor,TNamexn,TNamey3n,true,hName3);
      //--
      if(corpos==postop)
        {
          DisplayButtonClick("cstar");
          DisplayButtonClick("arbot");
        }
      if(corpos==posbot)
        {
          DisplayButtonClick("cstar");
          DisplayButtonClick("artop");
        }
      //--
      return;
      //---
     } //-end DrawCCIObject()
   //---
 //- This function is responsible for creating labels on the chart for each timeframe, with colors according to Overbought (green), Oversold (red), or No Signal (gold) Neutral conditions.

Dynamic Timeframe Panel OnChartEvent() Fuction

The indicator creates a clickable panel on the chart containing labels for all 21 timeframes. When a label (e.g., "H4") is clicked, the internal reference timeframe for analysis is updated, and the timeframe is changed to H4.

This makes it easy for the user to interact with the indicator dynamically.


//+------------------------------------------------------------------+
//| ChartEvent function                                              |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//---
//--- handling CHARTEVENT_CLICK event ("Clicking the chart")
   ResetLastError();
//--
   if(id==CHARTEVENT_OBJECT_CLICK)
     {
      //--- if "X" button is click
      if(sparam=="X")
        {
         mi.DeletedCCIObject();
         //--- unpress the button
         ObjectSetInteger(mi.CI,"X",OBJPROP_STATE,false);
         ObjectSetInteger(mi.CI,"X",OBJPROP_ZORDER,0);
         //--
         mi.display=false;
         ObjectDelete(mi.CI,"X");
         mi.DisplayPanelButton();
        }
      //--- if "cstar" button is click
      if(sparam==mi.cstar)
        {
         mi.DeletedCCIObject();
         mi.DisplayPanelButton();
         //--- unpress the button
         ObjectSetInteger(mi.CI,mi.cstar,OBJPROP_STATE,false);
         ObjectSetInteger(mi.CI,mi.cstar,OBJPROP_ZORDER,0);
         if(!mi.display)
            mi.display=true;
         if(mi.corpos==mi.posbot) ObjectDelete(mi.CI,mi.arbot);
         if(mi.corpos==mi.postop) ObjectDelete(mi.CI,mi.artop);
         mi.DrawCCIObject();
         //--
         ChartRedraw(mi.CI);
        }
      //--- if "artop" button is click
      if(sparam==mi.artop)
        {
         mi.DeletedCCIObject();
         mi.DisplayPanelButton();
         //--- unpress the button
         ObjectSetInteger(mi.CI,mi.artop,OBJPROP_STATE,false);
         ObjectSetInteger(mi.CI,mi.artop,OBJPROP_ZORDER,0);
         if(!mi.display)
            mi.display=true;
         ObjectDelete(mi.CI,mi.artop);
         mi.PanelPosChange(mi.postop);
         //--
         ObjectDelete(mi.CI,"X");
         mi.DisplayButtonClick("arbot");
         mi.DrawCCIObject();
         //--
         ChartRedraw(mi.CI);
        }
      //--- if "arbot" button is click
      if(sparam==mi.arbot)
        {
         mi.DeletedCCIObject();
         mi.DisplayPanelButton();
         //--- unpress the button
         ObjectSetInteger(mi.CI,mi.arbot,OBJPROP_STATE,false);
         ObjectSetInteger(mi.CI,mi.arbot,OBJPROP_ZORDER,0);
         if(!mi.display)
            mi.display=true;
         ObjectDelete(mi.CI,mi.arbot);
         mi.PanelPosChange(mi.posbot);
         //--
         ObjectDelete(mi.CI,"X");
         mi.DisplayButtonClick("artop");
         mi.DrawCCIObject();
         //--
         ChartRedraw(mi.CI);
        }
      //--- if TF button is click
      //--
      if(sparam==mi.TFSc[0])
        {
         mi.ChangeChartSymbol(mi.TFSc[0],mi.TFId[0]);
        }
      //--
      if(sparam==mi.TFSc[1])
        {
         mi.ChangeChartSymbol(mi.TFSc[1],mi.TFId[1]);
        }
      //--
      if(sparam==mi.TFSc[2])
        {
         mi.ChangeChartSymbol(mi.TFSc[2],mi.TFId[2]);
        }
      //--
      if(sparam==mi.TFSc[3])
        {
         mi.ChangeChartSymbol(mi.TFSc[3],mi.TFId[3]);
        }
      //--
      if(sparam==mi.TFSc[4])
        {
         mi.ChangeChartSymbol(mi.TFSc[4],mi.TFId[4]);
        }
      //--
      if(sparam==mi.TFSc[5])
        {
         mi.ChangeChartSymbol(mi.TFSc[5],mi.TFId[5]);
        }
      //--
      if(sparam==mi.TFSc[6])
        {
         mi.ChangeChartSymbol(mi.TFSc[6],mi.TFId[6]);
        }
      //--
      if(sparam==mi.TFSc[7])
        {
         mi.ChangeChartSymbol(mi.TFSc[7],mi.TFId[7]);
        }
      //--
      if(sparam==mi.TFSc[8])
        {
         mi.ChangeChartSymbol(mi.TFSc[8],mi.TFId[8]);
        }
      //--
      if(sparam==mi.TFSc[9])
        {
         mi.ChangeChartSymbol(mi.TFSc[9],mi.TFId[9]);
        }
      //--
      if(sparam==mi.TFSc[10])
        {
         mi.ChangeChartSymbol(mi.TFSc[10],mi.TFId[10]);
        }
      //--
      if(sparam==mi.TFSc[11])
        {
         mi.ChangeChartSymbol(mi.TFSc[11],mi.TFId[11]);
        }
      //--
      if(sparam==mi.TFSc[12])
        {
         mi.ChangeChartSymbol(mi.TFSc[12],mi.TFId[12]);
        }
      //--
      if(sparam==mi.TFSc[13])
        {
         mi.ChangeChartSymbol(mi.TFSc[13],mi.TFId[13]);
        }
      //--
      if(sparam==mi.TFSc[14])
        {
         mi.ChangeChartSymbol(mi.TFSc[14],mi.TFId[14]);
        }
      //--
      if(sparam==mi.TFSc[15])
        {
         mi.ChangeChartSymbol(mi.TFSc[15],mi.TFId[15]);
        }
      //--
      if(sparam==mi.TFSc[16])
        {
         mi.ChangeChartSymbol(mi.TFSc[16],mi.TFId[16]);
        }
      //--
      if(sparam==mi.TFSc[17])
        {
         mi.ChangeChartSymbol(mi.TFSc[17],mi.TFId[17]);
        }
      //--
      if(sparam==mi.TFSc[18])
        {
         mi.ChangeChartSymbol(mi.TFSc[18],mi.TFId[18]);
        }
      //--
      if(sparam==mi.TFSc[19])
        {
         mi.ChangeChartSymbol(mi.TFSc[19],mi.TFId[19]);
        }
      //--
      if(sparam==mi.TFSc[20])
        {
         mi.ChangeChartSymbol(mi.TFSc[20],mi.TFId[20]);
        }
      //--
     }
//---
  } //-end OnChartEvent()
//---------//

7. How to Use It

  1. Attach the Indicator — Add CCI_MTF to any chart (e.g., EURUSD H1).
  2. Configure Settings — Open the indicator inputs to set BarCalc, choose arrow colors, font, and turn alerts on/off.
  3. Indicator wiil Interpret Signals — Look for alignment across timeframes and the summary arrow.
  4. Confirm with Price Action — Validate with swing structure, support/resistance, or another momentum/confirmation indicator (moving averages, RSI, etc.).
  5. Trend-following entry: — enter in direction of majority summary arrow on a pullback in your execution timeframe.
  6. Counter-trend: — trade only with defined risk and confluence (e.g., bullish divergence on CCI + summary turning bullish).

8. FAQ

Q1: What does the indicator measure?
A1: It measures the direction of the CCI on each timeframe — whether the recent closed CCI values are moving upward or downward — then aggregates those direction votes into a majority-based summary.

Q2: How is the summary arrow calculated?
A2: The indicator counts how many timeframes show “up” vs “down.” If up > down + 1, a summary up arrow is shown. If down > up + 1, a summary down arrow is shown. This reduces false signals from single-timeframe noise.

Q3: Does this indicator repaint?
A3: No. It uses CopyBuffer() to read closed-bar values from iCCI handles, which prevents repainting and ensures stable historical signals.

Q4: Which CCI period does it use?
A4: The default BarCalc (period) is configurable. Many traders use 14 as a starting point, but you can change it to suit your strategy.

Q5: Can I get alerts when the summary changes?
A5: Yes. The indicator includes on-screen alerts and optional email and push notifications (controlled by alerts, UseEmailAlert, and UseSendnotify inputs).

Q6: Is it resource heavy?
A6: No. The indicator uses MT5 indicator handles (iCCI) and CopyBuffer() calls efficiently. It is designed to be lightweight even while scanning 21 timeframes.

Q7: Can I change which timeframes are scanned?
A7: The indicator creates a clickable panel on the chart containing labels for all 21 timeframes (M1 → MN1). When a label (e.g., "H8") is clicked, the internal reference timeframe for analysis is updated, and the timeframe is changed to H8.

Q8: How to combine it with other indicators?
A8: Good compliment indicators are moving averages (for trend direction), RSI (for momentum confirmation), or price action signals for entry timing.

Q9: Suitable for which instruments?
A9: Works on forex, indices, commodities, stocks, and crypto — any instrument supported by MT5.

9. Conclusion

The Commodity Channel Index Multi-Timeframe (CCI_MTF) Indicator for MT5 gives traders an organized, low-noise way to read momentum across the entire range of MT5 timeframes. By using a majority-vote method and reliable closed-bar buffer reads, it delivers practical signals for both scalpers and swing traders. Combine it with price-action validation or a complementary indicator to refine entries and exits.

We hope that this article and the CCI_MTF or Commodity Channel Index Multi-Timeframe Indicator for MT5 program will be useful for traders in learning and generating new ideas for trading, who can ultimately make money from home by trading forex.

Thanks for reading this article.

Please download the CCI_MTF indicator: Commodity Channel Index Multi-Timeframe Indicator for MT5

If you are subscribed to my YouTube Channel, and would like to receive the source program of this article, please send a request via the Contact Us form page, and I will send it to your email, source code: Commodity Channel Index Multi-Timeframe Indicator for MT5

Don't forget to stop by and subscribe to Forex Home Experts YouTube Channel:

YouTube Channel: @ForexHomeExperts

YouTube Playlist: @ForexHomeExperts YouTube Playlist

Thursday, August 7, 2025

Average Directional Movement Index Multi-Timeframe Indicator for MT5

August 07, 2025 by Forex Home ExpertNo comments

Introduction

The Average Directional Movement Index Multi-Timeframe (ADX MTF) Indicator for MetaTrader 5 provides directional signals from all 21 standard timeframes, ranging from M1 to MN1.

For each timeframe, it displays a directional arrow object (`OBJ_ARROW`) using Wingdings character 108:

🟢 Green arrow = upward ADX signal
🔴 Red arrow = downward ADX signal

After gathering these signals, the indicator calculates a consensus summary using a unique logic:
If the number of **up** signals is greater than **down + 1**, the indicator plots a larger **Wingdings 217** upward arrow * If the number of **down** signals is greater than **up + 1**, it plots a larger **Wingdings 218** downward arrow

This enables traders to view a high-confidence trend direction based on multi-timeframe ADX analysis directly on the main chart.

🔁 Note: All multi-timeframe indicators developed by Forex Home Expert use this exact signal logic structure.

The Average Directional Movement Index Multi-Timeframe indicator for MT5 (ADX_MTF) utilizes a template and displays a panel on the chart. Its function, operation, and usage are identical to the Strength of Price Movement Multi Timeframe indicator (SPM_MTF) as detailed in the previous article. For a comprehensive guide on creating a multi-timeframe indicator, you can refer to the following resources: Strength of Price Movement Multi Timeframe indicator for MT5

Average Directional Movement Index Multi-Timeframe indicator for MT5

Key Features:

✅ 21-Timeframe Directional ADX Scanning
✅ Wingdings Arrows Overlay (per timeframe)
✅ Summary Arrow with Up/Down Consensus Calculation
✅ Color Customization for Each Signal
✅ Built-in Alerts (pop-up, email, mobile)
✅ Graphical Interface Panel for Timeframe Switching (via `OnChartEvent`)

Inputs and Parameters

| Input | Description | | --------------- | ------------------------------------------ |
| `BarCalc` | Bars used for ADX signal scan |
| `ArrowUp` | Color of up signal arrow |
| `ArrowDn` | Color of down signal arrow |
| `NTArrow` | Color of neutral arrow (default) |
| `f_model` | Font type for arrows (usually "Wingdings") |
| `alerts` | Enable/disable alert popups |
| `UseEmailAlert` | Enable email alerts |
| `UseSendnotify` | Enable push notification alerts |

Why Multi-Timeframe ADX Matters?

The ADX is powerful for identifying **trend strength** but lacks insight into **trend consistency** across timeframes. This custom ADX_MTF indicator solves that:

📈 Confirm short-term trades with long-term trend backing
⚠️ Avoid sideways or weak markets using visual confirmation
🚨 Detect powerful breakouts supported by multiple timeframe trends

Using **all 21 timeframes** (from M1 to MN1) ensures broad trend consistency in your decision-making process.

Technical Overview: How the Indicator Works

Timeframe Management

The indicator prepares and manages handles for all standard MT5 timeframes:


ENUM_TIMEFRAMES TFId[] = {PERIOD_M1, PERIOD_M2, ..., PERIOD_MN1};
int tfxar = ArraySize(TFId);  // total 21 timeframes


/*
Handles for all timeframe-specific ADX indicators are stored in `hADXp[]` and initialized inside `OnInit()` using `iADX()` for each timeframe.
*/

Signal Extraction Logic

Each timeframe is scanned using:


   //---
   int ADXDirectionScan(const ENUM_TIMEFRAMES stf,int shift) // Scan ADX Direction
     {
      //--
      int ret=0;
      int rise=1,
          down=-1;
      //--
      int br=shift+2;
      double res=0.0;
      UpdatePrice(stf);
      //--
      double ADXp[];
      ArrayResize(ADXp,br,br);
      ArraySetAsSeries(ADXp,true);
      //--
      int xx=TFIndexArray(stf);
      CopyBuffer(hADXp[xx],1,0,br,ADXp); // We will use ADX indicator buffer for DI+
      //--
      if(ADXp[shift]&gt;ADXp[shift+1]) ret=rise;
      if(ADXp[shift]&lt;ADXp[shift+1]) ret=down;
      //--
      return(ret);
      //---
     } //-end ADXDirectionScan()
   //---
   
/*
This compares DI+ values (buffer 1) to detect rising or falling strength.
*/

Consensus Calculation Logic.


   //---
   void ADXMovementCalculation(int barCnt) // Scan the direction of iADX on each timeframe
     {
      //--
      ArrayResize(PowerMove,barCnt,barCnt);
      ArraySetAsSeries(PowerMove,true);
      //--
      for(int i=barCnt-1; i>=0; i--)
        {
         up=0;
         dw=0;
         //--
         for(int x=0; x<tfxar; x++)
           {
            Arwcolor[x]=NTArrow;
            PowerMove[i]=0.0;
            int PPM=ADXDirectionScan(TFId[x],0);
            if(PPM>0)
              {
               up++;
               Arwcolor[x]=ArrowUp;
              }
            if(PPM<0)
              {
               dw++;
               Arwcolor[x]=ArrowDn;
              }
            if(x==tfxar-1)
              {
               if(up>dw+1)
                 {
                  PowerMove[i]=1.0;
                  TColor=ArrowUp;
                  curAlert=1;
                 }
               if(dw>up+1)
                 {
                  PowerMove[i]=-1.0;
                  TColor=ArrowDn;
                  curAlert=-1;
                 }
              }
           }
        }
      //--
      return;
      //---
     } //-end ADXMovementCalculation()
   //---

/*
This logic ensures that only dominant directional consensus (not slight differences) triggers a clear summary signal.
*/

Dynamic Timeframe Panel (OnChartEvent)

The indicator creates a clickable panel on the chart containing labels for all 21 timeframes. When a label (e.g., "H4") is clicked, the internal reference timeframe for analysis is updated.

This makes it easy for the user to interact with the indicator dynamically.


void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
//---
//--- handling CHARTEVENT_CLICK event ("Clicking the chart")
   ResetLastError();
//--
   if(id==CHARTEVENT_OBJECT_CLICK)
     {
      //--- if "X" button is click
      if(sparam=="X")
        {
         mi.DeletedADXObject();
         //--- unpress the button
         ObjectSetInteger(mi.CI,"X",OBJPROP_STATE,false);
         ObjectSetInteger(mi.CI,"X",OBJPROP_ZORDER,0);
         //--
         mi.display=false;
         ObjectDelete(mi.CI,"X");
         mi.DisplayPanelButton();
        }
      //--- if "cstar" button is click
      if(sparam==mi.cstar)
        {
         mi.DeletedADXObject();
         mi.DisplayPanelButton();
         //--- unpress the button
         ObjectSetInteger(mi.CI,mi.cstar,OBJPROP_STATE,false);
         ObjectSetInteger(mi.CI,mi.cstar,OBJPROP_ZORDER,0);
         if(!mi.display)
            mi.display=true;
         if(mi.corpos==mi.posbot) ObjectDelete(mi.CI,mi.arbot);
         if(mi.corpos==mi.postop) ObjectDelete(mi.CI,mi.artop);
         mi.DrawADXObject();
         //--
         ChartRedraw(mi.CI);
        }
      //--- if "artop" button is click
      if(sparam==mi.artop)
        {
         mi.DeletedADXObject();
         mi.DisplayPanelButton();
         //--- unpress the button
         ObjectSetInteger(mi.CI,mi.artop,OBJPROP_STATE,false);
         ObjectSetInteger(mi.CI,mi.artop,OBJPROP_ZORDER,0);
         if(!mi.display)
            mi.display=true;
         ObjectDelete(mi.CI,mi.artop);
         mi.PanelPosChange(mi.postop);
         //--
         ObjectDelete(mi.CI,"X");
         mi.DisplayButtonClick("arbot");
         mi.DrawADXObject();
         //--
         ChartRedraw(mi.CI);
        }
      //--- if "arbot" button is click
      if(sparam==mi.arbot)
        {
         mi.DeletedADXObject();
         mi.DisplayPanelButton();
         //--- unpress the button
         ObjectSetInteger(mi.CI,mi.arbot,OBJPROP_STATE,false);
         ObjectSetInteger(mi.CI,mi.arbot,OBJPROP_ZORDER,0);
         if(!mi.display)
            mi.display=true;
         ObjectDelete(mi.CI,mi.arbot);
         mi.PanelPosChange(mi.posbot);
         //--
         ObjectDelete(mi.CI,"X");
         mi.DisplayButtonClick("artop");
         mi.DrawADXObject();
         //--
         ChartRedraw(mi.CI);
        }
      //--- if TF button is click
      //--
      if(sparam==mi.TFSc[0])
        {
         mi.ChangeChartSymbol(mi.TFSc[0],mi.TFId[0]);
        }
      //--
      if(sparam==mi.TFSc[1])
        {
         mi.ChangeChartSymbol(mi.TFSc[1],mi.TFId[1]);
        }
      //--
      if(sparam==mi.TFSc[2])
        {
         mi.ChangeChartSymbol(mi.TFSc[2],mi.TFId[2]);
        }
      //--
      if(sparam==mi.TFSc[3])
        {
         mi.ChangeChartSymbol(mi.TFSc[3],mi.TFId[3]);
        }
      //--
      if(sparam==mi.TFSc[4])
        {
         mi.ChangeChartSymbol(mi.TFSc[4],mi.TFId[4]);
        }
      //--
      if(sparam==mi.TFSc[5])
        {
         mi.ChangeChartSymbol(mi.TFSc[5],mi.TFId[5]);
        }
      //--
      if(sparam==mi.TFSc[6])
        {
         mi.ChangeChartSymbol(mi.TFSc[6],mi.TFId[6]);
        }
      //--
      if(sparam==mi.TFSc[7])
        {
         mi.ChangeChartSymbol(mi.TFSc[7],mi.TFId[7]);
        }
      //--
      if(sparam==mi.TFSc[8])
        {
         mi.ChangeChartSymbol(mi.TFSc[8],mi.TFId[8]);
        }
      //--
      if(sparam==mi.TFSc[9])
        {
         mi.ChangeChartSymbol(mi.TFSc[9],mi.TFId[9]);
        }
      //--
      if(sparam==mi.TFSc[10])
        {
         mi.ChangeChartSymbol(mi.TFSc[10],mi.TFId[10]);
        }
      //--
      if(sparam==mi.TFSc[11])
        {
         mi.ChangeChartSymbol(mi.TFSc[11],mi.TFId[11]);
        }
      //--
      if(sparam==mi.TFSc[12])
        {
         mi.ChangeChartSymbol(mi.TFSc[12],mi.TFId[12]);
        }
      //--
      if(sparam==mi.TFSc[13])
        {
         mi.ChangeChartSymbol(mi.TFSc[13],mi.TFId[13]);
        }
      //--
      if(sparam==mi.TFSc[14])
        {
         mi.ChangeChartSymbol(mi.TFSc[14],mi.TFId[14]);
        }
      //--
      if(sparam==mi.TFSc[15])
        {
         mi.ChangeChartSymbol(mi.TFSc[15],mi.TFId[15]);
        }
      //--
      if(sparam==mi.TFSc[16])
        {
         mi.ChangeChartSymbol(mi.TFSc[16],mi.TFId[16]);
        }
      //--
      if(sparam==mi.TFSc[17])
        {
         mi.ChangeChartSymbol(mi.TFSc[17],mi.TFId[17]);
        }
      //--
      if(sparam==mi.TFSc[18])
        {
         mi.ChangeChartSymbol(mi.TFSc[18],mi.TFId[18]);
        }
      //--
      if(sparam==mi.TFSc[19])
        {
         mi.ChangeChartSymbol(mi.TFSc[19],mi.TFId[19]);
        }
      //--
      if(sparam==mi.TFSc[20])
        {
         mi.ChangeChartSymbol(mi.TFSc[20],mi.TFId[20]);
        }
      //--
     }
//---
  } //-end OnChartEvent()
//---------//

How to Use

1. **Attach to Any Chart** (e.g., EURUSD H1)
2. **Adjust the Inputs**
3. **Observe Directional Arrows** per timeframe on your chart
4. **Watch Summary Signal Arrow** (center chart)
5. **Click Timeframe Labels** to change timeframe view instantly

Frequently Asked Questions (FAQ)

**Q1: What makes this ADX MTF indicator different from the built-in ADX in MetaTrader 5?**
**A1:** The built-in ADX only analyzes the current chart timeframe. This ADX MTF indicator scans and displays directional strength across **21 timeframes**, giving you a full-spectrum view of the market’s trend dynamics. It also features consensus-based summary signals and interactive controls.

**Q2: What do the green and red arrows mean on the chart?**
**A2:**
**Green arrow** (Wingdings 108): Indicates that ADX is rising (positive DI > previous value) on that specific timeframe
**Red arrow** (Wingdings 108): Indicates ADX is falling (trend weakening)
The **large green (217)** or **red (218)** summary arrow shows dominant direction when more than one timeframe agrees

**Q3: How is the final summary signal calculated?**
**A3:** The indicator loops through all timeframes and counts up and down signals.
** If `up > down + 1`, it plots a large **up arrow** (Wingdings 217)
** If `down > up + 1`, it plots a **down arrow** (Wingdings 218)
** If neither, no summary arrow is drawn

**Q4: Can I change the timeframe used for analysis dynamically?**
**A4:** Yes. The indicator includes an interactive panel with all 21 timeframes (M1 to MN1). Just click on any label (like “H4” or “D1”) to switch the analysis source without reattaching the indicator. This is handled via the `OnChartEvent()` function in MQL5.

**Q5: Is this indicator repainting?**
**A5:** No. The indicator uses `CopyBuffer()` with proper indexing and does **not repaint** past signals. All calculations are based on closed candles and historical values.

**Q6: What symbols or assets can I use this on?**
**A6:** This indicator works with all MT5 instruments:
* Forex pairs (e.g., EURUSD, GBPJPY)
* Indices (e.g., DAX, S&P 500)
* Commodities (e.g., gold, oil)
* Crypto (e.g., BTCUSD)

**Q7: Does this indicator send alerts?**
**A7:** Yes. It supports:
* Popup alerts
* Email alerts
* Push notifications
These can be toggled on/off in the input settings.

**Q8: Can this be used inside Expert Advisors (EAs)?**
**A8:** While this is a custom visual indicator, its signal logic can be adapted into EAs. You may extract the consensus signal via `PowerMove[]` or implement a similar formula directly in your EA code.

**Q9: Can I use this for scalping or only for swing trading?**
**A9:** It’s suitable for **both**. Scalpers can confirm short-term moves with higher timeframe trends. Swing traders benefit from trend strength alignment across D1, H4, etc.

**Q10: Do I need to install any external libraries to use it?**
**A10:** No. Just download the `.ex5` file, place it in `MQL5/Indicators`, and run.

Conclusion

The **ADX Multi-Timeframe Indicator for MT5** offers a complete solution for traders who want to understand trend strength across all timeframes simultaneously. Using a unique formula that scans and weighs up/down movement across 21 timeframes, it delivers a summary arrow signal that simplifies complex data into an actionable visual.

With features like dynamic chart interaction, visual arrows, alerts, and a lightweight design, this tool is ideal for discretionary and algorithmic traders alike.

We hope that this article and the ADX_MTF or Average Directional Movement Index Multi-Timeframe Indicator for MT5 program will be useful for traders in learning and generating new ideas for trading, who can ultimately make money from home by trading forex.

Thanks for reading this article.

Please download the ADX_MTF indicator: Average Directional Movement Index Multi-Timeframe Indicator

If you are subscribed to my YouTube Channel, and would like to receive the source program of this article, please send a request via the Contact Us form page, and I will send it to your email, source code: Average Directional Movement Index Multi-Timeframe Indicator for MT5

Don't forget to stop by and subscribe to Forex Home Experts YouTube Channel:

YouTube Channel: @ForexHomeExperts

YouTube Playlist: @ForexHomeExperts YouTube Playlist

Friday, January 24, 2025

On Balance Volume Multi-Timeframe Indicator for MT5

January 24, 2025 by Forex Home ExpertNo comments

In this article, I will discuss the creation of the On Balance Volume Multi Timeframe indicator for MT5. This indicator will calculate the comparison of OBV movements in percentage terms across 21 different timeframes, ranging from M1 to MN1.

The On Balance Volume Multi-Timeframe indicator for MT5 (OBV_MTF) utilizes a template and displays a panel on the chart. Its function, operation, and usage are identical to the Strength of Price Movement Multi Timeframe indicator (SPM_MTF) as detailed in the previous article. For a comprehensive guide on creating a multi-timeframe indicator, you can refer to the following resources: Strength of Price Movement Multi Timeframe indicator for MT5

Introduction of On-Balance Volume Multi-Time Frame (OBV_MTF) Indicator

The primary function of the On-Balance Volume Multi-Time Frame (OBV_MTF) indicator is to enhance the traditional On-Balance Volume (OBV) indicator by incorporating analysis across multiple time frames. This approach offers a more comprehensive view of market trends and volume dynamics.

USDCHFH1_OBV_MTF

Key Components and Functions:

  • 1. Volume Analysis: The OBV_MTF indicator utilizes trading volume as a critical parameter. By adding the volume on up days and subtracting the volume on down days, it creates a cumulative total that helps identify the strength of price movements.
  • 2. Multi-Time Frame Analysis: Unlike the traditional OBV, which operates on a single time frame, the OBV_MTF indicator aggregates volume data from multiple time frames. This broader perspective allows traders to detect longer-term trends that might be overlooked when only considering one time frame.
  • 3. Trend Confirmation: The OBV_MTF indicator aids in confirming trends by comparing OBV values across different time frames. A rising OBV across multiple time frames typically indicates strong buying pressure, while a falling OBV suggests selling pressure.
  • 4. Divergence Detection: The OBV_MTF indicator can identify divergences between price movements and volume. For instance, if prices are rising but OBV is falling across multiple time frames, it could signal a potential reversal.
  • 5. Customizable Parameters: This indicator often includes customizable settings, allowing traders to adjust time frames and other parameters to fit their trading strategies and preferences.
  • 6. Visual Representation: The OBV_MTF indicator provides visual cues, such as arrows and colors, to highlight significant changes in volume and trends, making it easier for traders to interpret the data.
  • 7. Buffering and Storage: It maintains buffers for open, high, low, close prices, and tickvolume data. It also keeps track of time and various display settings to ensure accurate and timely updates.

Before explaining the differences between the SPM_MTF indicator and the OBV_MTF indicator, it is important to note that all functions for running this multi-timeframe indicator are managed by the class program for the MTF indicator, which is contained in the MTF_Indi class.

Class for MTF indicator:


//+------------------------------------------------------------------+
//| class for MTF indicator                                          |
//+------------------------------------------------------------------+
class MTF_Indi
  {
   //---
   public:
   //--
   int               fbar;
   int               star,
                     tstar,
                     bstar;
   int               TNamex,
                     TNamexn,
                     TNamey1,
                     TNamey2,
                     TNamey3,
                     TNamey1n,
                     TNamey2n,
                     TNamey3n;
   int               tfxar;
   int               up,dw;
   int               tfhalf;
   int               maxbar;
   int               ttlbars;
   int               scaleX,
                     scaleA,
                     scaleY,
                     horizL1,
                     horizL2,
                     horizL3,
                     horizL4,
                     horizL5,
                     horizL6,
                     vertiL1,
                     vertiL2,
                     vertiL3,
                     vertiL4,
                     vertiL5,
                     vertiL6,
                     offsetX,
                     offsetY,
                     fontSize,
                     windchar,
                     windsize;
   int               corx,
                     cory,
                     txttf;
   int               curmin,
                     prvmin;
   int               corpos;
   int               pospos,
                     postop,
                     posbot;
   int               curAlert;
   int               prvAlert;
   //--
   long              CI;
   string            posisi,
                     sigpos,
                     indname,
                     msgText,
                     ObjName;
   string            cstar,
                     artop,
                     arbot;
   string            hName1,
                     hName2,
                     hName3;
   string            font_mode;
   bool              display;
   double            OPEN[],
                     HIGH[],
                     LOW[],
                     CLOSE[];
   long              VOLUME[];
   datetime          TIME[];
   datetime          cbartime;
   //--
   int               year,  // Year
                     mon,   // Month
                     day,   // Day
                     hour,  // Hour
                     min,   // Minutes
                     sec,   // Seconds
                     dow,   // Day of week (0-Sunday, 1-Monday, ... ,6-Saturday)
                     doy;   // Day number of the year (January 1st is assigned the number value of zero)
   //---- buffers
   double            PowerMove[];
   string            TFSc[];
   color             Arwcolor[];
   color             TColor;
   ENUM_TIMEFRAMES   TFId[];
   ENUM_BASE_CORNER  bcor;
   ENUM_ANCHOR_POINT ancp;
   //---
   //---
   //- Constructor
                     MTF_Indi(void):
                     year(0),
                     mon(1),
                     day(2),
                     hour(3),
                     min(4),
                     sec(5),
                     dow(6),
                     doy(7),
                     fbar(125),
                     star(181),
                     maxbar(3),
                     pospos(0),
                     postop(0),
                     posbot(1),
                     tstar(217),
                     bstar(218),
                     tfhalf(11),
                     scaleX(35),
                     scaleA(36),
                     scaleY(50),
                     offsetY(18),
                     offsetX(120),
                     fontSize(7),
                     cbartime(0),
                     posisi(""),
                     sigpos(""),
                     msgText(""),
                     curAlert(0),
                     prvAlert(0),
                     ttlbars(125),
                     windsize(12),
                     windchar(108),
                     CI(ChartID()),
                     display(false),
                     ObjName("OBV_"),
                     font_mode(FontsModel(f_model)),
                     cstar(CharToString((uchar)star)),
                     artop(CharToString((uchar)tstar)),
                     arbot(CharToString((uchar)bstar)),
                     indname(MQLInfoString(MQL_PROGRAM_NAME))
     {
     }
   //---
   //- Destructor
                    ~MTF_Indi(void)
     {
     }
   //---

Code Explanation of the MTF_Indi Class:

  • Class Definition:
    • The MTF_Indi class is designed to handle the Multi-Time Frame (MTF) indicator for trading analysis. This class encapsulates various properties and methods that are essential for analyzing and displaying trading data across multiple time frames.
  • Public Members:
    • The class defines numerous public member variables for storing values such as chart coordinates, alert settings, font details, and indicator data buffers. These variables are used throughout the class methods to perform various indicator functions.
  • Key Components and Functions:
    • 1. Public Data Members:
      • fbar: An integer representing the function bar for analysis.
      • star, tstar, bstar: Integers representing specific chart arrow or markers.
      • TNamex, TNamexn, TNamey1, TNamey2, TNamey3, TNamey1n, TNamey2n, TNamey3n: Integers for naming conventions and chart positions.
      • tfxar: An integer for time frame-related calculations.
      • up, dw: Integers for tracking upward and downward movements.
      • tfhalf: An integer representing the midpoint of a time frame.
      • maxbar: An integer for the maximum number of bars considered.
      • ttlbars: An integer for the total number of bars.
      • scaleX, scaleA, scaleY: Integers for scaling the chart in different dimensions.
      • horizL1, horizL2, horizL3, horizL4, horizL5, horizL6: Integers for horizontal line positions.
      • vertiL1, vertiL2, vertiL3, vertiL4, vertiL5, vertiL6: Integers for vertical line positions.
      • offsetX, offsetY: Integers for positional offsets.
      • fontSize: An integer for the font size used in chart displays.
      • windchar, windsize: Integers related to window characteristics.
      • corx, cory: Integers for x and y coordinates.
      • txttf: An integer for text time frame.
    • 2. Time and Alert Variables:
      • curmin, prvmin: Integers for current and previous minutes.
      • corpos: An integer for core position.
      • pospos, postop, posbot: Integers for positional tracking.
      • curAlert, prvAlert: Integers for current and previous alert states.
      • year, mon, day, hour, min, sec, dow, doy: Integers representing date and time components.
    • 3. String Members:
      • posisi, sigpos, indname, msgText, ObjName, cstar, artop, arbot, hName1, hName2, hName3, font_mode: Strings for various naming conventions, messages, and display texts.
    • 4. Boolean Member:
      • display: A boolean flag indicating whether the display is active.
    • 5. Data Buffers:
      • OPEN[], HIGH[], LOW[], CLOSE[]: Arrays for storing open, high, low, and close prices.
      • VOLUME[]: An array for storing trading volume data.
      • TIME[]: An array for storing time data.
      • cbartime: A datetime variable for bar time tracking.
      • PowerMove[]: An array for storing calculated power move values.
      • TFSc[]: An array for storing time frame string components.
      • Arwcolor[]: An array for storing arrow colors.
      • TColor: A variable for text color.
    • 6. Enumerations:
      • TFId[]: An array of enumeration type ENUM_TIMEFRAMES for different time frames.
      • bcor: An enumeration of type ENUM_BASE_CORNER for base corner positions.
      • ancp: An enumeration of type ENUM_ANCHOR_POINT for anchor points.
    • 7. Constructor: The constructor initializes the member variables with default values, ensuring that the indicator is set up correctly when instantiated.
      • MTF_Indi(void): The constructor initializes the class members with default values.
    • 8. Destructor: The destructor is defined but currently does not perform any specific actions.
      • ~MTF_Indi(void): The destructor is provided to clean up resources when the object is destroyed.

    As I explained above, the differences between the On Balance Volume Multi-Timeframe indicator (OBV_MTF) and the Strength of Price Movement Multi Timeframe indicator (SPM_MTF) lie in two key functions:

    1. UpdatePrice(ENUM_TIMEFRAMES xtf):

    • In the SPM_MTF indicator program, the UpdatePrice(ENUM_TIMEFRAMES xtf) function does not perform a TickVolume update because it is not necessary.

    2. OBVDirectionScan(const ENUM_TIMEFRAMES stf, int shift):

    • The SPM_MTF indicator program uses the PriceStrengthScan(const ENUM_TIMEFRAMES stf, int shift) function, which scans the price and compares the current bar's price to the previous bar's price in percentage terms.
    • Conversely, the OBV_MTF indicator scans the movement of the OBV value on the current bar and compares it with the OBV value on the previous bar in percentage terms.

    Additionally, the value of the On Balance Volume indicator in the OBV_MTF indicator is not obtained using the Indicator Handle. Instead, the structure and code of the On Balance Volume indicator only use the closing price plus or minus TickVolume, allowing the OBV indicator code to be easily written directly into the OBVDirectionScan() function.

    Explanation of the UpdatePrice() Function in the SPM_MTF Indicator.

    The UpdatePrice() function in the Strength of Price Movement Multi Timeframe (SPM_MTF) indicator is designed to update price data across various timeframes. Below is a detailed breakdown of each step within this function:

    
   //---
   void              UpdatePrice(ENUM_TIMEFRAMES xtf)
     {
      //-- Clear existing arrays
      ArrayFree(OPEN);
      ArrayFree(HIGH);
      ArrayFree(LOW);
      ArrayFree(CLOSE);
      ArrayFree(TIME);
      //-- Resize arrays
      ArrayResize(OPEN,maxbar,maxbar);
      ArrayResize(HIGH,maxbar,maxbar);
      ArrayResize(LOW,maxbar,maxbar);
      ArrayResize(CLOSE,maxbar,maxbar);
      ArrayResize(TIME,maxbar,maxbar);
      //-- Set arrays as series
      ArraySetAsSeries(OPEN,true);
      ArraySetAsSeries(HIGH,true);
      ArraySetAsSeries(LOW,true);
      ArraySetAsSeries(CLOSE,true);
      ArraySetAsSeries(TIME,true);
      //-- Initialize arrays
      ArrayInitialize(OPEN,0.0);
      ArrayInitialize(HIGH,0.0);
      ArrayInitialize(LOW,0.0);
      ArrayInitialize(CLOSE,0.0);
      ArrayInitialize(TIME,0);
      //-- Calculate the number of bars based on the timeframe
      int barx=PeriodSeconds(xtf)/60*maxbar;
      RefreshPrice(PERIOD_M1,maxbar);
      RefreshPrice(xtf,barx);
      //-- Copy price data from the specified symbol and timeframe
      int co=CopyOpen(Symbol(),xtf,0,maxbar,OPEN);
      int ch=CopyHigh(Symbol(),xtf,0,maxbar,HIGH);
      int cl=CopyLow(Symbol(),xtf,0,maxbar,LOW);
      int cc=CopyClose(Symbol(),xtf,0,maxbar,CLOSE);
      int ct=CopyTime(Symbol(),xtf,0,maxbar,TIME);
      //--
      return;
      //---
     } //-end UpdatePrice()
   //---

    Steps in the UpdatePrice() Function in the SPM_MTF Indicator:

    • 1. Clear Existing Arrays:
      • The ArrayFree() function is used to clear the existing data in the OPEN, HIGH, LOW, CLOSE, and TIME arrays.
    • 2. Resize Arrays:
      • ArrayResize() function adjusts the size of these arrays based on the maximum number of bars (maxbar).
    • 3, Set Arrays as Series:
      • ArraySetAsSeries() sets the arrays as series, meaning that the most recent element is at index 0.
    • 4. Initialize Arrays:
      • ArrayInitialize() initializes the array values. The initial values are set to 0.0 for prices and 0 for time.
    • 5. Calculate the Number of Bars:
      • int barx = PeriodSeconds(xtf) / 60 * maxbar; calculates the number of bars required based on the specified timeframe (xtf).
    • 6. Refresh Price Data:
      • RefreshPrice(PERIOD_M1, maxbar); and RefreshPrice(xtf, barx); refresh the price data for the M1 timeframe and the specified timeframe.
    • 7. Copy Price Data:
      • CopyOpen(), CopyHigh(), CopyLow(), CopyClose(), and CopyTime() functions copy the open, high, low, close, and time data into their respective arrays.

    This function helps update and manage price data for further analysis across multiple timeframes without the need for TickVolume updates, as they are not relevant to the SPM_MTF indicator.

    Explanation of the UpdatePrice() Function in the OBV_MTF Indicator.

    The UpdatePrice() function in the On Balance Volume Multi-Timeframe (OBV_MTF) indicator is designed to update price and TickVolume data across various timeframes. Below is a detailed breakdown of each step within this function:

    
   //---
   void              UpdatePrice(ENUM_TIMEFRAMES xtf)
     {
      maxbar=fbar;
      //-- Clear existing arrays
      ArrayFree(OPEN);
      ArrayFree(HIGH);
      ArrayFree(LOW);
      ArrayFree(CLOSE);
      ArrayFree(TIME);
      ArrayFree(VOLUME);
      //-- Resize arrays
      ArrayResize(OPEN,maxbar,maxbar);
      ArrayResize(HIGH,maxbar,maxbar);
      ArrayResize(LOW,maxbar,maxbar);
      ArrayResize(CLOSE,maxbar,maxbar);
      ArrayResize(TIME,maxbar,maxbar);
      ArrayResize(VOLUME,maxbar,maxbar);
      //-- Set arrays as series
      ArraySetAsSeries(OPEN,true);
      ArraySetAsSeries(HIGH,true);
      ArraySetAsSeries(LOW,true);
      ArraySetAsSeries(CLOSE,true);
      ArraySetAsSeries(TIME,true);
      ArraySetAsSeries(VOLUME,true);
      //-- Initialize arrays
      ArrayInitialize(OPEN,0.0);
      ArrayInitialize(HIGH,0.0);
      ArrayInitialize(LOW,0.0);
      ArrayInitialize(CLOSE,0.0);
      ArrayInitialize(TIME,0);
      ArrayInitialize(VOLUME,0);
      //-- Calculate the number of bars based on the timeframe
      int barx=PeriodSeconds(xtf)/60*maxbar;
      RefreshPrice(PERIOD_M1,maxbar);
      RefreshPrice(xtf,barx);
      //-- Copy price and TickVolume data from the specified symbol and timeframe
      int co=CopyOpen(Symbol(),xtf,0,maxbar,OPEN);
      int ch=CopyHigh(Symbol(),xtf,0,maxbar,HIGH);
      int cl=CopyLow(Symbol(),xtf,0,maxbar,LOW);
      int cc=CopyClose(Symbol(),xtf,0,maxbar,CLOSE);
      int ct=CopyTime(Symbol(),xtf,0,maxbar,TIME);
      int cv=CopyTickVolume(Symbol(),xtf,0,maxbar,VOLUME);
      //--
      return;
      //---
     } //-end UpdatePrice()
   //---

    Steps in the UpdatePrice() Function in the OBV_MTF Indicator:

    • 1. Set Maximum Bars:
      • maxbar = fbar; sets the maximum number of bars to be processed.
    • 2. Clear Existing Arrays:
      • The ArrayFree() function is used to clear the existing data in the OPEN, HIGH, LOW, CLOSE, TIME, and VOLUME arrays.
    • 3. Resize Arrays:
      • ArrayResize() adjusts the size of these arrays based on the maximum number of bars (maxbar).
    • 4. Set Arrays as Series:
      • ArraySetAsSeries() sets the arrays as series, meaning that the most recent element is at index 0.
    • 5. Initialize Arrays:
      • ArrayInitialize() initializes the array values. The initial values are set to 0.0 for prices and TickVolume, and 0 for time.
    • 6. Calculate the Number of Bars:
      • int barx = PeriodSeconds(xtf) / 60 * maxbar; calculates the number of bars required based on the specified timeframe (xtf).
    • 7. Refresh Price Data:
      • RefreshPrice(PERIOD_M1, maxbar); and RefreshPrice(xtf, barx); refresh the price data for the M1 timeframe and the specified timeframe.
    • 8. Copy Price and TickVolume Data:
      • CopyOpen(), CopyHigh(), CopyLow(), CopyClose(), CopyTime(), and CopyTickVolume() is functions copy the open, high, low, close, time, and TickVolume data into their respective arrays.

    Explanation of the PriceStrengthScan() Function in the SPM_MTF Indicator.

    The PriceStrengthScan() function in the Strength of Price Movement Multi Timeframe (SPM_MTF) indicator is designed to scan and compare price data to determine the direction of price movement in percentage terms. Below is a detailed breakdown of each step within this function:

    
//---
   int               PriceStrengthScan(const ENUM_TIMEFRAMES stf,int shift) // Price Bar Direction in percent
     {
      //-- Initialize return value and direction indicators
      int ret=0;
      int rise=1,
          down=-1;
      //-- Set the number of bars to be scanned
      int br=shift+2;
      double res=0.0;
      double move=0.0;
      //-- Update price data for the specified timeframe
      UpdatePrice(stf);
      //-- Declare and resize the close price array
      double CL[];
      ArrayResize(CL,br,br);
      ArraySetAsSeries(CL,true);
      //-- Populate the close price array with data
      for(int x=br-1; x>=shift; x--)
         CL[x]=CLOSE[x];
      //-- Get the current and previous close prices
      double close_now  = CL[shift];
      double close_prev = CL[shift+1];
      //-- Calculate the percentage change in close prices
      if((close_now==0 || close_now==EMPTY_VALUE) || (close_prev==0 || close_prev==EMPTY_VALUE))
         res=0.0;
      else
         res=NormalizeDouble((close_now / close_prev * 100) - 100,3);
      //-- Adjust the result for percentage comparison
      res=NormalizeDouble(res*100,3); // because its value less than 1 then multiplied with 100.
      //-- Determine the direction of price movement
      if(res>move)
         ret=rise;
      if(res<move)
         ret=down;
      //--
      return(ret);
      //---
     } //-end PriceStrengthScan()
   //---

    Steps in the PriceStrengthScan() Function in the SPM_MTF Indicator:

    • 1. Initialization:
      • Initialize the return value (ret) to 0.
      • Define constants for rising and falling prices (rise and down).
    • 2. Set the Number of Bars to Scan:
      • Calculate the number of bars to scan (br) based on the shift parameter.
    • 3. Update Price Data:
      • Call the UpdatePrice(stf) function to update the price data for the specified timeframe (stf).
    • 4.Declare and Resize the Close Price Array:
      • Declare the CL array to store close prices.
      • Resize the CL array to accommodate the number of bars (br) and set it as a series.
    • 5. Populate the Close Price Array:
      • Use a loop to populate the CL array with close prices from the CLOSE array.
    • 6. Get the Current and Previous Close Prices:
      • Retrieve the current close price (close_now) and the previous close price (close_prev) from the CL array.
    • 7. Calculate the Percentage Change in Close Prices:
      • If either close_now or close_prev is 0 or empty, set res to 0.0.
      • Otherwise, calculate the percentage change in close prices and normalize the result.
    • 8. Adjust the Result for Percentage Comparison:
      • Multiply the result by 100 to adjust for percentage comparison.
    • 9. Determine the Direction of Price Movement:
      • Compare the result (res) with move to determine if the price is rising or falling.
      • Set the return value (ret) accordingly.

    This function helps determine the direction and strength of price movement by analyzing the percentage change in close prices across different timeframes.

    Explanation of the OBVDirectionScan() Function in the OBV_MTF Indicator.

    The OBVDirectionScan() function in the On Balance Volume Multi-Timeframe (OBV_MTF) indicator is designed to scan and compare the OBV values to determine the direction of OBV movement in percentage terms. Below is a detailed breakdown of each step within this function:

    
//---
   int               OBVDirectionScan(const ENUM_TIMEFRAMES stf,int shift) // Scan OBV Direction
     {
      //-- Initialize return value and direction indicators
      int ret=0;
      int rise=1,
          down=-1;
      //-- Set the number of bars to be scanned
      int br=shift+2;
      double res=0.0;
      double move=0.0;
      //-- Update price data for the specified timeframe
      UpdatePrice(stf);
      //-- Declare and resize the OBV array
      double OBV[];
      ArrayResize(OBV,br,br);
      ArraySetAsSeries(OBV,true);
      //-- Retrieve volume and close prices
      double vol=(double)VOLUME[shift];
      double prev_close=CLOSE[shift+1];
      double curr_close=CLOSE[shift];
      //--- Fill OBV Buffer
      if(curr_close<prev_close)
         OBV[shift]=OBV[shift+1]-vol;
      else
        {
         if(curr_close>prev_close)
            OBV[shift]=OBV[shift+1]+vol;
         else
            OBV[shift]=OBV[shift+1];
        }
      //-- Get the current and previous OBV values
      double close_now  = OBV[shift];
      double close_prev = OBV[shift+1];
      //-- Calculate the percentage change in OBV values
      if((close_now==0 || close_now==EMPTY_VALUE) || (close_prev==0 || close_prev==EMPTY_VALUE))
         res=0.0;
      else
         res=NormalizeDouble((close_now / close_prev * 100) - 100,3);
      //-- Adjust the result for percentage comparison
      res=NormalizeDouble(res*100,3); // because its value less than 1 then multiplied with 100.
      //-- Determine the direction of OBV movement
      if(res>move)
         ret=rise;
      if(res<move)
         ret=down;
      //--
      return(ret);
      //---
     } //-end OBVDirectionScan()
   //---

    Steps in the OBVDirectionScan() Function in the OBV_MTF Indicator:

    • 1. Initialization:
      • Initialize the return value (ret) to 0.
      • Define constants for rising and falling OBV (rise and down).
    • 2. Set the Number of Bars to Scan:
      • Calculate the number of bars to scan (br) based on the shift parameter.
    • 3. Update Price Data:
      • Call the UpdatePrice(stf) function to update the price data for the specified timeframe (stf).
    • 4. Declare and Resize the OBV Array:
      • Declare the OBV array to store OBV values.
      • Resize the OBV array to accommodate the number of bars (br) and set it as a series.
    • 5. Retrieve Volume and Close Prices:
      • Get the volume (vol), previous close price (prev_close), and current close price (curr_close) from their respective arrays.
    • 6. Fill OBV Buffer:
      • Calculate the OBV value for the current bar based on the comparison of curr_close and prev_close.
      • Update the OBV array with the calculated OBV value.
    • 7. Get the Current and Previous OBV Values:
      • Retrieve the current OBV value (close_now) and the previous OBV value (close_prev) from the OBV array.
    • 8. Calculate the Percentage Change in OBV Values:
      • If either close_now or close_prev is 0 or empty, set res to 0.0.
      • Otherwise, calculate the percentage change in OBV values and normalize the result.
    • 9. Adjust the Result for Percentage Comparison:
      • Multiply the result by 100 to adjust for percentage comparison.
    • 10. Determine the Direction of OBV Movement:
      • Compare the result (res) with move to determine if the OBV is rising or falling.
      • Set the return value (ret) accordingly.

    This function helps determine the direction and strength of OBV movement by analyzing the percentage change in OBV values across different timeframes.

    The On Balance Volume Multi-Timeframe (OBV_MTF) indicator is designed for MetaTrader 5 (MT5). It calculates the strength of price movement as a percentage on each timeframe bar, assisting traders in analyzing market trends and making informed trading decisions.

    Key Functions of the OBV_MTF Indicator:

    • 1. Displays Multiple Timeframes: Allows traders to view various timeframes on a single chart, enhancing their ability to analyze market movements effectively.
    • 2. Identifies Market Trends: By viewing the indicator across multiple timeframes, traders can more easily identify both larger and smaller market trends.
    • 3. Supports Trading Decisions: Assists traders in making informed decisions on entering or exiting trades based on observed market conditions across different timeframes.

    Detailed Breakdown of Functions:

    • 1. OBV_MTF_Config(): Configures the multi-timeframe settings and prepares the indicator for use.
    • 2. PositionCore(): Sets up core position settings for the indicator elements on the chart.
    • 3. DrawOBVObject(): Draws various elements of the indicator on the chart.
    • 4. PanelPosChange(int inpos): Changes the panel position based on the input position value.
    • 5. UpdatePrice(ENUM_TIMEFRAMES xtf): Updates price data, including TickVolume arrays, for a given timeframe.
    • 6. RefreshPrice(ENUM_TIMEFRAMES xtf, int bars): Refreshes price data for a given timeframe and a specified number of bars.
    • 7. OBVDirectionScan(const ENUM_TIMEFRAMES stf, int shift): Scans and calculates the direction of the OBV indicator value in percentage terms.
    • 8. OBVMovementCalculation(int barCnt): Scans the direction of OBV indicator value for each timeframe, calculates how much it has moved up or down, and compares them to determine the signal strength.
    • 9. ThisTime(const int reqmode): Retrieves current time information based on the requested mode.
    • 10. Do_Alerts(string msg): Generates various types of alerts (print, alert, email, and notification) based on the provided message.
    • 11. FontsModel(int mode): Returns the font name based on the input mode.
    • 12. ChangeChartSymbol(string tf_name, ENUM_TIMEFRAMES stf): Changes the chart symbol and timeframe based on the input parameters.
    • 13. DisplayPanelButton(): Displays panel buttons on the chart.
    • 14. DisplayButtonClick(string actreq): Handles the creation and display of various buttons on the chart.
    • 15. DeletedOBVObject(): Deletes all objects related to the OBV_MTF indicator from the chart.
    • 16. strTF(ENUM_TIMEFRAMES period): Converts timeframe enumerations to string representations.
    • 17. getUninitReasonText(int reasonCode): Provides descriptive reasons for the uninitialization of the Expert Advisor (EA) based on the given reason code.
    • 18. WS(int width): Calculates the width scaling factor for buttons based on screen DPI.
    • 19. CreateButtonClick(): Creates a clickable button on the chart with specified properties.
    • 20. CreateArrowLabel(): Creates an arrow label on the chart with specified properties.
    • 21. CreateButtonTemplate(): Creates a rectangular button on the chart with specified properties.

    Main Functions of the Program:

    • 1. OnInit(): Initializes the custom indicator, configuring indicator buffers and setting indicator properties.
    • 2. OnDeinit(const int reason): Deinitializes the custom indicator, cleans up indicator objects, and prints the reason for deinitialization.
    • 3. OnCalculate(): Handles the main calculations for the indicator on every price tick, including scanning price strength and generating alerts.
    • 4. OnChartEvent(): Handles chart events, particularly button clicks, to manage the indicator's display and settings.

    Summary

    The OBV_MTF indicator is a comprehensive tool that provides traders with valuable insights into price movements across multiple timeframes. Its various functions ensure an enhanced trading experience by configuring, updating, and displaying the indicator's elements effectively. This helps traders identify market trends and make well-informed trading decisions.

    We hope that this article and the OBV_MTF or On Balance Volume Multi Timeframe indicator for MT5 program will be useful for traders in learning and generating new ideas, who can ultimately make money from home by trading forex.

    Thanks for reading this article.

    Please download the OBV_MTF indicator: On Balance Volume Multi Timeframe indicator

    If you are subscribed to my YouTube Channel, and would like to receive the source program of this article, please send a request via the Contact Us form page, and I will send it to your email, source code: On Balance Volume Multi Timeframe indicator

    Don't forget to stop by and subscribe to Forex Home Experts YouTube Channel:

    YouTube Channel: @ForexHomeExperts

    YouTube Playlist: @ForexHomeExperts YouTube Playlist

Subscribe to: Posts (Atom)

Featured Post

How to create a simple Multi-Currency Expert Advisor using MQL5 with Zigzag and RSI Indicators Signal

Introduction The Expert Advisor discussed in this article is a multi-currency trading robot that uses the Zigzag and RSI indicators. It fol...