MTF_FXSnipErgoCCI_BarM6

Download script
Author: Copyright � 2006, Eli hayun
MTF_FXSnipErgoCCI_BarM6

Technical Logic Overview

This script is a Multi-Timeframe (MTF) visual tool designed to provide traders with a comprehensive overview of market momentum across four different timeframes simultaneously. Instead of requiring the user to switch back and forth between charts to see the "big picture," this tool aggregates data from multiple periods into a single, easy-to-read indicator window.

Multi-Timeframe Synchronization

The core logic of the script relies on identifying the current chart's timeframe and automatically selecting four corresponding higher timeframes to monitor. For example, if you are viewing a 5-minute chart, the script will automatically pull data for the 15-minute, 30-minute, 60-minute, and 4-hour charts. This ensures that you are always aware of the broader trend relative to your current trading execution.

Trend Detection Engine

The tool utilizes an external calculation (based on "FXSnipers Ergodic" logic) to determine market direction. It analyzes two specific data points—an opening and a closing value—for each of the four timeframes.

  • If the calculated "opening" value is higher than or equal to the "closing" value, the script identifies a downward sentiment.
  • If the "opening" value is lower than the "closing" value, it identifies an upward sentiment.

Visual Representation

The results are displayed in a separate window as a series of colored markers (arrows) grouped into four distinct levels:

  • Layering: Each timeframe is assigned its own horizontal space so the markers do not overlap. This allows you to see if all four timeframes are aligned (e.g., all showing upward momentum) or if there is a conflict between short-term and long-term trends.
  • Color Coding: The script uses specific colors (typically Blue for upward movements and Red/Violet for downward movements) to make it instantly recognizable whether the market is bullish or bearish across various horizons.
  • Dynamic Labeling: To keep the interface organized, the tool automatically generates text labels on the side of the window identifying which row corresponds to which timeframe (e.g., M5, H1, D1, etc.).

Data Smoothing and Continuity

To ensure the visual information remains consistent, the script includes a "Refresh" mechanism. This ensures that if there is a gap in data or a transition between periods, the previous state is maintained until new data confirms a change. This prevents flickering or "empty" spots on your chart, providing a smooth and continuous flow of trend information.

Miscellaneous
Implements a curve of type %1
11 Views
0 Downloads
0 Favorites
MTF_FXSnipErgoCCI_BarM6 
//+------------------------------------------------------------------+
//|MTF NonLagMAv7.1_4TF_BarM  based on    MTF_MegaTrend_Bar_4TFNextM5 | 
//|                 from STEINITZ lee_yan_cn mod N4TF HAS Bar.mq4    |
//|                  Modified by Matsu, from #MTF Supertrend Bar.mq4 |
//| Forex-TSD.com                        Copyright © 2006, Eli hayun |
//|  M                                    http://www.elihayun.com |
//+------------------------------------------------------------------+
#property copyright "Copyright © 2006, Eli hayun"
#property link      "http://www.elihayun.com"

#property indicator_separate_window
#property indicator_minimum 0
#property indicator_maximum 5.5
#property indicator_buffers 8
#property indicator_color1 Red
#property indicator_color2 Blue
#property indicator_color3 Red
#property indicator_color4 Blue
#property indicator_color5 Red
#property indicator_color6 Blue
#property indicator_color7 Red
#property indicator_color8 Blue

//---- parameters
extern int pq =2;
extern int pr = 10;
extern int ps = 5;
extern int trigger =3;
//extern int Length = 9;
//extern int method  = 3;
//extern int Price = 0;
//extern int MaMetod2  = 3;
//extern int MaPeriod2 = 2;
extern int BarWidth = 0;
extern color BarColorUp = RoyalBlue;
extern color BarColorDown = MediumVioletRed;
extern color TextColor = White;
extern int MaxBars=500;

double Gap = 1; // Gap between the lines of bars
//---- buffers
double buf4_up[];
double buf4_down[];
double buf3_up[];
double buf3_down[];
double buf2_up[];
double buf2_down[];
double buf1_up[];
double buf1_down[];
//double haOpen;
//double haClose;
double haOpenN;
double haCloseN;


string shortname = "";


