Wednesday, November 27, 2024

MT5 Indicator Program Explanation and Function

Overview:

The TimeBarCloseCheck MT5 Indicator is designed to detect the bar close time and the close price in the MetaTrader 5 trading platform. This program assists traders by providing accurate timing and pricing information, which is essential for making informed trading decisions.

Functions:

1. Bar Close Time Detection:

The indicator precisely identifies when a trading bar (or candlestick) closes. This is crucial for traders who rely on closing prices to determine market trends and make trading decisions.

2. Price Close Detection:

It captures the exact price at which the bar closes. This data is vital for analyzing market conditions and planning future trades.

3. Alerts and Notifications:

The program can be configured to send alerts or notifications when a bar closes, allowing traders to stay updated without constantly monitoring the charts.

4. Customizable Settings:

Users can customize the indicator settings according to their trading strategy and preferences, making it a versatile tool for different trading styles.

Benefits:

1. Accuracy: Provides precise timing and pricing information to enhance trading strategies.

2. Convenience: Automated alerts save time and help traders stay focused on their trading goals.

3. Customization: Adaptable to various trading strategies, ensuring it meets individual needs.

How to detect Bar Close Time in MT5 and MT4

Let's go through the code section provided and explain each part:


//+------------------------------------------------------------------+
//|                                            TimeBarCloseCheck.mq5 |
//|        Copyright 2024, Roberto Jacobs (3rjfx) ~ Date: 2024-11-26 |
//|                              https://www.mql5.com/en/users/3rjfx |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, Roberto Jacobs (3rjfx) ~ Date: 2024-11-26"
#property link      "https://www.mql5.com/en/users/3rjfx"
#property version   "1.00"
#property indicator_chart_window

Code Explanation:

Metadata Section:

This section contains metadata about the indicator, including the name, author, version, and copyright information.

#property copyright specifies the copyright details.

#property link provides a link to the author's profile or website.

#property version indicates the version of the indicator.

#property indicator_chart_window tells MT5 that this indicator will be applied to the chart window.

#property indicator_plots 0
#property indicator_plots = 0, indicates that this indicator does not have any graphical plots.


//-- Enumeration
enum YN
 {
   No,  
   Yes
 };

Enumeration YN:

An enumeration defining Yes and No options. Useful for input parameters that need a binary choice.


enum corner
 {  
   LeftHand=0,
   RightHand=1
 };

Enumeration corner:

This enumeration is used to define possible positions (left or right) for text display on the chart.


enum fonts
  {
    Verdana,
    Bodoni_MT_Black
  }; 

Enumeration fonts:

An enumeration listing the font options available for text display on the chart.


input ENUM_TIMEFRAMES  Timeframe = PERIOD_H1;     // Select Expert TimeFrame, default PERIOD_H1
input corner                 cor = LeftHand;     // Corner Position Text
//--- 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)
//--- Input text parameters
input fonts              f_model = Verdana;        // Select Font Model
input color              t_color = clrGold;        // Select Text Color

Input Parameters:

input ENUM_TIMEFRAMES Timeframe = PERIOD_H1; - Allows the user to select the timeframe for the indicator, default is 1 hour (H1).

Explanation:

The input ENUM_TIMEFRAMES Timeframe, Allowing users to select the timeframe (with the default being H1) for the TimeBarCloseCheck indicator provides significant flexibility. Even if a user is analyzing a Symbol chart on a different timeframe, such as D1, setting the indicator to H1 ensures it continues to provide information and alerts based on the H1 timeframe.

This functionality is highly advantageous for traders who prefer to monitor multiple timeframes simultaneously. For instance, a trader could keep an eye on long-term trends on a D1 chart while still receiving timely alerts and information pertinent to the H1 timeframe without switching their primary chart’s timeframe. This approach provides a comprehensive view of the market, facilitating more informed trading decisions.

input corner cor = LeftHand; - Allows the user to select the position of the text on the chart.

Alert input parameters to enable or disable different types of alerts:

  • input YN alerts = Yes; - Shows a pop-up alert on the chart.
  • input YN UseEmailAlert = No; - Enables or disables email alerts.
  • input YN UseSendnotify = No; - Enables or disables notifications.

Text input parameters to customize the appearance:

  • input fonts f_model = Verdana; - Selects the font model for the text.
  • input color t_color = clrGold; - Selects the color of the text.

Variables:

  • double CLOSE[];
  • datetime TIME[];
  • datetime TFOpenTime=0;
  • datetime TFClosTime=0;
  • datetime TFNextTime=0;
  • datetime TFprevTime=0;
  • datetime TFTimeRem=0;
  • datetime remd=0;
  • datetime tmrem=0;
  • datetime tmrem=0;
  • double tmdrem=0;
  • string txtday;
  • string font_mode;

Various global variables to store close prices (CLOSE[]), time values (TIME[], TFOpenTime, etc.), and text settings (txtday, font_mode).

Time Variables:

Variables to store different components of the time (year, month, day, hour, minute, second).

  • int x_year; // Year
  • int x_mon; // Month
  • int x_day; // Day of the month
  • int x_hour; // Hour in a day
  • int x_min; // Minutes
  • int x_sec; // Seconds

Time Constants:

Constants used for indexing time components and day information.

  • int year=0; // Year
  • int mon=1; // Month
  • int day=2; // Day
  • int hour=3; // Hour
  • int min=4; // Minutes
  • int sec=5; // Seconds
  • int dow=6; // Day of week (0-Sunday, 1-Monday, ... ,6-Saturday)
  • int doy=7; // Day number of the year (January 1st is assigned the number value of zero)

Miscellaneous Variables:

Various other global variables for specific functionalities like extime, exday, f_size, cbar, scale, garis, and alert-related variables (doalert, AlertTxt).

  • int extime=0;
  • int exday=0;
  • int f_size=9;
  • int cbar=9;
  • int scale=15;
  • int garis=12;
  • int xdis=0,ydis=90;
  • ENUM_BASE_CORNER PilCor;
  • bool doalert;
  • string AlertTxt;
  • string _pname;
  • string indiname;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
     _pname=MQLInfoString(MQL_PROGRAM_NAME);
     indiname=_pname+" : "+TF2Str(Timeframe);
     //--
     cor==RightHand ? PilCor=ENUM_BASE_CORNER(CORNER_RIGHT_UPPER) : PilCor=ENUM_BASE_CORNER(CORNER_LEFT_UPPER);
     xdis=PilCor==(ENUM_BASE_CORNER)CORNER_RIGHT_UPPER ? 288 : 30;
     //--
     font_mode=FontsModel(f_model);
//---
   return(INIT_SUCCEEDED);
  }
//---------//

This function primarily sets up the necessary parameters for the indicator to function properly, including determining the position of text elements on the chart and setting the font style.

Explanation:

1. Function Purpose:

The OnInit function is the initialization function for the custom indicator. It sets up various parameters and prepares the indicator to run.

  • _pname=MQLInfoString(MQL_PROGRAM_NAME);
  • indiname=_pname+" : "+TF2Str(Timeframe);

_pname stores the name of the MQL program.

indiname combines the program name and the selected timeframe into a single string for display or logging purpose

2. Setting the Text Position:

cor==RightHand ? PilCor=ENUM_BASE_CORNER(CORNER_RIGHT_UPPER) : PilCor=ENUM_BASE_CORNER(CORNER_LEFT_UPPER); xdis=PilCor==(ENUM_BASE_CORNER)CORNER_RIGHT_UPPER ? 288 : 30;

This conditional (ternary) operator checks if the cor variable is set to RightHand.

If cor is RightHand, PilCor is set to CORNER_RIGHT_UPPER; otherwise, it is set to CORNER_LEFT_UPPER.

xdis is set based on the value of PilCor: 288 if CORNER_RIGHT_UPPER, otherwise 30.

Font Mode: font_mode=FontsModel(f_model);

Return Value: return(INIT_SUCCEEDED);

The function returns INIT_SUCCEEDED, indicating that the initialization was successful.


string FontsModel(int mode)
  { 
   string str_font;
   switch(mode) 
     { 
      case 0: str_font="Verdana"; break;
      case 1: str_font="Bodoni MT Black"; break; 
     }
   //--
   return(str_font);
//----
  } //-end FontsModel()
//---------//

This function helps convert the integer mode to a string representing the font name, which can then be used elsewhere in the indicator for setting text properties.

Let's break down the FontsModel function:

Explanation:

Function Name and Parameters: string FontsModel(int mode)

The function FontsModel takes an integer parameter mode.

String Variable Declaration: string str_font;

A string variable str_font is declared to hold the name of the font.

Switch Statement: The switch statement evaluates the value of mode to determine which font to select.

Case Statements:

  • case 0: str_font="Verdana"; break;
  • case 1: str_font="Bodoni MT Black"; break;

If mode is 0, str_font is set to "Verdana".

If mode is 1, str_font is set to "Bodoni MT Black".

Default Case: The default case is not explicitly provided here, meaning if mode is neither 0 nor 1, str_font will remain uninitialized.

Return Statement: return(str_font);

The function returns the value of str_font.


//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//----
    Comment("");
    PrintFormat("%s: Deinitialization reason code=%d",__FUNCTION__,reason);
    Print(getUninitReasonText(reason));
    //--
    ObjectsDeleteAll(ChartID(),0,-1);
//----
   return;
  }
//-----//

Let's dive into the OnDeinit function and break down each part.

Explanation:

1. Function Purpose: The OnDeinit function is called when the custom indicator is being removed or unloaded from the chart. It handles cleanup tasks and ensures that resources are properly released.

Function Definition: void OnDeinit(const int reason)

The function takes an integer parameter reason which indicates the reason for deinitialization. The void keyword means this function does not return any value.

Clearing Comments: Comment("");

This line clears any comments displayed on the chart.

Printing Deinitialization Reason:

PrintFormat("%s: Deinitialization reason code=%d", __FUNCTION__, reason);

Print(getUninitReasonText(reason));

