How to create a FiboPivotCandleBar Expert Advisor that trades Multi-Currency for MT5

This FiboPivotCandleBar Multi-Currency Expert Advisor for MT5 has the same concept and signal strategy as the single-currency FiboPivotCandleBar as I explained in the previous article A Comprehensive Guide to FiboPivotCandleBar: Functions and Performance of the Expert Advisor for MT5 (single-currency)

FiboPivotCandleBar is a sophisticated trading tool designed to provide trading signals by combining several technical indicators, including Fibonacci levels, Pivot Points, ZigZag, MACD, and Moving Averages. Below is a breakdown of the main components and their functions:

Fibonacci Levels:

Function: Identify potential support and resistance levels based on the Fibonacci retracement levels. These levels are derived from the Fibonacci sequence and are used by traders to predict potential reversal points in the market.

Pivot Points:

Function: Calculate key price levels that are expected to act as support or resistance. These levels are computed from the high, low, and close prices of the previous trading period. Pivot Points help traders to anticipate the likely market turning points.

ZigZag Indicator:

Function: Highlight significant price changes, filtering out smaller movements and noise in the market. The ZigZag indicator connects significant tops and bottoms to identify the prevailing trend and potential reversal points.

MACD (Moving Average Convergence Divergence):

Function: Determine the momentum and trend direction by comparing different timeframes of moving averages. MACD consists of two exponential moving averages (EMA) and a histogram that indicates the difference between the MACD line and the signal line. It helps traders identify bullish and bearish market conditions.

Moving Averages:

Function: Smooth out price data to identify the trend direction over a specified period. Moving averages are used to filter out short-term fluctuations and provide a clearer view of the underlying trend.

By integrating these indicators, the FiboPivotCandleBar Multi-Currency EA generates trading signals that guide traders on when to enter and exit trades. The combination of these technical tools allows for a comprehensive analysis of the market, aiming to enhance trading accuracy and profitability.

Therefore, in this article I will not explain each function because you can see the explanation in the article A Comprehensive Guide to FiboPivotCandleBar: Functions and Performance of the Expert Advisor for MT5.

The differences in function and program writing between multi-currency and single-currency can be illustrated in the function example below:

In Multi-Currency Expert Advisor:

void MCEA::CurrentSymbolSet(const string symbol)
  {
//---
   mc_symbol.Name(symbol);
   mc_symbol.CheckMarketWatch();
   mc_symbol.IsSynchronized();
   mc_trade.SetTypeFillingBySymbol(symbol);
   mc_symbol.Refresh();
   mc_symbol.RefreshRates();
   //--
   return;
//---
  } //-end CurrentSymbolSet()
//---------//

In Single-Currency Expert Advisor:

void SFPCB::CurrentSymbolSet(void)
  {
//---
   sc_symbol.Name(SPC);
   sc_symbol.CheckMarketWatch();
   sc_symbol.IsSynchronized();
   sc_trade.SetTypeFillingBySymbol(SPC);
   sc_symbol.Refresh();
   sc_symbol.RefreshRates();
   //--
   return;
//---
  } //-end CurrentSymbolSet()
//---------//

Detailed explanation of the differences between the two functions:

In Multi-Currency Expert Advisor:

void MCEA::CurrentSymbolSet(const string symbol)

This function is designed for a Multi-Currency Expert Advisor. It takes a single parameter, symbol, which is a string representing the symbol of the financial instrument. Here are the steps it follows:

1. Set Symbol Name: It sets the name of the symbol using mc_symbol.Name(symbol)

2. Check Market Watch: It ensures the symbol is in the market watch using mc_symbol.CheckMarketWatch().

3. Synchronization: It checks if the symbol is synchronized with the server using mc_symbol.IsSynchronized().

4. Set Trade Type: It sets the trade type filling by symbol using mc_trade.SetTypeFillingBySymbol(symbol).

5. Refresh Symbol Data:It refreshes the symbol's data using mc_symbol.Refresh().

6. Refresh Rates: It refreshes the rates for the symbol using mc_symbol.RefreshRates().

In Single-Currency Expert Advisor:

void SFPCB::CurrentSymbolSet(void)

This function is designed for a Single-Currency Expert Advisor. It does not take any parameters. Instead, it uses a predefined symbol, SPC. Here are the steps it follows:

1. Set Symbol Name: It sets the name of the symbol using sc_symbol.Name(SPC).

2. Check Market Watch: It ensures the symbol is in the market watch using sc_symbol.CheckMarketWatch().

3. Synchronization: It checks if the symbol is synchronized with the server using sc_symbol.IsSynchronized().

4. Set Trade Type: It sets the trade type filling by symbol using sc_trade.SetTypeFillingBySymbol(SPC).

5. Refresh Symbol Data: It refreshes the symbol's data using sc_symbol.Refresh().

6. Refresh Rates: It refreshes the rates for the symbol using sc_symbol.RefreshRates().

Key Differences

• 1. Parameter Input:
• MCEA::CurrentSymbolSet takes a parameter symbol as input, allowing dynamic setting of symbols.
• SFPCB::CurrentSymbolSet does not take any parameters and uses a predefined symbol SPC.
• 2. Usage Context:
• MCEA::CurrentSymbolSet is used in a Multi-Currency environment where the symbol can change dynamically based on the input parameter.
• SFPCB::CurrentSymbolSet is used in a Single-Currency environment where the symbol is fixed and predefined.
• 3. Flexibility:
• MCEA::CurrentSymbolSet offers more flexibility by allowing different symbols to be set at runtime.
• SFPCB::CurrentSymbolSet is less flexible as it always operates on the same predefined symbol.

By understanding these differences, you can appreciate how each function is tailored to its specific use case within the context of multi-currency versus single-currency trading strategies.

Let's break down the ExpFPCB_MCEA_Config function of FiboPivotCandleBar Expert Advisor for MT5.

void MCEA::ExpFPCB_MCEA_Config(void)

This function configures an Expert Advisor (EA) for multi-currency trading. Below are the step-by-step processes within this function:

//+------------------------------------------------------------------+
//| Expert Configuration                                             |
//+------------------------------------------------------------------+
void MCEA::ExpFPCB_MCEA_Config(void) 
  {
//---
    //--
    HandlingSymbolArrays(); // With this function we will handle all pairs that will be traded
    //--
    TFT05=PERIOD_M5;
    TFT15=PERIOD_M15;
    TFT30=PERIOD_M30;
    TFT60=PERIOD_H1;
    ENUM_TIMEFRAMES TFs[]={PERIOD_M5,PERIOD_M15,PERIOD_M30,PERIOD_H1,PERIOD_H2,PERIOD_H3,PERIOD_H4,PERIOD_H6,PERIOD_H8,PERIOD_H12,PERIOD_D1};
    int arTFs=ArraySize(TFs);
    //--
    for(int x=0; x<arTFs; x++) if(tfinuse==x) TFt=TFs[x]; // TF for calculation signal
    //--
    //-- Indicators handle for all symbol
    for(int x=0; x<arrsymbx; x++) 
      {
        hMATrF[x]=iMA(DIRI[x],TFt,2,0,MODE_LWMA,PRICE_WEIGHTED);
        hMATrS[x]=iMA(DIRI[x],TFt,20,0,MODE_SMA,PRICE_MEDIAN);
        hiMA02[x]=iMA(DIRI[x],TFT15,2,0,MODE_EMA,PRICE_MEDIAN);
        hiMA20[x]=iMA(DIRI[x],TFT15,20,0,MODE_SMA,PRICE_MEDIAN);
        hiMACD[x]=iMACD(DIRI[x],TFT60,12,26,9,PRICE_CLOSE);
        hZZm30[x]=iCustom(DIRI[x],TFT30,indiname,depth,devia,backs);
        hZZm60[x]=iCustom(DIRI[x],TFT60,indiname,depth,devia,backs);
        hPar05[x]=iSAR(DIRI[x],TFT05,SARstep,SARmaxi);       //-- Handle for the iSAR indicator for M5 Timeframe
        //--
      }
    //--
    minprofit=NormalizeDouble(TSmin/100.0,2);
    //--
    ALO=(int)mc_account.LimitOrders()>sall ? sall : (int)mc_account.LimitOrders();
    if(Close_by_Opps==No) 
      {
        if((int)mc_account.LimitOrders()>=(sall*2)) ALO=sall*2;
        else 
        ALO=(int)(mc_account.LimitOrders()/2);
      }
    //--
    LotPS=(double)ALO;
    maxSpread=maxsprd;
    if(MQLInfoInteger(MQL_TESTER))
      maxSpread=(int)SymbolInfoInteger(Symbol(),SYMBOL_SPREAD);
    //--
    mc_trade.SetExpertMagicNumber(magicEA);
    mc_trade.SetDeviationInPoints(slip);
    mc_trade.SetMarginMode();
    Set_Time_Zone();
    //--
    return;
//---
  } //-end ExpFPCB_MCEA_Config()