int ArrSize = 110;//110,159;
int UniqueNum = 2282;
int Period_1, Period_2, Period_3, Period_4;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
  
  
   SetIndexStyle(0,DRAW_ARROW,0,BarWidth,BarColorUp);
   SetIndexArrow(0,ArrSize);
   SetIndexBuffer(0,buf1_up);
   SetIndexEmptyValue(0,0.0);
   SetIndexStyle(1,DRAW_ARROW,0,BarWidth,BarColorDown);
   SetIndexArrow(1,ArrSize);
   SetIndexBuffer(1,buf1_down);
   SetIndexEmptyValue(1,0.0);
   SetIndexStyle(2,DRAW_ARROW,0,BarWidth,BarColorUp);
   SetIndexArrow(2,ArrSize);
   SetIndexBuffer(2,buf2_up);
   SetIndexEmptyValue(2,0.0);
   SetIndexStyle(3,DRAW_ARROW,0,BarWidth,BarColorDown);
   SetIndexArrow(3,ArrSize);
   SetIndexBuffer(3,buf2_down);
   SetIndexEmptyValue(3,0.0);
   SetIndexStyle(4,DRAW_ARROW,0,BarWidth,BarColorUp);
   SetIndexArrow(4,ArrSize);
   SetIndexBuffer(4,buf3_up);
   SetIndexEmptyValue(4,0.0);
   SetIndexStyle(5,DRAW_ARROW,0,BarWidth,BarColorDown);
   SetIndexArrow(5,ArrSize);
   SetIndexBuffer(5,buf3_down);
   SetIndexEmptyValue(5,0.0);
   SetIndexStyle(6,DRAW_ARROW,0,BarWidth,BarColorUp);
   SetIndexArrow(6,ArrSize);
   SetIndexBuffer(6,buf4_up);
   SetIndexEmptyValue(6,0.0);
   SetIndexStyle(7,DRAW_ARROW,0,BarWidth,BarColorDown);
   SetIndexArrow(7,ArrSize);
   SetIndexBuffer(7,buf4_down);
   SetIndexEmptyValue(7,0.0);
   
   
   IndicatorDigits(0);
   getPeriod();
   
 //  shortname = "MTF_SnErgCCI("+Period_1+","+Period_2+","+Period_3+","+Period_4+")";
   shortname = "MTF_SnErgCCI";
  
   IndicatorShortName(shortname);