PrintFormat outputs a formatted string to the log, showing the function name (__FUNCTION__) and the deinitialization reason code.

Print outputs the text returned by getUninitReasonText(reason), which provides a more descriptive reason for deinitialization.

Deleting Objects: ObjectsDeleteAll(ChartID(), 0, -1);

This line deletes all objects from the chart. ChartID() gets the current chart's ID, and the 0 and -1 parameters indicate that all objects on all subwindows of the chart should be deleted.

Returning: return;

The function ends with a return statement, which is redundant for a void function but included for clarity.

This function ensures that when the indicator is removed, all related objects and comments are cleared from the chart, and relevant information about the deinitialization reason is logged for debugging or informational purposes.


string getUninitReasonText(int reasonCode) 
  { 
//---
   string text=""; 
   //--- 
   switch(reasonCode) 
     { 
       case REASON_PROGRAM:
            text="The EA has stopped working calling by remove function."; break;
       case REASON_REMOVE: 
            text="Program "+__FILE__+" was removed from chart"; break;
       case REASON_RECOMPILE:
            text="Program recompiled."; break;    
       case REASON_CHARTCHANGE: 
            text="Symbol or timeframe was changed"; break;
       case REASON_CHARTCLOSE: 
            text="Chart was closed"; break; 
       case REASON_PARAMETERS: 
            text="Input-parameter was changed"; break;            
       case REASON_ACCOUNT: 
            text="Account was changed"; break; 
       case REASON_TEMPLATE: 
            text="New template was applied to chart"; break; 
       case REASON_INITFAILED:
            text="The OnInit() handler returned a non-zero value."; break;
       case REASON_CLOSE: 
            text="Terminal closed."; break;
       default: text="Another reason"; break;
     } 
   //--
   return text;
//---
  } //-end getUninitReasonText()
//---------//

Let's explain the getUninitReasonText function and how it works:

Explanation:

1. Function Purpose: The getUninitReasonText function converts a deinitialization reason code into a human-readable string explanation. It helps in understanding why the indicator was deinitialized.

2. Function Definition: string getUninitReasonText(int reasonCode)

String Initialization: string text="";

Initializes an empty string text to store the explanation.

Switch Statement: switch(reasonCode)

The switch statement evaluates the reasonCode and sets the text variable accordingly.

Case Statements:

Each case in the switch statement corresponds to a specific reason code:

  • case REASON_PROGRAM: text="The EA has stopped working calling by remove function."; break;
  • case REASON_REMOVE: text="Program "+__FILE__+" was removed from chart"; break;
  • case REASON_RECOMPILE: text="Program recompiled."; break;
  • case REASON_CHARTCHANGE: text="Symbol or timeframe was changed"; break;
  • case REASON_CHARTCLOSE: text="Chart was closed"; break;
  • case REASON_PARAMETERS: text="Input-parameter was changed"; break;
  • case REASON_ACCOUNT: text="Account was changed"; break;
  • case REASON_TEMPLATE: text="New template was applied to chart"; break;
  • case REASON_INITFAILED: text="The OnInit() handler returned a non-zero value."; break;
  • case REASON_CLOSE: text="Terminal closed."; break;
  • default: text="Another reason"; break;

For each possible reasonCode, the corresponding text explanation is assigned to text. The __FILE__ macro is used to include the filename in the explanation for the REASON_REMOVE case.

Default Case: default: text="Another reason"; break;

If reasonCode does not match any of the specified cases, the default text "Another reason" is assigned.

Return Statement: return text;

The function returns the text variable containing the explanation.

This function is useful for logging and debugging, providing clear reasons why the indicator was deinitialized, which can help in diagnosing issues or understanding the behavior of the indicator.


//+------------------------------------------------------------------+
//| 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[])
  {
//---
     ArrayResize(TIME,cbar);
     ArrayResize(CLOSE,cbar);
     ArraySetAsSeries(TIME,true);
     ArraySetAsSeries(CLOSE,true);
     ArraySetAsSeries(time,true);
     ArraySetAsSeries(close,true);
     //--
     RefreshPrice(Timeframe);
     //--
     TFOpenTime=TIME[0];
     CheckSeconds();
     //--
     TFNextTime=TFOpenTime+extime;
     TFClosTime=TFNextTime-1;
     TFTimeRem=fabs(TimeCurrent()-TFClosTime);
     tmrem=TFClosTime-TimeCurrent();
     datetime dtB=0; 
     if(TFClosTime!=TFprevTime) doalert=false;
     string SDT=ReqDate(TimeCurrent(),ReqTime(TimeCurrent(),day),ReqTime(TimeCurrent(),hour),ReqTime(TimeCurrent(),min),ReqTime(TimeCurrent(),sec));
     //--
     if(TimeCurrent()<TFClosTime)
       {
         remd=ReqTime(TFClosTime,day)-ReqTime(TimeCurrent(),day);
         exday=int(remd);
         if(exday<=0) exday=0;
         txtday=exday==0 ? (string)ReqTime(TFTimeRem,hour)+":"+(string)ReqTime(TFTimeRem,min)+":"+(string)ReqTime(TFTimeRem,sec) :
         (string)exday+" Day ~ "+(string)ReqTime(TFTimeRem,hour)+":"+(string)ReqTime(TFTimeRem,min)+":"+(string)ReqTime(TFTimeRem,sec);
       }
     //--
     CreateChartText(0,indiname+"SDT0","Server Date Time : "+SDT,font_mode,f_size,t_color,PilCor,xdis,ydis);
     CreateChartText(0,indiname+"SDT11","------------------------------------------------------",font_mode,f_size,t_color,PilCor,xdis,ydis+garis);
     CreateChartText(0,indiname+"SDT1",_pname+" : Period "+TF2Str(Timeframe),font_mode,f_size,t_color,PilCor,xdis,ydis+garis+(1*scale));
     CreateChartText(0,indiname+"SDT2","Bar Open Time : "+
                       TimeToString(TFOpenTime,TIME_DATE|TIME_MINUTES|TIME_SECONDS),font_mode,f_size,t_color,PilCor,xdis,ydis+garis+(2*scale));
     CreateChartText(0,indiname+"SDT3","Bar Close Time : "+
                       TimeToString(TFClosTime,TIME_DATE|TIME_MINUTES|TIME_SECONDS),font_mode,f_size,t_color,PilCor,xdis,ydis+garis+(3*scale));
     CreateChartText(0,indiname+"SDT4","Next Bar Open Time : "+
                       TimeToString(TFNextTime,TIME_DATE|TIME_MINUTES|TIME_SECONDS),font_mode,f_size,t_color,PilCor,xdis,ydis+garis+(4*scale));
     CreateChartText(0,indiname+"SDT5","Time Remaining : "+txtday,font_mode,f_size,t_color,PilCor,xdis,ydis+garis+(5*scale));                         
     //--
     if(alerts==Yes||UseEmailAlert==Yes||UseSendnotify==Yes)
       {
         if(TimeCurrent()>=TFClosTime && TimeCurrent()<=TFNextTime && !doalert)
           {
             dtB=TimeCurrent();
             AlertTxt="Bar Close time triggered in Timeframe : "+TF2Str(Timeframe)+" @Price: "+DoubleToString(CLOSE[0],Digits());
             Do_Alerts(AlertTxt,dtB);
             TFprevTime=TFClosTime;
             doalert=true;
           }
       }
    //--
//--- return value of prev_calculated for next call
   return(rates_total);
  }

Let's break down the OnCalculate function of MT5 indicator. This function is called on every tick to update the indicator's values and perform calculations. Here's a detailed explanation:

Function Definition and Parameters:


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[])

1. Function Purpose: This function is responsible for calculating and updating the indicator's values on each new tick.

2. Parameters:

  • rates_total: - The total number of bars.
  • prev_calculated: - The number of bars calculated on the previous call.
  • time, open, high, low, close, tick_volume, volume, spread - Arrays containing the bar data for the symbol.

3. Code Breakdown:

  • ArrayResize(TIME, cbar);
  • ArrayResize(CLOSE, cbar);
  • ArraySetAsSeries(TIME, true);
  • ArraySetAsSeries(CLOSE, true);
  • ArraySetAsSeries(time, true);
  • ArraySetAsSeries(close, true);

Array Setup: Resizes and sets arrays to series to access data from the current bar to the oldest.

Fuction Call:

RefreshPrice(Timeframe);

Refresh Price Data: Calls a custom function to refresh price data for the specified timeframe.

  • TFOpenTime = TIME[0];
  • CheckSeconds();

Initialize Variables: Sets the opening time of the current bar and calls a custom function to check seconds.

  • TFNextTime = TFOpenTime + extime;
  • TFClosTime = TFNextTime - 1;
  • TFTimeRem = fabs(TimeCurrent() - TFClosTime);
  • tmrem = TFClosTime - TimeCurrent();
  • datetime dtB = 0;
  • if (TFClosTime != TFprevTime) doalert = false;
  • string SDT = ReqDate(TimeCurrent(), ReqTime(TimeCurrent(), day), ReqTime(TimeCurrent(), hour), ReqTime(TimeCurrent(), min), ReqTime(TimeCurrent(), sec));

Calculate Times: Calculates the next bar's opening and closing times, the remaining time until the bar closes, and other time-related variables.


//--
if(TimeCurrent()<TFClosTime)
  {
    remd=ReqTime(TFClosTime,day)-ReqTime(TimeCurrent(),day);
    exday=int(remd);
    if(exday<=0) exday=0;
    txtday=exday==0 ? (string)ReqTime(TFTimeRem,hour)+":"+(string)ReqTime(TFTimeRem,min)+":"+(string)ReqTime(TFTimeRem,sec) :
                    (string)exday+" Day ~ "+(string)ReqTime(TFTimeRem,hour)+":"+(string)ReqTime(TFTimeRem,min)+":"+   (string)ReqTime(TFTimeRem,sec);
  }
//--