//---------//

Function Explanation

Detailed Breakdown:

1. Handling Symbol Arrays:

• HandlingSymbolArrays(); This function manages all the pairs that will be traded. This will be explained in more detail in the paragraphs below.

2. Timeframe Setup:

• TFT05=PERIOD_M5;, TFT15=PERIOD_M15;, TFT30=PERIOD_M30;, TFT60=PERIOD_H1; Sets up several timeframe constants for later use.

3. Dynamic Timeframe Selection:

• Creates an array of different timeframes: ENUM_TIMEFRAMES TFs[]=PERIOD_M5,PERIOD_M15,PERIOD_M30,PERIOD_H1,PERIOD_H2,PERIOD_H3,PERIOD_H4,PERIOD_H6,PERIOD_H8,PERIOD_H12,PERIOD_D1};
• Determines the size of the array: int arTFs=ArraySize(TFs);
• Loops through the array to set the calculation timeframe (TFt) based on a condition: for(int x=0; x<arTFs; x++) if(tfinuse==x) TFt=TFs[x];

4. Indicators Handling for All Symbols:

• Iterates through each symbol in arrsymbx to initialize various indicators for each symbol:

      
    //-- Indicators handle for all symbol
      for(int x=0; x<arrsymbx; x++) 
        {
          hMATrF[x]=iMA(DIRI[x],TFt,2,0,MODE_LWMA,PRICE_WEIGHTED);
          hMATrS[x]=iMA(DIRI[x],TFt,20,0,MODE_SMA,PRICE_MEDIAN);
          hiMA02[x]=iMA(DIRI[x],TFT15,2,0,MODE_EMA,PRICE_MEDIAN);
          hiMA20[x]=iMA(DIRI[x],TFT15,20,0,MODE_SMA,PRICE_MEDIAN);
          hiMACD[x]=iMACD(DIRI[x],TFT60,12,26,9,PRICE_CLOSE);
          hZZm30[x]=iCustom(DIRI[x],TFT30,indiname,depth,devia,backs);
          hZZm60[x]=iCustom(DIRI[x],TFT60,indiname,depth,devia,backs);
          hPar05[x]=iSAR(DIRI[x],TFT05,SARstep,SARmaxi);
          //--
        }
      //--
  

5. Profit Calculation:

• Normalizes the minimum profit value: minprofit=NormalizeDouble(TSmin/100.0,2);

6. Account Limit Orders:

• Sets the allowable limit orders (ALO) based on the account's limit and certain conditions:

  
      //--
      ALO=(int)mc_account.LimitOrders()>sall ? sall : (int)mc_account.LimitOrders();
      if(Close_by_Opps==No) 
        {
          if((int)mc_account.LimitOrders()>=(sall*2)) ALO=sall*2;
          else 
          ALO=(int)(mc_account.LimitOrders()/2);
        }
      //--
  

7. Lot and Spread Settings:

• Sets the lot size per symbol: LotPS=(double)ALO;
• Defines the maximum spread allowed:

  
    maxSpread=maxsprd;
      if(MQLInfoInteger(MQL_TESTER))
        maxSpread=(int)SymbolInfoInteger(Symbol(),SYMBOL_SPREAD);
  

8. Trade Settings:

• Sets various trading parameters, such as the magic number, deviation in points, and margin mode:

   
      //--
      mc_trade.SetExpertMagicNumber(magicEA);
      mc_trade.SetDeviationInPoints(slip);
      mc_trade.SetMarginMode();
      Set_Time_Zone();
      //--
  

Summary

The MCEA::ExpFPCB_MCEA_Config function is crucial for configuring a multi-currency Expert Advisor by setting up symbol arrays, timeframes, indicators, and trading parameters. It ensures that all required symbols and their respective indicators are prepared for trading, and it adjusts trading limits and parameters based on current market conditions and account settings.