/*   
   SetIndexLabel(0,"NLMA("+Length+")"+Period_1+"");
   SetIndexLabel(1,"NLMA("+Length+")"+Period_1+"");
   SetIndexLabel(2,"NLMA("+Length+")"+Period_2+"");
   SetIndexLabel(3,"NLMA("+Length+")"+Period_2+"");
   SetIndexLabel(4,"NLMA("+Length+")"+Period_3+"");
   SetIndexLabel(5,"NLMA("+Length+")"+Period_3+"");
   SetIndexLabel(6,"NLMA("+Length+")"+Period_4+"");
   SetIndexLabel(7,"NLMA("+Length+")"+Period_4+"");
 */ 
 
   SetIndexLabel(0,"MTF_SnErgCCI("+Period_1+")");
   SetIndexLabel(1,"MTF_SnErgCCI("+Period_1+")");
   SetIndexLabel(2,"MTF_SnErgCCI("+Period_2+")");
   SetIndexLabel(3,"MTF_SnErgCCI("+Period_2+")");
   SetIndexLabel(4,"MTF_SnErgCCI("+Period_3+")");
   SetIndexLabel(5,"MTF_SnErgCCI("+Period_3+")");
   SetIndexLabel(6,"MTF_SnErgCCI("+Period_4+")");
   SetIndexLabel(7,"MTF_SnErgCCI("+Period_4+"");
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int counted_bars=IndicatorCounted();
   //---- check for possible errors
   if(counted_bars<0) return(-1);
   //---- the last counted bar will be recounted
   if(counted_bars>0) counted_bars--;
   int  limit=MathMax(Bars-counted_bars,Period_1/Period());     
        limit=MathMax(            limit,Period_2/Period());   
        limit=MathMax(            limit,Period_3/Period());  
        limit=MathMax(            limit,Period_4/Period());  
   int i,tf;

   //-------------------------------1----------------------------------------   
   double dif = Time[0] - Time[1];
   for ( i=ObjectsTotal()-1; i>-1; i--)
      {
         if (StringFind(ObjectName(i),"FF_"+UniqueNum+"_") >= 0)  ObjectDelete(ObjectName(i));
      }
   double shift = 0.2;
   for ( tf=1; tf<=4; tf++)
      {  
         string txt = "??";
         double gp;
         switch (tf)
         {
             case 1: txt = tf2txt(Period_1);  gp = 1 + Gap*3 + shift; break;
             case 2: txt = tf2txt(Period_2);  gp = 1 + Gap*2 + shift; break;
             case 3: txt = tf2txt(Period_3);  gp = 1 + Gap + shift; break;
             case 4: txt = tf2txt(Period_4);  gp = 1.5 + shift; break;
         }
         string name = "FF_"+UniqueNum+"_"+tf+"_"+txt;
         ObjectCreate(name, OBJ_TEXT, WindowFind(shortname), iTime(NULL,0,0)+dif*3, gp);
         ObjectSetText(name, txt,8,"Arial", TextColor);
      }
   //-------------------------------2----------------------------------------
   datetime TimeArray_1[], TimeArray_2[], TimeArray_3[], TimeArray_4[];
   ArrayCopySeries(TimeArray_1,MODE_TIME,Symbol(),Period_1);
   ArrayCopySeries(TimeArray_2,MODE_TIME,Symbol(),Period_2);
   ArrayCopySeries(TimeArray_3,MODE_TIME,Symbol(),Period_3); 
   ArrayCopySeries(TimeArray_4,MODE_TIME,Symbol(),Period_4);
   
   int  i1=0, i2=0, i3=0, i4=0, yy;

  // for(i=0, i1=0,  i2=0,  i3=0,  i4=0;i<MaxBars;i++)
   for(i=0, i1=0,  i2=0,  i3=0,  i4=0;i<limit;i++)
   {
      if (Time[i]<TimeArray_1[i1]) i1++;
      if (Time[i]<TimeArray_2[i2]) i2++;
      if (Time[i]<TimeArray_3[i3]) i3++;
      if (Time[i]<TimeArray_4[i4]) i4++;

      for ( tf = 1; tf <= 4; tf++)
      {
         int prd;
         switch (tf)
         {
            case 1: prd = Period_1; yy = i1;  break;
            case 2: prd = Period_2; yy = i2;  break;
            case 3: prd = Period_3; yy = i3;   break;
            case 4: prd = Period_4; yy = i4;   break;
         }
      
         haOpenN = iCustom(NULL,prd,"FXSnipersErgodic_CCITrigger",2,10,5,3,1,yy) ;
         haCloseN = iCustom(NULL,prd,"FXSnipersErgodic_CCITrigger",2,10,5,3,0,yy) ;
            
         switch (tf)
         {  case 4: buf4_down[i]=EMPTY_VALUE;buf4_up[i]=EMPTY_VALUE;  if (haOpenN>=haCloseN)  buf4_down[i] = 1;           else buf4_up[i] = 1;           break;
            case 3: buf3_down[i]=EMPTY_VALUE;buf3_up[i]=EMPTY_VALUE; if (haOpenN>=haCloseN)  buf3_down[i] = 1 + Gap * 1; else buf3_up[i] = 1 + Gap * 1; break;
            case 2: buf2_down[i]=EMPTY_VALUE;buf2_up[i]=EMPTY_VALUE; if (haOpenN>=haCloseN)  buf2_down[i] = 1 + Gap * 2; else buf2_up[i] = 1 + Gap * 2; break;
            case 1: buf1_down[i]=EMPTY_VALUE;buf1_up[i]=EMPTY_VALUE; if (haOpenN>=haCloseN)  buf1_down[i] = 1 + Gap * 3; else buf1_up[i] = 1 + Gap * 3; break;
         }
      }
   }

   return(0);
  }
  