Calculate Remaining Time: Determines the remaining time until the current bar closes and formats it for display.

CreateChartText Function Calls:

  • CreateChartText(0, indiname + "SDT0", "Server Date Time : " + SDT, font_mode, f_size, t_color, PilCor, xdis, ydis);
  • CreateChartText(0, indiname + "SDT11", "------------------------------------------------------", font_mode, f_size, t_color, PilCor, xdis, ydis + garis);
  • CreateChartText(0, indiname + "SDT1", _pname + " : Period " + TF2Str(Timeframe), font_mode, f_size, t_color, PilCor, xdis, ydis + garis + (1 * scale));
  • CreateChartText(0, indiname + "SDT2", "Bar Open Time : " + TimeToString(TFOpenTime, TIME_DATE|TIME_MINUTES|TIME_SECONDS), font_mode, f_size, t_color, PilCor, xdis, ydis + garis + (2 * scale));
  • CreateChartText(0, indiname + "SDT3", "Bar Close Time : " + TimeToString(TFClosTime, TIME_DATE|TIME_MINUTES|TIME_SECONDS), font_mode, f_size, t_color, PilCor, xdis, ydis + garis + (3 * scale));
  • CreateChartText(0, indiname + "SDT4", "Next Bar Open Time : " + TimeToString(TFNextTime, TIME_DATE|TIME_MINUTES|TIME_SECONDS), font_mode, f_size, t_color, PilCor, xdis, ydis + garis + (4 * scale));
  • CreateChartText(0, indiname + "SDT5", "Time Remaining : " + txtday, font_mode, f_size, t_color, PilCor, xdis, ydis + garis + (5 * scale));

Display Information:

Uses custom CreateChartText function to display various pieces of information on the chart, such as server date/time, bar open/close times, and time remaining.

Alerts:


if (alerts == Yes || UseEmailAlert == Yes || UseSendnotify == Yes)
{
  if (TimeCurrent() >= TFClosTime && TimeCurrent() <= TFNextTime && !doalert)
  {
    dtB = TimeCurrent();
    AlertTxt = "Bar Close time triggered in Timeframe : " + TF2Str(Timeframe) + " @Price: " + DoubleToString(CLOSE[0], Digits());
    Do_Alerts(AlertTxt, dtB);
    TFprevTime = TFClosTime;
    doalert = true;
  }
}

Trigger Alerts: Checks if current time is within the bar's closing period and triggers alerts if necessary.

Return Value: return(rates_total);

Return Statement: Returns the total number of rates (bars) calculated, which is used for the next call to OnCalculate.

This function ensures that the indicator updates accurately with each new tick, displaying relevant information on the chart and triggering alerts as needed.

CheckSeconds Function:

Let's explain the CheckSeconds function:

1. Purpose: The CheckSeconds function determines the number of seconds in a specific timeframe and assigns it to the extime variable. This helps to calculate the duration of each bar in the selected timeframe.

2. Code Breakdown:


int CheckSeconds(void)
  {
   //---
   switch(Timeframe)
     {
       //--
       case PERIOD_M1:   extime=PeriodSeconds(PERIOD_M1);     break;
       case PERIOD_M2:   extime=PeriodSeconds(PERIOD_M2);     break;
       case PERIOD_M3:   extime=PeriodSeconds(PERIOD_M3);     break;
       case PERIOD_M4:   extime=PeriodSeconds(PERIOD_M4);     break;
       case PERIOD_M5:   extime=PeriodSeconds(PERIOD_M5);     break;
       case PERIOD_M6:   extime=PeriodSeconds(PERIOD_M6);     break;
       case PERIOD_M10:  extime=PeriodSeconds(PERIOD_M10);    break;
       case PERIOD_M12:  extime=PeriodSeconds(PERIOD_M12);    break;
       case PERIOD_M15:  extime=PeriodSeconds(PERIOD_M15);    break;
       case PERIOD_M20:  extime=PeriodSeconds(PERIOD_M20);    break;
       case PERIOD_M30:  extime=PeriodSeconds(PERIOD_M30);    break;
       case PERIOD_H1:   extime=PeriodSeconds(PERIOD_H1);     break;
       case PERIOD_H2:   extime=PeriodSeconds(PERIOD_H2);     break;
       case PERIOD_H3:   extime=PeriodSeconds(PERIOD_H3);     break;
       case PERIOD_H4:   extime=PeriodSeconds(PERIOD_H4);     break;
       case PERIOD_H6:   extime=PeriodSeconds(PERIOD_H6);     break;
       case PERIOD_H8:   extime=PeriodSeconds(PERIOD_H8);     break;
       case PERIOD_H12:  extime=PeriodSeconds(PERIOD_H12);    break;
       case PERIOD_D1:   extime=PeriodSeconds(PERIOD_D1);     break;
       case PERIOD_W1:   extime=PeriodSeconds(PERIOD_W1);     break;
       case PERIOD_MN1:  extime=PeriodSeconds(PERIOD_MN1);    break;
       //--
     }
    //--
    return(extime);
  }

3. Explanation:

1. Function Signature: int CheckSeconds(void)

This function returns an integer value representing the number of seconds in the current timeframe.

2. Switch Statement: switch(Timeframe)

The switch statement evaluates the Timeframe variable to determine which timeframe is being used.

Case Statements:

  • case PERIOD_M1: extime=PeriodSeconds(PERIOD_M1); break;
  • case PERIOD_M2: extime=PeriodSeconds(PERIOD_M2); break;
  • case PERIOD_M3: extime=PeriodSeconds(PERIOD_M3); break;
  • case PERIOD_M4: extime=PeriodSeconds(PERIOD_M4); break;
  • case PERIOD_M5: extime=PeriodSeconds(PERIOD_M5); break;
  • case PERIOD_M6: extime=PeriodSeconds(PERIOD_M6); break;
  • case PERIOD_M10: extime=PeriodSeconds(PERIOD_M10); break;
  • case PERIOD_M12: extime=PeriodSeconds(PERIOD_M12); break;
  • case PERIOD_M15: extime=PeriodSeconds(PERIOD_M15); break;
  • case PERIOD_M20: extime=PeriodSeconds(PERIOD_M20); break;
  • case PERIOD_M30: extime=PeriodSeconds(PERIOD_M30); break;
  • case PERIOD_H1: extime=PeriodSeconds(PERIOD_H1); break;
  • case PERIOD_H2: extime=PeriodSeconds(PERIOD_H2); break;
  • case PERIOD_H3: extime=PeriodSeconds(PERIOD_H3); break;
  • case PERIOD_H4: extime=PeriodSeconds(PERIOD_H4); break;
  • case PERIOD_H6: extime=PeriodSeconds(PERIOD_H6); break;
  • case PERIOD_H8: extime=PeriodSeconds(PERIOD_H8); break;
  • case PERIOD_H12: extime=PeriodSeconds(PERIOD_H12); break;
  • case PERIOD_D1: extime=PeriodSeconds(PERIOD_D1); break;
  • case PERIOD_W1: extime=PeriodSeconds(PERIOD_W1); break;
  • case PERIOD_MN1: extime=PeriodSeconds(PERIOD_MN1); break;

For each timeframe (e.g., PERIOD_M1, PERIOD_H1, etc.), the corresponding number of seconds is calculated using the PeriodSeconds function and assigned to the extime variable.

Return Statement: return(extime);

The function returns the value of extime, which represents the duration of each bar in seconds for the selected timeframe.

This function is crucial for ensuring that the indicator can accurately calculate the time remaining until the current bar closes, regardless of the timeframe selected.

RefreshPrice Function.

1. Purpose:

The RefreshPrice function updates the price data arrays for a specified timeframe. This helps ensure that the indicator has the latest data for its calculations.

2. Code Breakdown:


void RefreshPrice(ENUM_TIMEFRAMES xtf)
  {
    //---
    MqlRates parray[]; 
    ArraySetAsSeries(parray, true); 
    int copied = CopyRates(Symbol(), xtf, 0, cbar, parray);
    //--
    int cc = CopyClose(Symbol(), xtf, 0, cbar, CLOSE);
    int ct = CopyTime(Symbol(), xtf, 0, cbar, TIME);
    //--
    return;
    //---
  } //-end RefreshPrice()
//---------//

3. Explanation:

1. Function Signature: void RefreshPrice(ENUM_TIMEFRAMES xtf)

The function takes a single parameter xtf of type ENUM_TIMEFRAMES, which specifies the timeframe to update.

2. Declare and Initialize MqlRates Array:

  • MqlRates parray[];
  • ArraySetAsSeries(parray, true);

Declares an array parray of type MqlRates to store the price data.

ArraySetAsSeries(parray, true) sets the array to be accessed as a series (with the latest data at index 0).

3. Copy Rates Data: int copied = CopyRates(Symbol(), xtf, 0, cbar, parray);

Uses CopyRates to copy the rates (OHLC and others data) for the specified symbol and timeframe into the parray array.

  • Symbol() returns the current symbol.
  • xtf is the timeframe.
  • 0 is the starting position.
  • cbar is the number of bars to copy.
  • parray is the destination array.

The function returns the number of copied rates and stores it in copied.

Copy Close Prices: int cc = CopyClose(Symbol(), xtf, 0, cbar, CLOSE);

Uses CopyClose to copy the close prices for the specified symbol and timeframe into the CLOSE array.

The function returns the number of copied close prices and stores it in cc.

Copy Time Data: int ct = CopyTime(Symbol(), xtf, 0, cbar, TIME);

Uses CopyTime to copy the time data for the specified symbol and timeframe into the TIME array.

The function returns the number of copied time values and stores it in ct.

Return Statement: return;

The function returns void, indicating it does not return any value. The return statement is used to exit the function.

This function is crucial for ensuring that the indicator always has the most up-to-date price data, which is essential for accurate calculations and display.

timehr Function

1. Purpose: The timehr function formats the given hour and minute values into a string representation of time in the "HH:MM" format.

2. Code Breakdown:


string timehr(int hr,int mn)
  {
//---
    string scon="";
    string men=mn==0 ? "00" : string(mn);
    int shr=hr==24 ? 0 : hr;
    if(shr<10) scon="0"+string(shr)+":"+men;
    else scon=string(shr)+":"+men;
    //--
    return(scon);
//---
  } //-end timehr()
//---------//

3. Explanation:

1. Function Signature: The function takes two integer parameters: hr for hours and mn for minutes. It returns a string representing the formatted time.

2. Variable Initialization:

  • string scon = "";
  • string men = mn == 0 ? "00" : string(mn);
  • int shr = hr == 24 ? 0 : hr;

scon is initialized as an empty string.

men is set to "00" if mn is 0; otherwise, it is set to the string representation of mn.

shr is set to 0 if hr is 24 (to represent midnight as "00:00"); otherwise, it is set to hr.

3. Conditional Formatting:


if (shr < 10) scon = "0" + string(shr) + ":" + men;
else scon = string(shr) + ":" + men;

If shr is less than 10, scon is formatted with a leading zero (e.g., "09:00").

If shr is 10 or greater, scon is formatted without a leading zero (e.g., "10:00").

4. Return Statement: The function returns the formatted string scon, which represents the time in "HH:MM" format.

This function is useful for ensuring that time values are consistently formatted, which is particularly important for displaying times in a readable and standardized manner on charts or logs.

ReqDate Function.

1. Purpose: The ReqDate function formats a given datetime value into a custom string representation that includes the date and time.

2. Code Breakdown:


string ReqDate(datetime reqtime,int d,int h,int m,int s) 
  { 
//---
   MqlDateTime mdt; 
   datetime t=TimeToStruct(reqtime,mdt);
   x_year=mdt.year; 
   x_mon=mdt.mon; 
   x_day=d; 
   x_hour=h; 
   x_min=m;
   x_sec=s;
   //--
   string mdr=string(x_year)+"."+string(x_mon)+"."+string(x_day)+" ~ "+timehr(x_hour,x_min)+":"+string(x_sec);
   return(mdr);
//---
  } //-end ReqDate()
//---------//

3. Explanation:

1. Function Signature: string ReqDate(datetime reqtime, int d, int h, int m, int s)

The function takes five parameters:

  • reqtime: The datetime value to be converted.
  • d: Day component to be used.
  • h: Hour component to be used.
  • m: Minute component to be used.
  • s: Second component to be used.

It returns a string representing the formatted date and time.

2. Variable Initialization:

  • MqlDateTime mdt;
  • datetime t = TimeToStruct(reqtime, mdt);

Declares an MqlDateTime structure mdt to hold the components of the datetime.

Converts reqtime into a structured datetime format using TimeToStruct and stores it in mdt.

3. Assign Date and Time Components:

  • x_year = mdt.year;
  • x_mon = mdt.mon;
  • x_day = d;
  • x_hour = h;
  • x_min = m;
  • x_sec = s;

Assigns the year and month from mdt to global variables x_year and x_mon.

Assigns the day, hour, minute, and second from the parameters d, h, m, and s to global variables x_day, x_hour, x_min, and x_sec.

4. Format String:

string mdr = string(x_year) + "." + string(x_mon) + "." + string(x_day) + " ~ " + timehr(x_hour, x_min) + ":" + string(x_sec);

Formats the date and time into a string mdr in the format "YYYY.MM.DD ~ HH:MM:SS".

Uses the timehr function to format the hour and minute components.

5. Return Statement: return(mdr);

The function returns the formatted string mdr.

This function is useful for generating a custom string representation of a datetime value, which can be displayed on the chart or used in logs.

ReqTime Function.

1. Purpose: The ReqTime function extracts a specific component of a given datetime value and returns it based on the requested mode.

2. Code Breakdown:


int ReqTime(datetime reqtime,
            const int reqmode) 
  {
    MqlDateTime tm;
    TimeToStruct(reqtime,tm);
    int valtm=0;
    //--
    switch(reqmode)
      {
        case 0: valtm=tm.year; break;        // Return Year 
        case 1: valtm=tm.mon;  break;        // Return Month 
        case 2: valtm=tm.day;  break;        // Return Day 
        case 3: valtm=tm.hour; break;        // Return Hour 
        case 4: valtm=tm.min;  break;        // Return Minutes 
        case 5: valtm=tm.sec;  break;        // Return Seconds 
        case 6: valtm=tm.day_of_week; break; // Return Day of week (0-Sunday, 1-Monday, ... ,6-Saturday) 
        case 7: valtm=tm.day_of_year; break; // Return Day number of the year (January 1st is assigned the number value of zero) 
      }
    //--
    return(valtm);
//---
  } //-end ReqTime()
//---------//

3. Explanation:

1. Function Signature: int ReqTime(datetime reqtime, const int reqmode)

The function takes two parameters:

  • reqtime: The datetime value from which to extract the component.
  • reqmode: An integer indicating which component of the datetime to return.

The function returns an integer value representing the requested component of the datetime.

2. Convert datetime to MqlDateTime:

  • MqlDateTime tm;
  • TimeToStruct(reqtime, tm);

Declares a MqlDateTime structure tm.

Converts the reqtime datetime value into the structured tm format using TimeToStruct.

3. Initialize Return Variable: int valtm = 0;

Initializes an integer variable valtm to store the value of the requested datetime component.

4. Switch Statement:


switch(reqmode)
{
  case 0: valtm = tm.year; break;        // Return Year 
  case 1: valtm = tm.mon;  break;        // Return Month 
  case 2: valtm = tm.day;  break;        // Return Day 
  case 3: valtm = tm.hour; break;        // Return Hour 
  case 4: valtm = tm.min;  break;        // Return Minutes 
  case 5: valtm = tm.sec;  break;        // Return Seconds 
  case 6: valtm = tm.day_of_week; break; // Return Day of week (0-Sunday, 1-Monday, ... ,6-Saturday) 
  case 7: valtm = tm.day_of_year; break; // Return Day number of the year (January 1st is assigned the number value of zero) 
}

The switch statement evaluates reqmode to determine which component of the datetime to return.

Each case in the switch statement corresponds to a specific component of the datetime structure:

  • 0 returns the year.
  • 1 returns the month.
  • 2 returns the day.
  • 3 returns the hour.
  • 4 returns the minutes.
  • 5 returns the seconds.
  • 6 returns the day of the week.
  • 7 returns the day number of the year.

5. Return Statement: return(valtm);

The function returns the value of valtm, which contains the requested component of the datetime.

This ReqTime function is useful for extracting specific components of a datetime value, allowing for flexible handling of date and time data.

TF2Str Function.

1.Purpose: The TF2Str function converts a given period code (representing a timeframe) into a string representation.

2. Code Breakdown:


string TF2Str(int period)
  {
   switch(period)
     {
       //--
       case PERIOD_M1:   return("M1");
       case PERIOD_M2:   return("M2");
       case PERIOD_M3:   return("M3");
       case PERIOD_M4:   return("M4");
       case PERIOD_M5:   return("M5");
       case PERIOD_M6:   return("M6");
       case PERIOD_M10:  return("M10");
       case PERIOD_M12:  return("M12");
       case PERIOD_M15:  return("M15");
       case PERIOD_M20:  return("M20");
       case PERIOD_M30:  return("M30");
       case PERIOD_H1:   return("H1");
       case PERIOD_H2:   return("H2");
       case PERIOD_H3:   return("H3");
       case PERIOD_H4:   return("H4");
       case PERIOD_H6:   return("H6");
       case PERIOD_H8:   return("H8");
       case PERIOD_H12:  return("H12");
       case PERIOD_D1:   return("D1");
       case PERIOD_W1:   return("W1");
       case PERIOD_MN1:  return("MN1");
       //--
     }
   return(string(period));
  }

3. Explanation:

1. Function Signature: string TF2Str(int period)

The function takes a single integer parameter period and returns a string representation of the timeframe.

2. Switch Statement: switch(period)

The switch statement evaluates the period variable to determine which timeframe it represents.

Case Statements:

  • case PERIOD_M1: return("M1");
  • case PERIOD_M2: return("M2");
  • case PERIOD_M3: return("M3");
  • case PERIOD_M4: return("M4");
  • case PERIOD_M5: return("M5");
  • case PERIOD_M6: return("M6");
  • case PERIOD_M10: return("M10");
  • case PERIOD_M12: return("M12");
  • case PERIOD_M15: return("M15");
  • case PERIOD_M20: return("M20");
  • case PERIOD_M30: return("M30");
  • case PERIOD_H1: return("H1");
  • case PERIOD_H2: return("H2");
  • case PERIOD_H3: return("H3");
  • case PERIOD_H4: return("H4");
  • case PERIOD_H6: return("H6");
  • case PERIOD_H8: return("H8");
  • case PERIOD_H12: return("H12");
  • case PERIOD_D1: return("D1");
  • case PERIOD_W1: return("W1");
  • case PERIOD_MN1: return("MN1");

Each case corresponds to a specific period constant (e.g., PERIOD_M1, PERIOD_H1, etc.) and returns the corresponding string representation (e.g., "M1", "H1").

Default Case: return(string(period));

If the period does not match any of the specified cases, the function converts the period integer to a string and returns it.

This TF2Str function is useful for converting timeframe constants into readable string representations, which can be displayed on the chart or used in logs.

Do_Alerts Function.

1. Purpose: The Do_Alerts function generates and sends alerts in various formats (print message, alert box, email, and notification) based on the user settings.

2. Code Breakdown:


void Do_Alerts(string msgText, datetime Altime)
  {
    //---
    // Print message in the terminal
    Print(_pname + " --- " + Symbol() + ": " + msgText +
          "\n --- at: ", TimeToString(Altime, TIME_DATE | TIME_MINUTES | TIME_SECONDS));
    //--
    if(alerts == Yes)
      {
        Alert(_pname, " --- " + Symbol() + ": " + msgText +
              " --- at: ", TimeToString(Altime, TIME_DATE | TIME_MINUTES | TIME_SECONDS));
      }
    //--
    if(UseEmailAlert == Yes) 
      SendMail(_pname, " --- " + Symbol() + " " + TF2Str(Period()) + ": " + msgText +
                       "\n--- at: " + TimeToString(Altime, TIME_DATE | TIME_MINUTES | TIME_SECONDS));
    //--
    if(UseSendnotify == Yes) 
      SendNotification(_pname + "--- " + Symbol() + " " + TF2Str(Period()) + ": " + msgText +
                      "\n --- at: " + TimeToString(Altime, TIME_DATE | TIME_MINUTES | TIME_SECONDS));
    //--
    return;
    //---
  } //-end Do_Alerts()
//---------//

3. Explanation:

1. Function Signature: void Do_Alerts(string msgText, datetime Altime)

The function takes two parameters:

  • msgText: A string containing the alert message text.
  • Altime: A datetime value indicating the alert time.

2. Print Alert in Terminal:

  • Print(_pname + " --- " + Symbol() + ": " + msgText + "\n --- at: ", TimeToString(Altime, TIME_DATE | TIME_MINUTES | TIME_SECONDS));

Prints the alert message to the terminal, including the program name (_pname), symbol, message text, and formatted alert time.

Alert Box:


if(alerts == Yes)
  {
    Alert(_pname, " --- " + Symbol() + ": " + msgText +
          " --- at: ", TimeToString(Altime, TIME_DATE | TIME_MINUTES | TIME_SECONDS));
  }

If the alerts setting is enabled (Yes), displays an alert box with the program name, symbol, message text, and formatted alert time.

Email Alert:


if(UseEmailAlert == Yes) 
  SendMail(_pname, " --- " + Symbol() + " " + TF2Str(Period()) + ": " + msgText +
                   "\n--- at: " + TimeToString(Altime, TIME_DATE | TIME_MINUTES | TIME_SECONDS));

If the UseEmailAlert setting is enabled (Yes), sends an email with the program name, symbol, timeframe, message text, and formatted alert time.

Notification Alert:


if(UseSendnotify == Yes) 
  SendNotification(_pname + "--- " + Symbol() + " " + TF2Str(Period()) + ": " + msgText +
                  "\n --- at: " + TimeToString(Altime, TIME_DATE | TIME_MINUTES | TIME_SECONDS));

If the UseSendnotify setting is enabled (Yes), sends a notification with the program name, symbol, timeframe, message text, and formatted alert time.

3. Return Statement: return;

The function returns void, indicating it does not return any value. The return statement is used to exit the function.

This Do_Alerts function provides a comprehensive alerting mechanism, ensuring that users are notified in multiple ways based on their preferences.

CreateChartText Function.

Let's break down the CreateChartText function and explain its components in detail:

1. Purpose: The CreateChartText function creates and manages a text label on the chart with specific properties, including text content, font style, size, color, and position.

2. Code Breakdown:


void CreateChartText(long   chart_id, 
                     string lable_name, 
                     string label_text,
                     string font_model,
                     int    font_size,
                     color  label_color,
                     int    chart_corner,
                     int    x_cor, 
                     int    y_cor) 
  { 
//--- 
   if(ObjectFind(chart_id,lable_name)<0)
     {
       if(ObjectCreate(chart_id,lable_name,OBJ_LABEL,0,0,0,0,0)) 
         { 
           ObjectSetString(chart_id,lable_name,OBJPROP_TEXT,label_text);
           ObjectSetString(chart_id,lable_name,OBJPROP_FONT,font_model); 
           ObjectSetInteger(chart_id,lable_name,OBJPROP_FONTSIZE,font_size);
           ObjectSetInteger(chart_id,lable_name,OBJPROP_COLOR,label_color);
           ObjectSetInteger(chart_id,lable_name,OBJPROP_CORNER,chart_corner);
           ObjectSetInteger(chart_id,lable_name,OBJPROP_XDISTANCE,x_cor);
           ObjectSetInteger(chart_id,lable_name,OBJPROP_YDISTANCE,y_cor);
         } 
       else 
          {Print("Failed to create the object OBJ_LABEL ",lable_name,", Error code = ", GetLastError());}
     }
   else
     {
       ObjectSetString(chart_id,lable_name,OBJPROP_TEXT,label_text);
       ObjectSetString(chart_id,lable_name,OBJPROP_FONT,font_model); 
       ObjectSetInteger(chart_id,lable_name,OBJPROP_FONTSIZE,font_size);
       ObjectSetInteger(chart_id,lable_name,OBJPROP_COLOR,label_color);
       ObjectSetInteger(chart_id,lable_name,OBJPROP_CORNER,chart_corner);
       ObjectSetInteger(chart_id,lable_name,OBJPROP_XDISTANCE,x_cor);
       ObjectSetInteger(chart_id,lable_name,OBJPROP_YDISTANCE,y_cor);
     }
//---
  }
//---------//

3. Explanation:

1. Function Signature:


void CreateChartText(long chart_id, 
                     string lable_name, 
                     string label_text,
                     string font_model,
                     int font_size,
                     color label_color,
                     int chart_corner,
                     int x_cor, 
                     int y_cor)

The function takes several parameters:

  • chart_id: The ID of the chart where the label will be created.
  • lable_name: The name of the label object.
  • label_text: The text content of the label.
  • font_model: The font style for the label text.
  • font_size: The font size for the label text.
  • label_color: The color of the label text.
  • chart_corner: The corner of the chart where the label will be positioned.
  • x_cor: The horizontal distance from the specified corner.
  • y_cor: The vertical distance from the specified corner.

2. Check if Label Exists:


if(ObjectFind(chart_id, lable_name) < 0)

Checks if the label object already exists on the chart.

If it does not exist (< 0), it proceeds to create a new label.

3. Create New Label:


if(ObjectCreate(chart_id, lable_name, OBJ_LABEL, 0, 0, 0, 0, 0))

Attempts to create a new label object with the specified parameters.

If the creation is successful, it sets various properties for the label:

  • ObjectSetString(chart_id, lable_name, OBJPROP_TEXT, label_text);
  • ObjectSetString(chart_id, lable_name, OBJPROP_FONT, font_model);
  • ObjectSetInteger(chart_id, lable_name, OBJPROP_FONTSIZE, font_size);
  • ObjectSetInteger(chart_id, lable_name, OBJPROP_COLOR, label_color);
  • ObjectSetInteger(chart_id, lable_name, OBJPROP_CORNER, chart_corner);
  • ObjectSetInteger(chart_id, lable_name, OBJPROP_XDISTANCE, x_cor);
  • ObjectSetInteger(chart_id, lable_name, OBJPROP_YDISTANCE, y_cor);

4. Error Handling:


else 
{
  Print("Failed to create the object OBJ_LABEL ", lable_name, ", Error code = ", GetLastError());
}

If the label creation fails, it prints an error message with the error code.

5. Update Existing Label:


else
{
  ObjectSetString(chart_id, lable_name, OBJPROP_TEXT, label_text);
  ObjectSetString(chart_id, lable_name, OBJPROP_FONT, font_model); 
  ObjectSetInteger(chart_id, lable_name, OBJPROP_FONTSIZE, font_size);
  ObjectSetInteger(chart_id, lable_name, OBJPROP_COLOR, label_color);
  ObjectSetInteger(chart_id, lable_name, OBJPROP_CORNER, chart_corner);
  ObjectSetInteger(chart_id, lable_name, OBJPROP_XDISTANCE, x_cor);
  ObjectSetInteger(chart_id, lable_name, OBJPROP_YDISTANCE, y_cor);
}

If the label already exists, it updates the properties of the existing label with the new values.

This CreateChartText function allows you to dynamically create and manage text labels on the chart, ensuring that the labels are created if they do not exist or updated if they already exist.

TimeBarCloseCheck Indicator Alerts.

Overview: The TimeBarCloseCheck indicator is designed to assist traders by providing real-time alerts when a bar (or candlestick) closes on the MetaTrader 5 platform. This feature is crucial for traders who rely on precise timing to make informed trading decisions.

Key Features:

Immediate Notifications: The indicator generates instant alerts as soon as a bar closes. This ensures that traders are always aware of the exact moment a bar closes, allowing them to respond swiftly to market changes.

Multiple Alert Options: Traders can choose from various alert types, including pop-up alerts, email notifications, and push notifications to their mobile devices. This flexibility ensures that traders never miss an important alert, regardless of where they are.

Customizable Settings: The alert settings are highly customizable, enabling traders to set up alerts according to their specific trading strategies and preferences. Whether it's adjusting the timeframe or selecting the type of alert, traders have full control.

Enhanced Decision Making: By providing timely and accurate alerts, the TimeBarCloseCheck indicator helps traders make better decisions. Knowing the precise time and price at which a bar closes can significantly improve the timing of trade entries and exits.

User-Friendly Interface: The alerts are displayed in an easy-to-read format, complete with the symbol, timeframe, and closing price. This ensures that traders can quickly understand the alert without any confusion.

Considerations:

Despite the robust features, traders should be aware of the potential delays caused by varying internet speeds and broker server delays. These factors can impact the timing accuracy of alert.

1. Internet Speed:Different traders have varying internet speeds, which can affect how quickly they receive alerts. Slower internet speeds may result in a slight delay in receiving the alert.

2. Broker Server Delay: The delay from the broker’s server when sending data to MT5 can also impact alert timing. If an alert is supposed to trigger one second before the new bar opens, and there is a server delay, the alert might not trigger at the exact time. Instead, it might trigger slightly late, or in some cases, it may miss the timing entirely because the new bar has already opened by the time the delay is resolved.

Example Alert:

Alert: TimeBarCloseCheck --- GBPJPY: Bar Close time triggered in Timeframe: M1 @Price: 192.311 --- at: 2024.11.26 20:09:59

