UniOscillator Indicator For MT5

UniOscillator Indicator For MT5

The UniOscillator Indicator For MT5 is a momentum oscillator that is based on the Relative Strength Index (RSI), with colored oversold and overbought areas. The indicator color scheme may be modified in the input parameters.

Users can select color change either on slope change, or on outer levels cross, or on breach of middle line. There is also the option to choose from 22 different types of applied prices. This level of customization can prove to be helpful for traders who operate in multiple asset classes; with each market requiring an oscillator that is optimized to fittingly adapt to the inherent demand-supply dynamics of that particular market.

FREE UniOscillator Indicator

Download the FREE UniOscillator Indicator for MT5.

To receive my email 100% sure: 
Put my email on your whitelist!

 

Partially Automated Trading Besides Your Day Job

Alerts In Real-Time When Divergences Occur

My Recommended MT4/MT5 Broker

 

Installing the UniOscillator Indicator For MT5

After you downloaded the indicator via the form above you need to unzip the zip-file. Then you need to copy the file Universal_oscillator.mq5 into the folder MQL5\Indicators of your MT5 installation. After that please restart MT5 and then you will be able to see the indicator in the list of indicators.

Parameters of the UniOscillator Indicator For MT5

The UniOscillator Indicator For MT5 has 5 parameters to configure.

input double     BandEdge  = 20;          // Band edge
input enPrices   Price     = pr_close;    // Price to use
input double     LevelUp   =  0.8;        // Upper level
input double     LevelDown = -0.8;        // Lower level
input enColorOn  ColorOn   = cc_onLevels; // Color change :

Buffers of the UniOscillator Indicator For MT5

The UniOscillator Indicator For MT5 provides 9 buffers.

SetIndexBuffer(0,fill1  ,INDICATOR_DATA);
SetIndexBuffer(1,fill2  ,INDICATOR_DATA);
SetIndexBuffer(2,levelup,INDICATOR_DATA);
SetIndexBuffer(3,levelmi,INDICATOR_DATA);
SetIndexBuffer(4,leveldn,INDICATOR_DATA);
SetIndexBuffer(5,unio   ,INDICATOR_DATA);
SetIndexBuffer(6,trend  ,INDICATOR_COLOR_INDEX);
SetIndexBuffer(7,prices ,INDICATOR_CALCULATIONS);
SetIndexBuffer(8,peak   ,INDICATOR_CALCULATIONS);

Main Parts Of The Code

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[])
{
   for (int i=(int)MathMax(prev_calculated-1,0); i lt rates_total; i++)
   {
         prices[i] = getPrice(Price,open,close,high,low,i,rates_total);
            if (i lt 2) { peak[i] = 0; continue; }
            double whiteNoise = (prices[i]-prices[i-2])/2.0;
            double filter     = iSsm(whiteNoise,BandEdge,i,rates_total);
                   peak[i]    = 0.991*peak[i-1];
                   if (MathAbs(filter) gt peak[i]) peak[i] = MathAbs(filter);
                                                unio[i] = filter/peak[i];
         
            levelup[i] = LevelUp;
            levelmi[i] = 0;
            leveldn[i] = LevelDown;
            trend[i]   = 0;
            switch(ColorOn)
            {
               case cc_onLevels:
                  if (unio[i] gt levelup[i]) trend[i] = 1;
                  if (unio[i] lt leveldn[i]) trend[i] = 2;
                  break;
               case cc_onMiddle:                  
                  if (unio[i] gt levelmi[i]) trend[i] = 1;
                  if (unio[i] lt levelmi[i]) trend[i] = 2;
                  break;
               default :
                  if (i gt 0)
                  {
                     if (unio[i] gt unio[i-1]) trend[i] = 1;
                     if (unio[i] lt unio[i-1]) trend[i] = 2;
                  }                  
            }                  
         
         //
         //
         //
         //
         //
         
      fill1[i] = unio[i];
      fill2[i] = unio[i];
      if (unio[i] gt levelup[i]) fill2[i] = levelup[i]; 
      if (unio[i] lt leveldn[i]) fill2[i] = leveldn[i]; 
   }      
   return(rates_total);
}

//-------------------------------------------------------------------
//
//-------------------------------------------------------------------
//
//
//
//
//


#define Pi 3.14159265358979323846264338327950288
double workSsm[][2];
#define _tprice  0
#define _ssm     1

double workSsmCoeffs[][4];
#define _speriod 0
#define _sc1    1
#define _sc2    2
#define _sc3    3

