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.
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_Indiclass 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_TIMEFRAMESfor different time frames. - bcor: An enumeration of type
ENUM_BASE_CORNERfor base corner positions. - ancp: An enumeration of type
ENUM_ANCHOR_POINTfor 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.
- In the SPM_MTF indicator program, the
UpdatePrice(ENUM_TIMEFRAMES xtf)function does not perform a TickVolume update because it is not necessary. - 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
OBVvalue on the previous bar in percentage terms. - 1. Clear Existing Arrays:
- The
ArrayFree()function is used to clear the existing data in theOPEN, HIGH, LOW, CLOSE, and TIMEarrays. - 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); andRefreshPrice(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.- 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.- 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.
- 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.
- 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.
- 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.
- 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.
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):
2. OBVDirectionScan(const ENUM_TIMEFRAMES stf, int shift):
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:
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:
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:
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:
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:
Detailed Breakdown of Functions:
Main Functions of the Program:
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