In this example, the alert informs the trader that the GBPJPY bar on the M1 timeframe has closed at a price of 192.311. The exact time of the bar close is also provided, allowing the trader to take immediate action if necessary.

Conclusion:

The TimeBarCloseCheck indicator is an essential tool for traders who value precision and timely information. By leveraging its powerful alert features and being mindful of potential delays due to internet speed and broker server latency, traders can stay ahead of the market and make more informed trading decisions.

That's all for the article How to detect Bar Close Time in MT5 and MT4 programs, hopefully it's useful.

Thank you for reading.

Please download the Expert Advisor: TimeBarCloseCheck

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: TimeBarCloseCheck Expert Advisor.

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

YouTube Channel: @ForexHomeExperts

YouTube Playlist: @ForexHomeExperts YouTube Playlist

Monday, November 25, 2024

Before we start discussing how to create a program to detect whether a new bar has appeared or not on MT5 and MT4, it's a good idea to know the benefits of detecting new bars.

How to detect new bars on Expert Advisors in MT4 and MT5

Detecting new bars in MT4 or MT5 has several important benefits for traders, especially in increasing the efficiency and effectiveness of their trading strategies and the use of automated trading like expert advisor.. Here are some of the main benefits:

  • 1. Faster Decision-Making: Detecting new bars helps you get instant updates on price changes, allowing you to make quick decisions based on the latest data.
  • 2. Less Data Clutter: By focusing on new bars, you avoid unnecessary data and concentrate on the most important information for your strategy.
  • 3. Increased Efficiency: You don't need to manually check charts all the time. This frees you up to focus on deeper analysis or other activities.
  • 4. Automation: Integrate new bar detection with automation tools for sending messages or placing orders automatically when certain conditions are met.
  • 5. Better Monitoring: Keep a closer eye on market trends and detect trend changes faster by watching for new bars.
  • 6. Reduced Stress: You don't have to constantly monitor charts, which helps reduce stress and improves your concentration.
  • 7. Improved Trading Strategies: With quicker and more accurate information, you can develop and optimize your trading strategies more effectively.

Overall, detecting new bars in MT4 or MT5 helps traders be more efficient, make better decisions, and manage their trading activities more effectively. It can be clearly said that detecting new bars is very important in using automatic trading or expert advisors.

Example of a simple program in MQL5


//+------------------------------------------------------------------+
//|                                                   TestNewBar.mq5 |
//|        Copyright 2024, Roberto Jacobs (3rjfx) ~ Date: 2024-11-24 |
//|                              https://www.mql5.com/en/users/3rjfx |
//+------------------------------------------------------------------+
#property copyright "Copyright 2024, Roberto Jacobs (3rjfx) ~ Date: 2024-11-24"
#property link      "https://www.mql5.com/en/users/3rjfx"
#property version   "1.00"
#property strict
//--
//+------------------------------------------------------------------+
//|                             Include                              |
//+------------------------------------------------------------------+
#include <trade rade.mqh="">
#include <trade ositioninfo.mqh="">
#include <trade ymbolinfo.mqh="">
#include <trade ccountinfo.mqh="">
//--
CTrade              mc_trade;
CSymbolInfo         mc_symbol;
CPositionInfo       mc_position; 
CAccountInfo        mc_account;
//---
//--
input ENUM_TIMEFRAMES  Timeframe = PERIOD_H1;     // Select Expert TimeFrame, default PERIOD_H1

//--
datetime         
   PrevbarBuy,
   TimebarBuy,
   PrevbarSell,
   TimebarSell;
//+------------------------------------------------------------------+
//| Expert initialization function                                   |
//+------------------------------------------------------------------+
int OnInit()
  {
//---
     // Initialization code here
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Expert deinitialization function                                 |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   Comment("");
   PrintFormat("%s: Deinitialization reason code=%d",__FUNCTION__,reason);
   //--
   return;
//---
  }
//+------------------------------------------------------------------+
//| Expert tick function                                             |
//+------------------------------------------------------------------+
void OnTick()
  {
//---
     //- For Open Order Buy
     if(IFNewBarsB()) { OpenBuy(); PrevbarBuy=TimebarBuy; }
     //--
     //- For Open Order Sell
     if(IFNewBarsB()) { OpenSell(); PrevbarSell=TimebarSell; }
    //--
    return;
//---
  }
//+------------------------------------------------------------------+

bool IFNewBarsB(void) // New bar check buy order
  {
//---
    bool Nb=false;
    //--
    TimebarBuy=iTime(Symbol(),Timeframe,0);
    if(TimebarBuy!=PrevbarBuy) Nb=true;
    //--
    return(Nb);
//---
  } //-end IFNewBarsB()
//---------//

bool IFNewBarsS(void) // New bar check sell order
  {
//---
    bool Nb=false;
    //--
    TimebarSell=iTime(Symbol(),Timeframe,0);
    if(TimebarSell!=PrevbarSell) Nb=true;
    //--
    return(Nb);
//---
  } //-end IFNewBarsS()
//---------//

bool OpenBuy(void) 
  {
//---
    ResetLastError();
    //--
    bool buyopen      = false;
    //--
    MqlTradeRequest req={};
    MqlTradeResult  res={};
    MqlTradeCheckResult check={};
    //-- structure is set to zero
    ZeroMemory(req);
    ZeroMemory(res);
    ZeroMemory(check);
    //--
    double Lot=0.01;
    double SL=0.0;
    double TP=0.0;
    //--
    buyopen=mc_trade.Buy(Lot,Symbol(),mc_symbol.Ask(),SL,TP,"Your Comment");
    //--
    int error=GetLastError();
    if(buyopen||error==0)
      {
        string bsopen="Open BUY Order for "+Symbol()+" ~ Ticket= ["+(string)mc_trade.ResultOrder()+"] successfully..!";
        PrevbarBuy=iTime(Symbol(),Timeframe,0);
      }
    else
      {
        mc_trade.CheckResult(check);
        return(false);   
      }
    //--
    return(buyopen);
    //--
//---
  } //-end OpenBuy
//---------//

bool OpenSell(void) 
  {
//---
    ResetLastError();
    //--
    bool selopen      = false;
    //--
    MqlTradeRequest req={};
    MqlTradeResult  res={};
    MqlTradeCheckResult check={};
    //-- structure is set to zero
    ZeroMemory(req);
    ZeroMemory(res);
    ZeroMemory(check);
    //--
    double Lot=0.0;
    double SL=0.0;
    double TP=0.0;
    //--
    selopen=mc_trade.Sell(Lot,Symbol(),mc_symbol.Bid(),SL,TP,"Your Comment");
    //--
    int error=GetLastError();
    if(selopen||error==0)
      {
        string bsopen="Open SELL Order for "+Symbol()+" ~ Ticket= ["+(string)mc_trade.ResultOrder()+"] successfully..!";
        PrevbarSell=iTime(Symbol(),Timeframe,0);
      }
    else
      {
        mc_trade.CheckResult(check);
        return(false);   
      }
    //--
    return(selopen);
    //--
//---
  } //-end OpenSell
//---------//

Includes and Declarations.


#include <trade rade.mqh="">
#include <trade ositioninfo.mqh="">
#include <trade ymbolinfo.mqh="">
#include <trade ccountinfo.mqh="">

CTrade              mc_trade;
CSymbolInfo         mc_symbol;
CPositionInfo       mc_position; 
CAccountInfo        mc_account;

input ENUM_TIMEFRAMES  Timeframe = PERIOD_H1;     // Select Expert TimeFrame, default PERIOD_H1

datetime         
   PrevbarBuy,
   TimebarBuy,
   PrevbarSell,
   TimebarSell;
  • Includes: Importing trade, position, symbol, and account information classes.
  • Declarations: Creating instances of trade, symbol, position, and account classes. Defining the input parameter for selecting the timeframe and datetime variables for buy and sell bars.

int OnInit()
{
   // Initialization code here
   return(INIT_SUCCEEDED);
}

void OnDeinit(const int reason)
{
   Comment("");
   PrintFormat("%s: Deinitialization reason code=%d",__FUNCTION__,reason);
   return;
}
  • OnInit: Runs once when the expert advisor is initialized. It returns INIT_SUCCEEDED to indicate successful initialization.
  • OnDeinit: Runs once when the expert advisor is removed or the terminal is shut down. It clears any comments and prints the deinitialization reason.

void OnTick()
{
   // For Open Order Buy
   if(IFNewBarsB()) { OpenBuy(); PrevbarBuy = TimebarBuy; }
   
   // For Open Order Sell
   if(IFNewBarsB()) { OpenSell(); PrevbarSell = TimebarSell; }
   
   return;
}
  • OnTick: Runs on every tick (price update). It checks for new buy and sell bars and opens orders accordingly.

bool IFNewBarsB(void) // New bar check buy order
  {
//---
    bool Nb=false;
    //--
    TimebarBuy=iTime(Symbol(),Timeframe,0);
    if(TimebarBuy!=PrevbarBuy) Nb=true;
    //--
    return(Nb);
//---
  } //-end IFNewBarsB()
//---------//

bool IFNewBarsS(void) // New bar check sell order
  {
//---
    bool Nb=false;
    //--
    TimebarSell=iTime(Symbol(),Timeframe,0);
    if(TimebarSell!=PrevbarSell) Nb=true;
    //--
    return(Nb);
//---
  } //-end IFNewBarsS()
//---------//
  • IFNewBarsB and IFNewBarsS: Check if a new buy or sell bar has appeared by comparing the current bar time with the previous bar time. If they are different, a new bar is detected, and the function returns true.