double iSsm(double price, double period, int i, int TotalBars, int instanceNo=0)
{
   if (period lt =1) return(price);
   if (ArrayRange(workSsm,0) !=TotalBars)            ArrayResize(workSsm,TotalBars);
   if (ArrayRange(workSsmCoeffs,0)  lt  (instanceNo+1)) ArrayResize(workSsmCoeffs,instanceNo+1);
   if (workSsmCoeffs[instanceNo][_speriod] != period)
   {
      workSsmCoeffs[instanceNo][_speriod] = period;
      double a1 = MathExp(-1.414*Pi/period);
      double b1 = 2.0*a1*MathCos(1.414*Pi/period);
         workSsmCoeffs[instanceNo][_sc2] = b1;
         workSsmCoeffs[instanceNo][_sc3] = -a1*a1;
         workSsmCoeffs[instanceNo][_sc1] = 1.0 - workSsmCoeffs[instanceNo][_sc2] - workSsmCoeffs[instanceNo][_sc3];
   }

   //
   //
   //
   //
   //

      int s = instanceNo*2; 
      workSsm[i][s+_ssm]    = price;
      workSsm[i][s+_tprice] = price;
      if (i gt 1)
      {  
          workSsm[i][s+_ssm] = workSsmCoeffs[instanceNo][_sc1]*(workSsm[i][s+_tprice]+workSsm[i-1][s+_tprice])/2.0 + 
                               workSsmCoeffs[instanceNo][_sc2]*workSsm[i-1][s+_ssm]                                + 
                               workSsmCoeffs[instanceNo][_sc3]*workSsm[i-2][s+_ssm]; }
   return(workSsm[i][s+_ssm]);
}

//------------------------------------------------------------------
//
//------------------------------------------------------------------
//
//
//
//
//
//

double workHa[][4];
double getPrice(int tprice, const double& open[], const double& close[], const double& high[], const double& low[], int i, int _bars, int instanceNo=0)
{
  if (tprice gt =pr_haclose)
   {
      if (ArrayRange(workHa,0)!= _bars) ArrayResize(workHa,_bars); 
         
         //
         //
         //
         //
         //
         
         double haOpen;
         if (i gt 0)
                haOpen  = (workHa[i-1][instanceNo+2] + workHa[i-1][instanceNo+3])/2.0;
         else   haOpen  = (open[i]+close[i])/2;
         double haClose = (open[i] + high[i] + low[i] + close[i]) / 4.0;
         double haHigh  = MathMax(high[i], MathMax(haOpen,haClose));
         double haLow   = MathMin(low[i] , MathMin(haOpen,haClose));

         if(haOpen   lt haClose) { workHa[i][instanceNo+0] = haLow;  workHa[i][instanceNo+1] = haHigh; } 
         else                 { workHa[i][instanceNo+0] = haHigh; workHa[i][instanceNo+1] = haLow;  } 
                                workHa[i][instanceNo+2] = haOpen;
                                workHa[i][instanceNo+3] = haClose;
         //
         //
         //
         //
         //
         
         switch (tprice)
         {
            case pr_haclose:     return(haClose);
            case pr_haopen:      return(haOpen);
            case pr_hahigh:      return(haHigh);
            case pr_halow:       return(haLow);
            case pr_hamedian:    return((haHigh+haLow)/2.0);
            case pr_hamedianb:   return((haOpen+haClose)/2.0);
            case pr_hatypical:   return((haHigh+haLow+haClose)/3.0);
            case pr_haweighted:  return((haHigh+haLow+haClose+haClose)/4.0);
            case pr_haaverage:   return((haHigh+haLow+haClose+haOpen)/4.0);
            case pr_hatbiased:
               if (haClose gt haOpen)
                     return((haHigh+haClose)/2.0);
               else  return((haLow+haClose)/2.0);        
            case pr_hatbiased2:
               if (haClose gt haOpen)  return(haHigh);
               if (haClose lt haOpen)  return(haLow);
                                    return(haClose);        
         }
   }
   
   //
   //
   //
   //
   //
   
   switch (tprice)
   {
      case pr_close:     return(close[i]);
      case pr_open:      return(open[i]);
      case pr_high:      return(high[i]);
      case pr_low:       return(low[i]);
      case pr_median:    return((high[i]+low[i])/2.0);
      case pr_medianb:   return((open[i]+close[i])/2.0);
      case pr_typical:   return((high[i]+low[i]+close[i])/3.0);
      case pr_weighted:  return((high[i]+low[i]+close[i]+close[i])/4.0);
      case pr_average:   return((high[i]+low[i]+close[i]+open[i])/4.0);
      case pr_tbiased:   
               if (close[i] gt open[i])
                     return((high[i]+close[i])/2.0);
               else  return((low[i]+close[i])/2.0);        
      case pr_tbiased2:   
               if (close[i] gt open[i]) return(high[i]);
               if (close[i] lt open[i]) return(low[i]);
                                     return(close[i]);        
   }
   return(0);
}   

 

About Me

I'm Mike Semlitsch the owner of PerfectTrendSystem.com. My trading career started in 2007. Since 2013 I have helped thousands of traders to take their trading to the next level. Many of them are now constantly profitable traders. 

The following performance was achieved by me while trading live in front of hundreds of my clients:

Connect With Me:  

This FREE Indicator Can Transform
Your Trading!

FREE Indicator + Telegram Group


Request the Ultimate Double Top/Bottom Indicator which is used by 10,000+ traders.

Results From 5 Months!
This service starts soon! Be the first who get's notified when it begins!