This section of the function iterates through each symbol in the arrsymbx array to initialize various indicator handles for each symbol. The indicators used include Moving Averages (MA), Moving Average Convergence Divergence (MACD), Custom Indicator (ZZ), and Parabolic SAR (iSAR). Here’s a detailed breakdown:

1. Iteration Through Symbols:

• The loop for(int x=0; x<arrsymbx; x++) iterates over all the symbols in the arrsymbx array.

2. Initializing Indicators:

• Weighted Moving Average (LWMA):
• hMATrF[x]=iMA(DIRI[x],TFt,2,0,MODE_LWMA,PRICE_WEIGHTED);
• Initializes a 2-period LWMA with weighted prices for each symbol.
• Simple Moving Average (SMA):
• hMATrS[x]=iMA(DIRI[x],TFt,20,0,MODE_SMA,PRICE_MEDIAN);
• Initializes a 20-period SMA with median prices for each symbol.
• Exponential Moving Average (EMA):
• hiMA02[x]=iMA(DIRI[x],TFT15,2,0,MODE_EMA,PRICE_MEDIAN);
• Initializes a 2-period EMA with median prices for each symbol in the 15-minute timeframe.
• hiMA20[x]=iMA(DIRI[x],TFT15,20,0,MODE_SMA,PRICE_MEDIAN);
• Initializes a 20-period SMA with median prices for each symbol in the 15-minute timeframe.
• Moving Average Convergence Divergence (MACD):
• hiMACD[x]=iMACD(DIRI[x],TFT60,12,26,9,PRICE_CLOSE);
• Initializes the MACD indicator with standard parameters (12, 26, 9) for the 60-minute timeframe.
• Custom Indicator (ZigZag):
• hZZm30[x]=iCustom(DIRI[x],TFT30,indiname,depth,devia,backs);
• Initializes a custom indicator (e.g., ZigZag) for the 30-minute timeframe with specified parameters.
• hZZm60[x]=iCustom(DIRI[x],TFT60,indiname,depth,devia,backs);
• Initializes the same custom indicator for the 60-minute timeframe with specified parameters.
• Parabolic SAR (iSAR):
• hPar05[x]=iSAR(DIRI[x],TFT05,SARstep,SARmaxi);
• Initializes the Parabolic SAR indicator for the 5-minute timeframe with specified parameters (SARstep and SARmaxi).

Summary

The "Indicators Handling for All Symbols" loop is critical for setting up the necessary technical indicators for each symbol that the Expert Advisor will trade. By initializing these indicators, the function ensures that the EA has the required data to analyze market conditions and make informed trading decisions based on various timeframes and price calculations.

The "Trade on Specific Time" feature allows traders to align their trading activities with specific time zones. This is particularly useful for traders who want to focus on particular trading sessions, such as the London, New York, or Tokyo sessions.

By enabling this feature, the Expert Advisor can be configured to trade only during specific time frames, potentially reducing exposure to market volatility during less active periods.

Provides 2 options:

• Trade on Specific Time = No;
• Trade on Specific Time = Yes;

No Specific Time:

If "Trade on Specific Time Zone" is set to "No," the Expert Advisor will trade 24/5, from 00:15 to 23:59, based on the MT5 server time.

Specific Time Zones:

If "Trade on Specific Time Zone" is set to "Yes," the trader can select from the following options:

Custom Session:

• Traders can specify custom start and end times for the trading session. The EA will only execute trades within this specified time.

Predefined Sessions:

• New Zealand Session: Trades during New Zealand trading hours.
• Australia Sydney Session: Trades during Australian trading hours.
• Asia Tokyo Session: Trades during Asian trading hours.
• Europe London Session: Trades during European trading hours.
• America New York Session: Trades during US trading hours.

Trading Session Duration Calculation:

• For trades initiated during the New Zealand to New York session, the Expert Advisor calculates the duration of the trade, which can be useful for various trading strategies and analysis.

Function: MCEA::GoodMarginTrade function of FiboPivotCandleBar Multi-Currency Expert Advisor for MT5.

The GoodMarginTrade function is designed to check whether an order can be placed based on the available free margin in the trading account. It evaluates if the account has sufficient free margin to open a trade with specified parameters and triggers an alert if the margin is insufficient.