bool OpenBuy(void) 
  {
//---
    ResetLastError();
    //--
    bool buyopen      = false;
    //--
    MqlTradeRequest req={};
    MqlTradeResult  res={};
    MqlTradeCheckResult check={};
    //-- structure is set to zero
    ZeroMemory(req);
    ZeroMemory(res);
    ZeroMemory(check);
    //--
    double Lot=0.01;
    double SL=0.0;
    double TP=0.0;
    //--
    buyopen=mc_trade.Buy(Lot,Symbol(),mc_symbol.Ask(),SL,TP,"Your Comment");
    //--
    int error=GetLastError();
    if(buyopen||error==0)
      {
        string bsopen="Open BUY Order for "+Symbol()+" ~ Ticket= ["+(string)mc_trade.ResultOrder()+"] successfully..!";
        PrevbarBuy=iTime(Symbol(),Timeframe,0);
      }
    else
      {
        mc_trade.CheckResult(check);
        return(false);   
      }
    //--
    return(buyopen);
    //--
//---
  } //-end OpenBuy
//---------//

bool OpenSell(void) 
  {
//---
    ResetLastError();
    //--
    bool selopen      = false;
    //--
    MqlTradeRequest req={};
    MqlTradeResult  res={};
    MqlTradeCheckResult check={};
    //-- structure is set to zero
    ZeroMemory(req);
    ZeroMemory(res);
    ZeroMemory(check);
    //--
    double Lot=0.0;
    double SL=0.0;
    double TP=0.0;
    //--
    selopen=mc_trade.Sell(Lot,Symbol(),mc_symbol.Bid(),SL,TP,"Your Comment");
    //--
    int error=GetLastError();
    if(selopen||error==0)
      {
        string bsopen="Open SELL Order for "+Symbol()+" ~ Ticket= ["+(string)mc_trade.ResultOrder()+"] successfully..!";
        PrevbarSell=iTime(Symbol(),Timeframe,0);
      }
    else
      {
        mc_trade.CheckResult(check);
        return(false);   
      }
    //--
    return(selopen);
    //--
//---
  } //-end OpenSell
//---------//
  • OpenBuy and OpenSell: These functions handle opening buy and sell orders. They use the CTrade class to place orders with specified lot sizes, stop loss, and take profit levels. If an order is successfully placed, the functions return true; otherwise, they return false.

Summary:

The improved script detects new bars on the selected timeframe and opens buy or sell orders accordingly. It includes functions to check for new bars and open orders while utilizing the powerful MQL5 trading library.

Many programmers create new bar detection functions with less than ideal considerations. They often rely on the logic: "If the opening time of the current bar is not the same as the previous bar time, then the 'New Bar' condition becomes 'TRUE'. Subsequently, the previous bar time is immediately updated to match the current bar time."

Limitations of the Conventional Logic.

This approach, while straightforward, has significant drawbacks:

  • Transient Condition: The EA (Expert Advisor) will only register the 'New Bar' condition as 'TRUE' at the exact moment the new bar opens. A few seconds later, upon rechecking, the 'New Bar' condition will revert to 'FALSE'.
  • Indicator Signals: This logic fails when EAs rely on indicators to generate signals. Indicators might not produce a signal precisely at the new bar's opening. Consequently, if the new bar condition quickly turns 'FALSE', the EA might miss potential trading opportunities.

Enhanced Algorithm Logic.

To address these issues, I propose a more robust algorithm:

  • 1. New Bar Detection: Check if the new bar condition is 'TRUE'.
  • 2. Order Function Check: Ensure that the open order function (OpenBuy() or OpenSell()) also returns 'TRUE'.
  • 3. Update Time Variables: Only if both checks are 'TRUE', update the previous bar time variable (PrevbarBuy for Buy orders or PrevbarSell for Sell orders) to match the current bar time variable (TimebarBuy or TimebarSell).

This approach guarantees that the previous bar time is updated only after a successful order placement. Thus, when the EA rechecks for a new bar, the function returns 'FALSE', preventing multiple orders from being placed within the same bar.

Handling Reversed Indicator Signals.

In my example program, I use separate time variables for Buy and Sell conditions:

  • Buy Orders: Utilize PrevbarBuy and TimebarBuy.
  • Sell Orders: Utilize PrevbarSell and TimebarSell.

This separation accounts for scenarios where indicator signals might reverse within the same bar. If both signals share a single time check variable, the EA could miss opportunities to open opposite orders due to the 'New Bar' condition being 'FALSE'.

Conclusion.

By refining the new bar detection logic, we can enhance the reliability of EAs, ensuring they act upon indicator signals accurately and timely. This approach leads to more precise trading actions and potentially better trading outcomes.

This article ends here, hopefully it can help and be useful for fellow traders.

Notes:

This code provides a basic framework for new bar detection in an EA. However, for a robust and reliable trading strategy, it needs further development to incorporate additional factors such as price movements, indicators, and risk management techniques.

Please download the Expert Advisor: TestNewBar

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

YouTube Channel: @ForexHomeExperts

YouTube Playlist: @ForexHomeExperts YouTube Playlist

Sunday, November 24, 2024

In this article I will discuss how to add alerts to indicator programs or Expert Advisors using MQL5.

The alerts that will be discussed include sound and pop-up alerts on MT5 or MT4, notification alerts and email alerts.

But before discussing the creation of the program, we need to know what the benefits of alerts in indicator or expert advisor programs actually are?

the benefits of alerts in indicator or expert advisor programs

What are the benefits of alerts in indicator or expert advisor programs in MT4 or MT5?

Alerts in MT4 and MT5 indicators and expert advisors (EAs) are invaluable tools for traders. They provide timely notifications about specific market conditions, allowing traders to react quickly and make informed decisions.

Here are the key benefits of using alerts:

1.Timely Notifications:

  • Real-time alerts: Receive immediate notifications when a specific condition is met, such as a price crossing a moving average or a support/resistance level being breached.
  • No Constant Monitoring: You don't have to constantly stare at charts to catch these opportunities. Alerts can notify you even when you're away from your computer.

2. Improved Decision-Making:

  • Quick Reaction: Alerts allow you to react promptly to market changes, potentially leading to better entry and exit points.
  • Reduced Emotional Trading: By automating notifications, you can avoid impulsive decisions based on fear or greed.

3. Enhanced Risk Management:

  • Stop-Loss and Take-Profit Alerts: Set up alerts to trigger when your positions reach predefined profit or loss levels.
  • Risk Management Strategies: Automate risk management strategies, such as trailing stop-loss orders, to protect your profits.

4. Increased Efficiency:

  • Automation: Automate repetitive tasks like monitoring indicators and placing orders.
  • Focus on Other Tasks: Spend more time on other aspects of your trading strategy, such as fundamental analysis or portfolio management.

5. Scalping and Day Trading:

  • Quick Entry and Exit: Alerts can help you capitalize on short-term price movements and scalping opportunities.

Remember:

While alerts can be a powerful tool, it's important to use them wisely. Overreliance on alerts can lead to impulsive decisions and potential losses. Always combine alerts with sound risk management practices and thorough analysis.

In this article I will demonstrate the implementation of alerts using the modified MACD indicator by adding alerts.

First of all, I will create a template that is usually used to add alerts to indicators or expert advisors in MQL5.

Template program alerts:


//+------------------------------------------------------------------+
//|                                                  MACD_Alerts.mq5 |
//|                             Copyright 2000-2024, MetaQuotes Ltd. |
//|                                             https://www.mql5.com ||
//|                              https://www.mql5.com/en/users/3rjfx |
//+------------------------------------------------------------------+
#property copyright   "Copyright 2000-2024, MetaQuotes Ltd."
#property link        "https://www.mql5.com"
#property link        "https://www.mql5.com/en/users/3rjfx"
#property description "Moving Average Convergence/Divergence"
#property version     "1.00"
#property description "Modify by: Roberto Jacobs (3rjfx) ~ Date: 2024-11-24"

#property indicator_separate_window
//---


//-- Enumeration
enum YN
 {
   No,  
   Yes
 };
//---
//--- 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)

//---Variables used in alerts
double MACDAlert[];
string AlertTxt;
string _name;
int curAlert;
int prvAlert;
//--
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- indicator buffers mapping
   
   
   //--
   _name="Your Indicator Name";
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int OnCalculate(const int rates_total,
                const int prev_calculated,
                const datetime &time[],
                const double &open[],
                const double &high[],
                const double &low[],
                const double &close[],
                const long &tick_volume[],
                const long &volume[],
                const int &spread[])
  {
//---
   
   
   
   //--
   double priceB=0.0;
   double priceS=0.0;
   datetime dtB=0;
   datetime dtS=0;
   //--
   if(alerts==Yes||UseEmailAlert==Yes||UseSendnotify==Yes)
     {
       if(curAlert==1 && curAlert!=prvAlert)
         {
           AlertTxt="Your Alerts Text here";
           Do_Alerts(AlertTxt,dtB);
           prvAlert=curAlert;
         }
       if(curAlert==-1 && curAlert!=prvAlert)
         {
           AlertTxt="Your Alerts Text here";
           Do_Alerts(AlertTxt,dtS);
           prvAlert=curAlert;
         }
     }
   //--
   
   
//--- return value of prev_calculated for next call
   return(rates_total);
  }
//+------------------------------------------------------------------+

string TF2Str(int period)
  {
   switch(period)
     {
       //--
       case PERIOD_M1:   return("M1");
       case PERIOD_M2:   return("M2");
       case PERIOD_M3:   return("M3");
       case PERIOD_M4:   return("M4");
       case PERIOD_M5:   return("M5");
       case PERIOD_M6:   return("M6");
       case PERIOD_M10:  return("M10");
       case PERIOD_M12:  return("M12");
       case PERIOD_M15:  return("M15");
       case PERIOD_M20:  return("M20");
       case PERIOD_M30:  return("M30");
       case PERIOD_H1:   return("H1");
       case PERIOD_H2:   return("H2");
       case PERIOD_H3:   return("H3");
       case PERIOD_H4:   return("H4");
       case PERIOD_H6:   return("H6");
       case PERIOD_H8:   return("H8");
       case PERIOD_H12:  return("H12");
       case PERIOD_D1:   return("D1");
       case PERIOD_W1:   return("W1");
       case PERIOD_MN1:  return("MN");
       //--
     }
   return(string(period));
  }  