//+------------------------------------------------------------------+
void getPeriod()
{
   switch(Period()) 
      {
         case 1: 
            Period_1=1; Period_2=5; Period_3=15; Period_4=30;
            break;
         case 5: 
            Period_1=5; Period_2=15; Period_3=30; Period_4=60;
            break;
         case 15: 
            Period_1=15; Period_2=30; Period_3=60; Period_4=240;
            break;
         case 30: 
            Period_1=30; Period_2=60; Period_3=240; Period_4=1440;
            break;
         case 60: 
            Period_1=60; Period_2=240; Period_3=1440; Period_4=10080;
            break;
         case 240: 
            Period_1=240; Period_2=1440; Period_3=10080; Period_4=43200;
            break;
         case 1440: 
            Period_1=1440; Period_2=10080; Period_3=43200; Period_4=43200;
            break;
         case 10080: 
            Period_1=10080; Period_2=43200; Period_3=43200; Period_4=43200;
            break;
         case 43200: 
            Period_1=43200; Period_2=43200; Period_3=43200; Period_4=43200;
            break;
         
      }
}

string tf2txt(int tf)
{
   if (tf == PERIOD_M1)    return("M1");
   if (tf == PERIOD_M5)    return("M5");
   if (tf == PERIOD_M15)   return("M15");
   if (tf == PERIOD_M30)   return("M30");
   if (tf == PERIOD_H1)    return("H1");
   if (tf == PERIOD_H4)    return("H4");
   if (tf == PERIOD_D1)    return("D1");
   if (tf == PERIOD_W1)    return("W1");
   if (tf == PERIOD_MN1)   return("MN");
  
  //----  Refresh buffers ++++++++++++++++++++ upgrade by Raff  
   int TimeFrame,TimeArray[],i;
   if (TimeFrame>Period()) {
     int PerINT=TimeFrame/Period()+1;
     datetime TimeArr[]; ArrayResize(TimeArr,PerINT);
     ArrayCopySeries(TimeArr,MODE_TIME,Symbol(),Period()); 
     for(i=0;i<PerINT+1;i++) {if (TimeArr[i]>=TimeArray[0]) {
 /********************************************************  
    Refresh buffers:         buffer[i] = buffer[0];
 ********************************************************/  
buf4_up[i]=buf4_up[0];
buf4_down[i]=buf4_down[0];
buf3_up[i]=buf3_up[0];
buf3_down[i]=buf3_down[0];
buf2_up[i]= buf2_up[0];
buf2_down[i]= buf2_down[0];
buf1_up[i]=buf1_up[0];
buf1_down[i]= buf1_down[0];

//----
   } } }
//+++++++++++++++++++++++++++++++++++++++++++++++ Raff  
 
//+-------------
  
   return("??");
}

Dependencies

FXSnipersErgodic_CCITrigger

This indicator calculates momentum dynamics by applying nested exponential moving averages to price changes and their absolute values to generate a crossover signal between an Ergodic CCI and a smoothed trigger line.

Similar scripts

MTF_MegaTrend_Bar_4TFNextM5

This indicator visualizes concurrent bullish or bearish trends across four distinct timeframes simultaneously by mapping high-level MegaTrend data onto a single chart window.

MTF_FXSnipErgoCCI_BarM

This indicator aggregates multi-timeframe price action data from a secondary ergodic trigger to visualize synchronized bullish and bearish sentiment across four distinct temporal horizons simultaneously.

MTF_NonLagMAv7.1_4TF_Bar

This indicator visualizes concurrent trend directions across four synchronized higher timeframes using non-lagging moving average crossovers.

4TF_AO_MovgAMd

4TF_AO_DinvAMr

MTF_MegaTrend_Bar_4TFNextM6

This indicator synchronizes trend directions from four distinct timeframes simultaneously by plotting directional signals based on the underlying MegaTrend price action.

4TF_AC_MovjAMf

MTF_AbsoluteStrength_v1DHs

This indicator synchronizes multi-timeframe momentum dynamics by calculating smoothed bullish and bearish strength vectors to identify trend divergence and non-trade zones.

4TFStochBars

This indicator visualizes the relative momentum of four distinct timeframes simultaneously by plotting directional bars based on the crossover relationship between stochastic main and signal lines.

MTF_AbsoluteStrength_v1DH

This indicator calculates smoothed bullish and bearish momentum strengths across different timeframes using RSI or Stochastic methodologies to identify dominant trend pressure.

MTF_BH_Ergodic_4TFBars

This indicator cross-references nested moving average deviations across four distinct timeframes to identify high-probability trend convergences and divergences.

Comments