bool MCEA::GoodMarginTrade(const string symbol,ENUM_ORDER_TYPE _cmd,double lotsz,double atprice)
  {
//---
   bool goodmrgn=true;
   //--
   if((mc_account.FreeMarginCheck(symbol,_cmd,lotsz,atprice)<=0.0)||(mc_account.FreeMargin()<(mc_account.Equity()*maxmrgn/100))) goodmrgn=false;
   //--
   if(!goodmrgn)
     {
       string nomargn="Account Free Margin minimum has reached the specified limit, Order will not opened";
       Do_Alerts(symbol,nomargn);
     }
   //--
   return(goodmrgn);
//---
  } //-end GoodMarginTrade()
//---------//

Parameters:

• symbol: A string representing the trading symbol (e.g., "EURUSD").
• _cmd: An enumeration (ENUM_ORDER_TYPE) indicating the type of order (e.g., buy, sell).
• lotsz: A double value representing the lot size of the trade.
• atprice: A double value indicating the price at which the order is to be placed.

Steps:

1. Initialize Margin Status:

• bool goodmrgn=true;
• A boolean variable goodmrgn is initialized to true, assuming the margin status is good by default.

2. Check Free Margin:

if((mc_account.FreeMarginCheck(symbol,_cmd,lotsz,atprice)<=0.0)||(mc_account.FreeMargin()<(mc_account.Equity()*maxmrgn/100))) goodmrgn=false;

• The function checks two conditions to determine if the margin is insufficient:
• a. If the free margin required to open the trade (FreeMarginCheck) is less than or equal to zero.
• b. If the available free margin is less than a specified percentage (maxmrgn) of the account's equity.
• If either condition is met, goodmrgn is set to false.

3. Alert if Margin is Insufficient:

//--
if(!goodmrgn)
  {
    string nomargn="Account Free Margin minimum has reached the specified limit, Order will not opened";
    Do_Alerts(symbol,nomargn);
  }
//--

• If goodmrgn is false (meaning the margin is insufficient), an alert message is created and sent using the Do_Alerts function.

4. Return Margin Status:

return(goodmrgn);

• The function returns the value of goodmrgn, indicating whether the margin is sufficient (true) or insufficient (false).

Summary

The GoodMarginTrade function is essential for ensuring that trades are only placed when there is sufficient free margin in the account. It helps prevent margin calls and potential losses by checking the margin requirements before executing any trade orders. If the margin is insufficient, it alerts the user and prevents the order from being opened.

Function: MCEA::CheckSpread

The CheckSpread function is designed to check whether the spread for a given trading symbol is within an acceptable limit. If the spread exceeds the maximum allowed spread, the function triggers an alert.

Parameters:

• symbol: A string representing the trading symbol (e.g., "EURUSD").

Steps:

1. Initialize Spread Allowance:

• bool allow_spread=false;
• A boolean variable allow_spread is initialized to false, assuming the spread is not allowed by default.

2. Get Symbol Index:

• int x=PairsIdxArray(symbol);
• The function calls PairsIdxArray(symbol) to get the index of the symbol in the pairs array.

3. Set Current Symbol:

• CurrentSymbolSet(symbol);
• Calls CurrentSymbolSet(symbol) to set up the current symbol context for subsequent operations.

4. Calculate Spread:

• spreadx[x]=mc_symbol.NormalizePrice(mc_symbol.Ask()-mc_symbol.Bid());
• Calculates the spread for the symbol by subtracting the bid price from the ask price and normalizing the result.

5. Check Spread Against Maximum Allowed Spread:

• allow_spread=spreadx[x] <= maxSpread*pip;
• Compares the calculated spread (spreadx[x]) with the maximum allowed spread (maxSpread multiplied by pip).
• Sets allow_spread to true if the spread is within the acceptable limit, otherwise false

6. Trigger Alert if Spread is Too High:

    
    //--
    if(!allow_spread)
      {
        string bigspread="Spread in "+symbol+" is greater than maximum spread limit.";
        Do_Alerts(symbol,bigspread);
      }
    //--

• If allow_spread is false (meaning the spread is too high), an alert message is created and sent using the Do_Alerts function.

7. Return Spread Allowance Status:

• return(allow_spread);
• The function returns the value of allow_spread, indicating whether the spread is within the acceptable limit (true) or not (false).

Summary

The CheckSpread function is essential for ensuring that trades are only placed when the spread for a given symbol is within an acceptable limit. By checking the spread before executing any trade orders, the function helps to prevent trades with excessively high costs, thereby safeguarding the trading account. If the spread is too high, it alerts the user and prevents the order from being opened.

1. The Challenge of Multi-Currency Trading.

When dealing with a multi-currency Expert Advisor that trades multiple pairs on a single chart, managing and monitoring individual pair performance can be cumbersome.

The Solution: A Dedicated Button Panel.

A well-designed button panel can significantly enhance the trading experience. By providing quick access to different chart symbols and timeframes, traders can:

• Monitor Individual Pair Performance: Easily switch between charts to assess the accuracy of entry and exit signals.
• React to Market Changes: Quickly identify opportunities and risks in specific pairs.
• Optimize Trading Strategies: Fine-tune strategies based on real-time market data.

Key Features of an Effective Button Panel:

• Symbol Selection: A dropdown menu or a list of buttons to quickly switch between different currency pairs.
• Timeframe Selection: Options to adjust the timeframe for each symbol, allowing for different time-frame analysis.
• Chart Navigation: Buttons to navigate between charts.
• Order Management: A clear overview of open and closed orders, including profit and loss information on that currency.

2. Manual Order Management.

Several manual buttons have been incorporated into this multi-currency expert advisor to enhance efficiency and effectiveness for traders in monitoring the advisor's operations.

• Set SL / TP All Orders
• This button is beneficial if the trader has initially set the parameters to Use Order Stop Loss (No) and/or Use Order Take Profit (No), but later decides to apply Stop Loss or Take Profit to all orders. By clicking the "Set SL / TP All Orders" button, all orders will be adjusted, and a Stop Loss and/or Take Profit will be implemented across the board.
• Close All Orders
• If a trader wants to close all orders, they can simply click on the "Close All Orders" button to close all open orders.
• Close All Orders Profit
• If a trader wishes to close all orders that are currently profitable, they can click on the "Close All Orders Profit" button to close all open orders that have generated profit.

3. Managing Orders and Chart Symbols.

For multi-currency expert advisors that trade 30 pairs using only one chart symbol, having a button panel for all symbols would be highly beneficial and convenient. This feature would allow traders to switch between chart timeframes or symbols with a single click, enabling them to quickly assess the accuracy of the indicator signal when the expert advisor opens or closes an order.

4. Expert Timeframe, Pair Selection, and Symbol Management

Expert Timeframe.

• The Expert Timeframe setting determines the timeframe on which the Expert Advisor will calculate indicators and generate trading signals. By default, it's set to PERIOD_H1, meaning the EA will analyze hourly data.
• Adjusting this setting can influence the sensitivity of the strategy to market movements. A shorter timeframe, like PERIOD_M15 or PERIOD_M30, can lead to more frequent signals, while a longer timeframe, like PERIOD_H4 or PERIOD_D1, can produce fewer, but potentially more reliable signals.

Pair Selection.

• The Select Pairs to Trade property allows traders to choose from a predefined list of currency pairs. The default option is typically to trade all 30 pairs, but traders can customize this selection based on their preferences and risk tolerance.
• Symbol Management with HandlingSymbolArrays The HandlingSymbolArray function plays a crucial role in managing the symbols that the Expert Advisor will trade.
• To perform the following tasks:
• Symbol Initialization: Initializes an array to store the selected symbols.
• Symbol Filtering: Filters the selected symbols based on market conditions or other criteria.
• Symbol Validation: Ensures that the selected symbols are valid and supported by the trading platform.
• Symbol Assignment: Assigns the selected symbols to the Expert Advisor's internal variables.
• By effectively managing symbols, the EA can optimize its performance and reduce the risk of errors.

Validating Pair (Symbol) Names and Error Handling.