//---------//

void Do_Alerts(string msgText,datetime Altime)
  {
//---
    //--
    Print("--- "+Symbol()+": "+msgText+
          "\n --- at: ",TimeToString(Altime,TIME_DATE|TIME_MINUTES));
    //--
    if(alerts==Yes)
      {
        Alert("--- "+Symbol()+": "+msgText+
              " --- at: ",TimeToString(Altime,TIME_DATE|TIME_MINUTES));
      }
    //--
    if(UseEmailAlert==Yes) 
      SendMail(_name," --- "+Symbol()+" "+TF2Str(Period())+": "+msgText+
                       "\n--- at: "+TimeToString(Altime,TIME_DATE|TIME_MINUTES));
    //--
    if(UseSendnotify==Yes) 
      SendNotification(_name+"--- "+Symbol()+" "+TF2Str(Period())+": "+msgText+
                      "\n --- at: "+TimeToString(Altime,TIME_DATE|TIME_MINUTES));
    //--
    return;
    //--
//---
  } //-end Do_Alerts()
//---------//

Enumeration.

An enum (short for "enumeration") is a distinct type that consists of a set of named values called elements or members. Enums are used to represent a collection of related constants in a more readable and maintainable way.

Enums are particularly useful for representing a series of constants or actions that are related in a fixed manner, and this will make our code more readable and less error-prone.

The YN enum we've defined contains two possible values: No and Yes.

Breakdown:

  • enum YN: This defines a new enumeration type named YN.
  • { No, Yes }: These are the members of the enum, representing two possible states or values: No and Yes.

Then we use that enumeration in the indicator input properties.


//--- 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)

In order not to disturb the MACD buffer calculation, we add a buffer variable named MACDAlert. In this MACDAlert buffer we will copy all values from the MACD buffer.

Then below are some variables that will be used in the alerts that we must place on the global scope of the indicator or expert advisor.

  • string AlertTxt: For the alert text to be created.
  • string _name: Name of the indicator or program that will provide the alert.
  • int curAlert: Current alert value, with a value of 1 for an Up or Buy Alert and minus 1 for a Down or Sell Alert.
  • int prvAlert: This variable is to hold the current alert value, to prevent the alert from repeating without interruption.

Explanation

Variables Initialization:


datetime dtB=0;
datetime dtS=0;
double priceB=0.0;
double priceS=0.0;

These variables store the date and price when a Moving Average Convergence Divergence (MACD) signal occurs. dtB and dtS store the date for the Buy and Sell signals, respectively. priceB and priceS store the prices at those times.

Array Manipulation:


ArraySetAsSeries(time, true);
ArraySetAsSeries(close, true);
ArrayCopy(MACDAlert, ExtMacdBuffer, 0, 0, WHOLE_ARRAY);
ArraySetAsSeries(MACDAlert, true);

These lines set up the arrays for time, closing prices, and MACD values to be used as series (reverse the array indexing). ArrayCopy copies the ExtMacdBuffer into MACDAlert.

Loop to Detect MACD Crossings:


for (int x = calculated - 2; x >= 0; x--)
{
    if (MACDAlert[x+1] <= 0.0 && MACDAlert[x] > 0.0)
    {
        curAlert = 1;
        dtB = time[x];
        priceB = close[x];
    }
    if (MACDAlert[x+1] >= 0.0 && MACDAlert[x] < 0.0)
    {
        curAlert = -1;
        dtS = time[x];
        priceS = close[x];
    }
}

This loop iterates over the MACDAlert array to detect crossings of the MACD line over the zero line.

  • If the MACD value crosses from negative to positive (MACDAlert[x+1] <= 0.0 && MACDAlert[x] > 0.0), a buy signal is generated, and the current time and price are recorded.
  • If the MACD value crosses from positive to negative (MACDAlert[x+1] >= 0.0 && MACDAlert[x] < 0.0), a sell signal is generated, and the current time and price are recorded.

Alerts:


if (alerts == Yes || UseEmailAlert == Yes || UseSendnotify == Yes)
{
    if (curAlert == 1 && curAlert != prvAlert)
    {
        AlertTxt = "MACD cross from below to above zero : " + DoubleToString(priceB, Digits()) + " @ bar shift: " + (string)iBarShift(Symbol(), 0, dtB, false);
        Do_Alerts(AlertTxt, dtB);
        prvAlert = curAlert;
    }
    if (curAlert == -1 && curAlert != prvAlert)
    {
        AlertTxt = "MACD cross from above to below zero : " + DoubleToString(priceS, Digits()) + " @ bar shift: " + (string)iBarShift(Symbol(), 0, dtS, false);
        Do_Alerts(AlertTxt, dtS);
        prvAlert = curAlert;
    }
}

If any alerts are enabled (regular alerts, email alerts, or notifications), the code sends an alert whenever a new MACD crossing signal is detected.

  • If a buy signal is detected (curAlert == 1) and it differs from the previous signal (curAlert != prvAlert), an alert message is constructed and sent.
  • If a sell signal is detected (curAlert == -1) and it differs from the previous signal, a similar alert message is constructed and sent.

Summary:

The code primarily focuses on detecting MACD zero-line crossings and issuing alerts when these crossings occur. This is useful in trading algorithms where MACD crossings can indicate buy or sell signals.


string TF2Str(int period)
  {
   switch(period)
     {
       //--
       case PERIOD_M1:   return("M1");
       case PERIOD_M2:   return("M2");
       case PERIOD_M3:   return("M3");
       case PERIOD_M4:   return("M4");
       case PERIOD_M5:   return("M5");
       case PERIOD_M6:   return("M6");
       case PERIOD_M10:  return("M10");
       case PERIOD_M12:  return("M12");
       case PERIOD_M15:  return("M15");
       case PERIOD_M20:  return("M20");
       case PERIOD_M30:  return("M30");
       case PERIOD_H1:   return("H1");
       case PERIOD_H2:   return("H2");
       case PERIOD_H3:   return("H3");
       case PERIOD_H4:   return("H4");
       case PERIOD_H6:   return("H6");
       case PERIOD_H8:   return("H8");
       case PERIOD_H12:  return("H12");
       case PERIOD_D1:   return("D1");
       case PERIOD_W1:   return("W1");
       case PERIOD_MN1:  return("MN");
       //--
     }
   return(string(period));
  }  
//---------//

This code defines a function TF2Str that converts a time period constant into a string representation. It uses a switch statement to match different period constants and returns the corresponding string.

Explanation:

  • 1. Function Signature: string TF2Str(int period): The function returns a string and takes an int parameter named period.
  • 2. Switch Statement: The switch statement evaluates the period and returns a corresponding string for each case.
  • 3. Case Statements: case PERIOD_M1: return("M1");: If period equals PERIOD_M1, the function returns the string "M1". This pattern is repeated for each predefined period constant, such as PERIOD_M2, PERIOD_M3, etc.
  • Default Case: If the period does not match any of the predefined cases, the function converts the period integer to a string and returns it. This ensures that the function always returns a valid string.

Use Case: This function is useful in scenarios where you need to convert time period constants (used in trading software or financial applications) to their string representations for display or logging purposes.

Function Alerts:

Function Definition:


void Do_Alerts(string msgText,datetime Altime)
  {
//---
    //--
    Print("--- "+Symbol()+": "+msgText+
          "\n --- at: ",TimeToString(Altime,TIME_DATE|TIME_MINUTES));
    //--
    if(alerts==Yes)
      {
        Alert(_name," --- "+Symbol()+": "+msgText+
              " --- at: ",TimeToString(Altime,TIME_DATE|TIME_MINUTES));
      }
    //--
    if(UseEmailAlert==Yes) 
      SendMail(_name," --- "+Symbol()+" "+TF2Str(Period())+": "+msgText+
                       "\n--- at: "+TimeToString(Altime,TIME_DATE|TIME_MINUTES));
    //--
    if(UseSendnotify==Yes) 
      SendNotification(_name+"--- "+Symbol()+" "+TF2Str(Period())+": "+msgText+
                      "\n --- at: "+TimeToString(Altime,TIME_DATE|TIME_MINUTES));
    //--
    return;
    //--
//---
  } //-end Do_Alerts()
//---------//

This function, Do_Alerts, sends different types of alerts (print messages, alerts, emails, notifications) based on MACD signal crosses detected. Here's a detailed breakdown:

  • 1. Print Message: This line prints the alert message along with the time of the alert. The Symbol() function returns the current symbol (currency pair or instrument), and TimeToString converts the datetime to a human-readable string format.
  • 2. Conditional Alerts:
    • Regular Alerts: If alerts are enabled (Yes), it sends an alert message.
    • Email Alerts: If UseEmailAlert is enabled, it sends an email with the alert message. The TF2Str(Period()) function converts the period to a string representation.
    • Push Notifications: If UseSendnotify is enabled, it sends a push notification with the alert message.
  • 3. Return Statement: The function ends here. The return statement ensures the function exits after executing the necessary alert commands.

Summary:

This function is designed to handle various types of alerts based on market conditions or trading signals. It ensures that you are notified through different channels (console print, alert, email, and push notification) whenever an important event occurs in your trading strategy.

The programs and functions in the template that I show above are just examples, they can be applied to both custom indicators and expert advisors with MQL5 and MQL4.

If the function template is applied to MQL4, then you must delete the timeframe periods that do not exist in MQL4, because MQL5 uses 21 timeframes while MQL4 only uses 9 timeframes.

You can adjust and modify the handling according to your needs.

MACD_Alerts indicator test results:

MACD_Alerts indicator test results

That's all for the article How to add Alerts to MT4 and MT5 programs, hopefully it's useful.

Thank you for reading.

Please download the MACD Indicator Alert: MACD Alert

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: MACD_Alerts Indicator.

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

YouTube Channel: @ForexHomeExperts

YouTube Playlist: @ForexHomeExperts YouTube Playlist

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...