Skip to content
TheChatArchiveThe Chat Archive
o1-mini-2024-09-12· OpenAIAi2 WildChat-4.8M (AI2)

Can you code advanced custom RSI indicator in mql4

  1. User

    Can you code advanced custom RSI indicator in mql4

  2. Assistant

    Certainly! Creating an advanced custom RSI (Relative Strength Index) indicator in MQL4 allows you to incorporate additional features beyond the standard RSI, such as multiple RSI periods, dynamic levels, alerts, color-coded RSI lines based on conditions, or even integrating with other indicators.

    Below, I'll provide a comprehensive example of an advanced RSI indicator with the following features:

    1. Multiple RSI Periods: Allows the user to input different periods for primary and secondary RSI calculations.
    2. Dynamic Overbought and Oversold Levels: User-adjustable levels instead of the default 70/30.
    3. Color-Coded RSI Lines: Changes color based on bullish or bearish conditions.
    4. Alert Notifications: Alerts when RSI crosses overbought or oversold levels.
    5. Visualization Enhancements: Includes optional moving average smoothing for RSI.

    Step 1: Setting Up the Indicator

    Open the MetaEditor in MetaTrader 4 and create a new custom indicator named AdvancedRSI.

    Step 2: Writing the Code

    //+------------------------------------------------------------------+
    //|                                             AdvancedRSI.mq4      |
    //|                        Custom RSI Indicator with Advanced Features |
    //+------------------------------------------------------------------+
    #property indicator_separate_window
    #property indicator_buffers 4
    #property indicator_color1 Blue    // Primary RSI
    #property indicator_color2 Red     // Secondary RSI
    #property indicator_color3 Green   // Overbought Level
    #property indicator_color4 Orange  // Oversold Level
    #property indicator_width1 2
    #property indicator_width2 2
    #property indicator_style3 STYLE_DASH
    #property indicator_style4 STYLE_DASH
    
    //--- input parameters
    input int     RSIPeriod1       = 14;         // Primary RSI period
    input int     RSIPeriod2       = 7;          // Secondary RSI period
    input double OverboughtLevel  = 70.0;       // Overbought level
    input double OversoldLevel    = 30.0;       // Oversold level
    input bool    UseMAMethod      = true;       // Apply Moving Average smoothing to RSI
    input int     MAMethod         = MODE_SMA;   // MA method for smoothing
    input int     MAPeriod         = 3;          // MA period for smoothing
    input bool    EnableAlerts     = true;       // Enable alert notifications
    
    //--- indicator buffers
    double    RSIBuffer1[];
    double    RSIBuffer2[];
    double    OverboughtBuffer[];
    double    OversoldBuffer[];
    
    //+------------------------------------------------------------------+
    //| Custom indicator initialization function                         |
    //+------------------------------------------------------------------+
    int OnInit()
      {
       // Indicator buffers
       SetIndexBuffer(0, RSIBuffer1);
       SetIndexBuffer(1, RSIBuffer2);
       SetIndexBuffer(2, OverboughtBuffer);
       SetIndexBuffer(3, OversoldBuffer);
       
       // Indicator labels
       IndicatorShortName("Advanced RSI(" + IntegerToString(RSIPeriod1) + ", " + IntegerToString(RSIPeriod2) + ")");
       SetIndexLabel(0, "RSI1");
       SetIndexLabel(1, "RSI2");
       SetIndexLabel(2, "Overbought");
       SetIndexLabel(3, "Oversold");
       
       // Set the style for overbought and oversold levels
       SetIndexStyle(2, DRAW_LINE);
       SetIndexStyle(3, DRAW_LINE);
       
       // Initialize levels
       for(int i=0;i<Bars;i++)
         {
          OverboughtBuffer[i] = OverboughtLevel;
          OversoldBuffer[i] = OversoldLevel;
         }
       
       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[])
      {
       // Ensure enough bars
       int limit = rates_total - prev_calculated;
       if(limit > rates_total - MathMax(RSIPeriod1, RSIPeriod2) - MAPeriod)
          limit = rates_total - MathMax(RSIPeriod1, RSIPeriod2) - MAPeriod;
       
       // Calculate primary RSI
       for(int i = limit-1; i >=0; i--)
         {
          RSIBuffer1[i] = iRSI(NULL, 0, RSIPeriod1, PRICE_CLOSE, i);
          
          // Apply MA smoothing if enabled
          if(UseMAMethod)
            {
             RSIBuffer1[i] = iMAOnArray(RSIBuffer1, 0, MAPeriod, 0, MAMethod, i);
            }
         }
       
       // Calculate secondary RSI
       for(int i = limit-1; i >=0; i--)
         {
          RSIBuffer2[i] = iRSI(NULL, 0, RSIPeriod2, PRICE_CLOSE, i);
          
          // Apply MA smoothing if enabled
          if(UseMAMethod)
            {
             RSIBuffer2[i] = iMAOnArray(RSIBuffer2, 0, MAPeriod, 0, MAMethod, i);
            }
         }
       
       // Initialize alert state (static variables retain their values between function calls)
       static bool overboughtAlerted = false;
       static bool oversoldAlerted = false;
       
       // Loop through bars to generate alerts
       for(int i = limit-1; i >=0; i--)
         {
          // Check for overbought crossing
          if(EnableAlerts)
            {
             if(RSIBuffer1[i] > OverboughtLevel && RSIBuffer1[i+1] <= OverboughtLevel && !overboughtAlerted)
               {
                Alert("RSI1 has crossed above the overbought level at ", TimeToStr(time[i], TIME_DATE|TIME_MINUTES));
                overboughtAlerted = true;
                oversoldAlerted = false;
               }
             // Check for oversold crossing
             if(RSIBuffer1[i] < OversoldLevel && RSIBuffer1[i+1] >= OversoldLevel && !oversoldAlerted)
               {
                Alert("RSI1 has crossed below the oversold level at ", TimeToStr(time[i], TIME_DATE|TIME_MINUTES));
                oversoldAlerted = true;
                overboughtAlerted = false;
               }
            }
          
          // Color change based on RSI direction
          if(RSIBuffer1[i] > RSIBuffer1[i+1])
             SetIndexColor(0, clrGreen);
          else
             SetIndexColor(0, clrRed);
          
          if(RSIBuffer2[i] > RSIBuffer2[i+1])
             SetIndexColor(1, clrBlue);
          else
             SetIndexColor(1, clrOrange);
         }
       
       return(rates_total);
      }
    
    //+------------------------------------------------------------------+
    

    Step 3: Understanding the Code

    Let's break down the key components of the above code:

    1. Indicator Properties:

      • #property indicator_separate_window: Places the RSI indicator in a separate window below the main chart.
      • indicator_buffers 4: Uses four buffers for primary RSI, secondary RSI, overbought, and oversold lines.
      • Colors and styles are set for better visualization.
    2. Input Parameters:

      • RSIPeriod1 and RSIPeriod2: Allow the user to define two different RSI periods for primary and secondary RSI lines.
      • OverboughtLevel and OversoldLevel: User-defined levels to signal potential reversals.
      • UseMAMethod, MAMethod, and MAPeriod: Optional smoothing of the RSI using a Moving Average.
      • EnableAlerts: Toggles alert notifications on RSI level breaches.
    3. Buffers:

      • RSIBuffer1 and RSIBuffer2: Store the RSI values.
      • OverboughtBuffer and OversoldBuffer: Store the levels for visualization.
    4. Initialization (OnInit Function):

      • Assigns buffers and sets up labels.
      • Initializes the overbought and oversold levels across all bars.
    5. Calculation (OnCalculate Function):

      • Ensures there are enough bars to perform calculations.
      • Computes the primary and secondary RSI values. If smoothing is enabled, applies a Moving Average to the RSI.
      • Implements alert logic to notify the user when RSI crosses overbought or oversold levels.
      • Changes the color of RSI lines based on whether RSI is rising or falling.

    Step 4: Adding the Indicator to MetaTrader 4

    1. Compile the Indicator:

      • Save the AdvancedRSI.mq4 file.
      • In MetaEditor, press the Compile button. Ensure there are no errors.
    2. Attach to Chart:

      • Open MetaTrader 4.
      • In the Navigator panel, under Custom Indicators, find AdvancedRSI.
      • Drag and drop it onto a chart or double-click to apply.
    3. Configure Settings:

      • Adjust the input parameters as desired, such as RSI periods, overbought/oversold levels, smoothing options, and alerts.

    Step 5: Extending the Indicator (Optional)

    Depending on your trading strategy, you might want to extend the indicator further. Here are some ideas:

    1. Multi-timeframe Analysis:

      • Incorporate RSI values from higher or lower timeframes to add confluence.
    2. Divergence Detection:

      • Implement logic to detect bullish or bearish divergences between RSI and price.
    3. Additional Alerts:

      • Add notifications for RSI crossovers between the two RSI lines.
    4. Visual Enhancements:

      • Include histogram representations or shading between RSI lines and levels.
    5. Integration with Other Indicators:

      • Combine RSI signals with trend indicators like Moving Averages or MACD for more robust signals.

    Example: Adding Divergence Detection

    Here's how you might implement a simple bullish/bearish divergence detection between RSI and price:

    // Inside OnCalculate, after RSI calculations
    
    // Detect divergence (simplistic example)
    for(int i = limit-1; i >=1; i--)
      {
       // Bullish Divergence: Price makes lower low, RSI makes higher low
       if(low[i] < low[i+1] && RSIBuffer1[i] > RSIBuffer1[i+1])
         {
          // You can draw an arrow or send an alert
          ObjectCreate("BullDiv_"+i, OBJ_ARROW, 0, time[i], low[i]-10*_Point);
          ObjectSetInteger(0, "BullDiv_"+i, OBJPROP_ARROWCODE, SYMBOL_ARROWUP);
          ObjectSetInteger(0, "BullDiv_"+i, OBJPROP_COLOR, clrGreen);
          if(EnableAlerts)
             Alert("Bullish divergence detected at ", TimeToStr(time[i], TIME_DATE|TIME_MINUTES));
         }
       
       // Bearish Divergence: Price makes higher high, RSI makes lower high
       if(high[i] > high[i+1] && RSIBuffer1[i] < RSIBuffer1[i+1])
         {
          // You can draw an arrow or send an alert
          ObjectCreate("BearDiv_"+i, OBJ_ARROW, 0, time[i], high[i]+10*_Point);
          ObjectSetInteger(0, "BearDiv_"+i, OBJPROP_ARROWCODE, SYMBOL_ARROWDOWN);
          ObjectSetInteger(0, "BearDiv_"+i, OBJPROP_COLOR, clrRed);
          if(EnableAlerts)
             Alert("Bearish divergence detected at ", TimeToStr(time[i], TIME_DATE|TIME_MINUTES));
         }
      }
    

    Note: Divergence detection can be complex and may require more sophisticated logic to avoid false signals. The above example is a simplistic approach and should be refined based on testing and specific strategy requirements.

    Conclusion

    The provided AdvancedRSI indicator offers a flexible foundation that you can customize further to fit your trading strategy. By leveraging multiple RSI periods, dynamic levels, color styling, and alert mechanisms, you can enhance your technical analysis capabilities within MetaTrader 4.

    Remember to thoroughly test any custom indicator on a demo account before using it in live trading to ensure it behaves as expected.

    Feel free to ask if you need further customization or have specific requirements!