• The Expert Advisor's ability to validate pair names is a critical feature to ensure smooth operation and prevent potential errors. Here's a breakdown of how this process might work:
• User Input: The trader enters a list of desired pairs in the Expert Advisor's input parameters.
• Symbol Check: The EA iterates through each pair name and checks its validity:
• Symbol Existence: The EA verifies if the specified symbol exists in the trading platform's symbol
• Symbol Format: The EA ensures that the symbol adheres to the correct format (e.g., EURUSD, GBPUSD, XAUUSD).
• Error Handling:
• If a symbol is invalid, the EA generates a warning message in the journal or displays an alert to the trader and the EA will removed from the chart.
• By incorporating robust symbol validation and error handling, the Expert Advisor can maintain its reliability and prevent unexpected issues.

Function: OnChartEvent

The OnChartEvent function handles various chart events, particularly focusing on click events for specific buttons on the chart. This allows for interactive actions based on user input.

Parameters:

• id: An integer representing the event ID.
• lparam: A long parameter associated with the event.
• dparam: A double parameter associated with the event.
• sparam: A string parameter associated with the event.

Steps:

• 1. Reset Error State:
• ResetLastError();
• Resets any previous error states to start fresh.

• 2. Set Current Timeframe:
• ENUM_TIMEFRAMES CCS=mc.TFt;
• Retrieves the current timeframe setting from the mc object.

• 3. Handle Object Click Events:
• Checks if the event ID is CHARTEVENT_OBJECT_CLICK, indicating a click on a chart object.
• if(id==CHARTEVENT_OBJECT_CLICK) { int lensymbol=StringLen(Symbol()); int lensparam=StringLen(sparam);
• 4. Button Click Handling:
• "Set SL/TP All Orders" Button:
• If this button is clicked, it sets Stop Loss (SL) and Take Profit (TP) for all orders.

//--- if "Set SL All Orders" button is click
if(sparam=="Set SL/TP All Orders") 
  { 
    mc.SetSLTPOrders();
    Alert("-- "+mc.expname+" -- ",Symbol()," -- Set SL/TP All Orders");
    //--- unpress the button 
    ObjectSetInteger(0,"Set SL/TP All Orders",OBJPROP_STATE,false);
    ObjectSetInteger(0,"Set SL/TP All Orders",OBJPROP_ZORDER,0);
    CreateManualPanel();
  }

• "Close All Order" Button:
• If this button is clicked, it closes all open orders.

//--- if "Close All Order" button is click
if(sparam=="Close All Order") 
  { 
    mc.CloseAllOrders();
    Alert("-- "+mc.expname+" -- ",Symbol()," -- Close All Orders");
    //--- unpress the button 
    ObjectSetInteger(0,"Close All Order",OBJPROP_STATE,false);
    ObjectSetInteger(0,"Close All Order",OBJPROP_ZORDER,0);
    CreateManualPanel();
  }

• "Close All Profit" Button:
• If this button is clicked, it closes all profitable orders.

        
//--- if "Close All Profit" button is click
if(sparam=="Close All Profit") 
  { 
    mc.ManualCloseAllProfit();
    Alert("-- "+mc.expname+" -- ",Symbol()," -- Close All Profit");
    //--- unpress the button 
    ObjectSetInteger(0,"Close All Profit",OBJPROP_STATE,false);
    ObjectSetInteger(0,"Close All Profit",OBJPROP_ZORDER,0);
    CreateManualPanel();
  }

• "X" Button:
• If this button is clicked, it deletes all button, label, and rectangle label objects and resets the panel state.

//--- if "X" button is click
if(sparam=="X") 
  { 
    ObjectsDeleteAll(0,0,OBJ_BUTTON);
    ObjectsDeleteAll(0,0,OBJ_LABEL);
    ObjectsDeleteAll(0,0,OBJ_RECTANGLE_LABEL);
    //--- unpress the button 
    ObjectSetInteger(0,"X",OBJPROP_STATE,false);
    ObjectSetInteger(0,"X",OBJPROP_ZORDER,0);
    //--
    DeleteButtonX();
    mc.PanelExtra=false;
    DisplayManualButton();
  }

• "M" Button:
• If this button is clicked, it toggles the manual panel.

//--- if "M" button is click
if(sparam=="M") 
  { 
    //--- unpress the button 
    ObjectSetInteger(0,"M",OBJPROP_STATE,false);
    ObjectSetInteger(0,"M",OBJPROP_ZORDER,0);
    mc.PanelExtra=true;
    CreateManualPanel();
  }     

• "C" Button:
• If this button is clicked, it creates the symbol panel.

   
//--- if "C" button is click
if(sparam=="C") 
  { 
    //--- unpress the button 
    ObjectSetInteger(0,"C",OBJPROP_STATE,false);
    ObjectSetInteger(0,"C",OBJPROP_ZORDER,0);
    mc.PanelExtra=true;
    CreateSymbolPanel();
  }        

• "R" Button:
• If this button is clicked, it removes the Expert Advisor from the chart.

          
//--- if "R" button is click
if(sparam=="R") 
  { 
    Alert("-- "+mc.expname+" -- ",Symbol()," -- expert advisor will be Remove from the chart.");
    ExpertRemove();
    //--- unpress the button 
    ObjectSetInteger(0,"R",OBJPROP_STATE,false);
    ObjectSetInteger(0,"R",OBJPROP_ZORDER,0);
    if(!ChartSetSymbolPeriod(0,Symbol(),Period()))
      ChartSetSymbolPeriod(0,Symbol(),Period());
    DeletePanelButton();
    ChartRedraw(0);
  }

• 5. Symbol Button Click:
• If the length of sparam matches the length of the symbol name, it validates the symbol and changes the chart symbol.

        
//--- if Symbol button is click
if(lensparam==lensymbol)
  {
    int sx=mc.ValidatePairs(sparam);
    ChangeChartSymbol(mc.AS30[sx],CCS);
    mc.PanelExtra=false;
  }

• 6. Return Statement:
• Ensures the function exits cleanly.
• return;

Summary

The OnChartEvent function is crucial for handling user interactions with the chart. By managing clicks on specific buttons, it allows for dynamic actions such as setting SL/TP, closing orders, toggling panels, and changing symbols. This enhances the usability and interactivity of the trading platform.

ChangeChartSymbol Function.

The ChangeChartSymbol function is designed to change the symbol and timeframe of the current chart in the MetaTrader platform. This function also handles resetting and redrawing the chart by unpressing buttons and deleting specific objects.

Parameters:

• c_symbol: A string representing the new trading symbol (e.g., "EURUSD") to be set on the chart.
• cstf: An enumeration (ENUM_TIMEFRAMES) indicating the new timeframe to be set for the chart.

Steps:

• 1. Unpress the Button:
• ObjectSetInteger(0, c_symbol, OBJPROP_STATE, false); ObjectSetInteger(0, c_symbol, OBJPROP_ZORDER, 0);
• Unpresses the button associated with the given symbol by setting its state (OBJPROP_STATE) to false and its Z-order (OBJPROP_ZORDER) to 0.
• 2. Delete Chart Objects:
ObjectsDeleteAll(0, 0, OBJ_BUTTON); ObjectsDeleteAll(0, 0, OBJ_LABEL); ObjectsDeleteAll(0, 0, OBJ_RECTANGLE_LABEL);
• Deletes all objects of type button (OBJ_BUTTON), label (OBJ_LABEL), and rectangle label (OBJ_RECTANGLE_LABEL) from the chart to reset the chart's visual elements.
• 3. Set Chart Symbol and Timeframe:
• ChartSetSymbolPeriod(0, c_symbol, cstf);
• Changes the chart's symbol to c_symbol and sets the timeframe to cstf.
• 4. Redraw the Chart:
• ChartRedraw(0);
• Forces the chart to redraw to reflect the changes made, ensuring the new symbol and timeframe are properly displayed.
• 5. Return Statement:
• return;
• Ensures the function exits cleanly.

Summary

The ChangeChartSymbol function is a crucial utility for dynamically changing the trading symbol and timeframe of a chart in MetaTrader. By unpressing buttons, deleting specific objects, setting the new symbol and timeframe, and redrawing the chart, it ensures a smooth transition and clear presentation of the updated chart.

Thank you for reading this article How to create a FiboPivotCandleBar Expert Advisor that trades Multi-Currency for MT5.

See you in the next article on Expert Advisor programs or indicators for MetaTrader 4 and MetaTrader 5.

Please download the Expert Advisor: ExpFPCB_MCEA

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: ExpFPCB_MCEA.mq5.

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

YouTube Channel: @ForexHomeExperts

YouTube Playlist: @ForexHomeExperts YouTube Playlist

Read more

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

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.

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

Read more