NRTR Rosh v2_v1

Download script
Author: Rosh
NRTR Rosh v2_v1

This technical indicator is designed to identify market trends and specific price movements by calculating dynamic support and resistance levels based on market volatility. Instead of using fixed price points, it adapts to the current "mood" of the market to help traders visualize whether price action is trending upwards or downwards.

Core Logic Overview

The script operates by monitoring three primary components: Volatility, Trend Direction, and Dynamic Boundaries.

1. Volatility Measurement The tool uses a volatility calculation method (ATR) to determine how much the market typically moves over a specific period. This ensures that the "boundaries" created by the script are not static; they expand during high-activity periods and contract during quieter markets.

2. Dynamic Support and Resistance (Ceilings and Floors) The script establishes two types of price boundaries:

  • Ceilings: Act as upper limits during an upward trend.
  • Floors: Act as lower limits during a downward trend. These are updated automatically. If the price pushes past a current boundary in a way that suggests a change in momentum, the script "resets" and creates a new baseline for the next movement.

3. Trend Detection and Reversal The logic constantly checks for two types of "breakouts":

  • Trend Continuation: If the price breaks through a ceiling or floor while maintaining the current trend direction, the script refreshes that specific boundary to accommodate the new price level.
  • Trend Reversal: If the price breaks significantly against the current trend (e.g., breaking downward during an uptrend), the script triggers a "Trend Reversal." At this point, it flips the logic: it switches from tracking "Ceilings" to "Floors" and vice versa, effectively alerting the user that the market direction has shifted.

Visual Indicators

The script translates these complex calculations into visual cues on your chart:

  • Arrows: It plots specific arrows to signal when a trend reversal or a significant price break has occurred.
  • Trend Tracking: It maintains an internal state of whether the market is in an "Up" or "Down" state, using this information to decide which boundaries to draw next.

Notifications

For active traders, the script includes an automated alert system. When the logic detects a complete reversal of the trend (switching from bullish to bearish or vice versa), it can be configured to send an email notification. This provides an immediate signal that the market structure has shifted, allowing for quicker reaction times without having to constantly watch the screen.

Indicators Used
Indicator of the average true range
Miscellaneous
Implements a curve of type %1It sends emails
12 Views
0 Downloads
0 Favorites
NRTR Rosh v2_v1
/*-----------------------------+
|			       |
| Shared by www.Aptrafx.com    |
|			       |
+------------------------------*/

//+------------------------------------------------------------------+
//|                                                 NRTR Rosh v2.mq4 |
//|                                                             Rosh |
//|                           http://forexsystems.ru/phpBB/index.php |
//+------------------------------------------------------------------+
#property copyright "Rosh"
#property link      "http://forexsystems.ru/phpBB/index.php"

#property indicator_chart_window
#property indicator_buffers 4
#property indicator_color1 Tomato
#property indicator_color2 DeepSkyBlue
#property indicator_color3 DeepSkyBlue
#property indicator_color4 Tomato
//---- input parameters
extern int       PerATR=40;
extern double    kATR=2.0;
extern bool      useSendMail=true;
//---- buffers
double SellBuffer[];
double BuyBuffer[];
double Ceil[];
double Floor[];
double Trend[];
int sm_Bars;
//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
//---- indicators
   IndicatorBuffers(5);

   SetIndexStyle(0,DRAW_ARROW);
   SetIndexArrow(0,251);
   SetIndexBuffer(0,SellBuffer);
   SetIndexEmptyValue(0,0.0);

   SetIndexStyle(1,DRAW_ARROW);
   SetIndexArrow(1,251);
   SetIndexBuffer(1,BuyBuffer);
   SetIndexEmptyValue(1,0.0);

   SetIndexStyle(2,DRAW_ARROW);
   SetIndexArrow(2,159);
   SetIndexBuffer(2,Ceil);
   SetIndexEmptyValue(2,0.0);

   SetIndexStyle(3,DRAW_ARROW);
   SetIndexArrow(3,159);
   SetIndexBuffer(3,Floor);
   SetIndexEmptyValue(3,0.0);

   SetIndexBuffer(4,Trend);   
   SetIndexEmptyValue(4,0);
   //----
   return(0);
  }
//+------------------------------------------------------------------+
//| ïðîáèòèå âåðõà ÄÀÓÍòðåíäà                              |
//+------------------------------------------------------------------+
bool BreakDown(int shift)
  {
   bool result=false;
   if (Close[shift]>SellBuffer[shift+1]) result=true;
   return(result);
  }

//+------------------------------------------------------------------+
//| ïðîáèòèå äíà ÀÏòðåíäà                              |
//+------------------------------------------------------------------+
bool BreakUp(int shift)
  {
   bool result=false;
   if (Close[shift]<BuyBuffer[shift+1]) result=true;
   return(result);
  }

//+------------------------------------------------------------------+
//| âçÿòèå íîâîãî ìèíèìóìà ïî ÄÀÓÍòðåíäó                             |
//+------------------------------------------------------------------+
bool BreakFloor(int shift)
  {
   bool result=false;
   if (High[shift]<Floor[shift+1]) result=true;
   return(result);
  }

//+------------------------------------------------------------------+
//| âçÿòèå íîâîãî ìàêñèìóìà ïî ÀÏòðåíäó                              |
//+------------------------------------------------------------------+
bool BreakCeil(int shift)
  {
   bool result=false;
   if (Low[shift]>Ceil[shift+1]) result=true;
   return(result);
  }

//+------------------------------------------------------------------+
//| îïðåäåëåíèå ïðåäûäóùåãî òðåíäà                                   |
//+------------------------------------------------------------------+
bool Uptrend(int shift)
  {
   //Print("Trend=",Trend[shift+1]);
   bool result=false;
   if (Trend[shift+1]==1) result=true;
   if (Trend[shift+1]==-1) result=false;
   if ((Trend[shift+1]!=1)&&(Trend[shift+1]!=-1)) Print("Âíèìàíèå! Òðåíä íå îïðåäåëåí, òàêîãî áûòü íå ìîæåò. Áàð îò êîíöà ",(Bars-shift));
   return(result);
  }

//+------------------------------------------------------------------+
//| âû÷èñëåíèå âîëàòèëüíîñòè                                         |
//+------------------------------------------------------------------+
double ATR(int iPer,int shift)
  {
   double result;
   //result=iMA(NULL,0,Per,0,MODE_SMA,PRICE_HIGH,shift+1)-iMA(NULL,0,Per,0,MODE_SMA,PRICE_LOW,shift+1);
   result=iATR(NULL,0,iPer,shift);
   //if (result>1.0) Alert("Áîëüøîé ÀÒÐ=",result);
   //Print("ATR[",shift,"]=",result);
   return(result);
  }
//+------------------------------------------------------------------+
//| óñòàíîâêà íîâîãî óðîâíÿ ïîòîëêà                                  |
//+------------------------------------------------------------------+
void NewCeil(int shift)
  {
   Ceil[shift]=Close[shift];
   Floor[shift]=0.0;
  }

//+------------------------------------------------------------------+
//| óñòàíîâêà íîâîãî óðîâíÿ ïîëà                                     |
//+------------------------------------------------------------------+
void NewFloor(int shift)
  {
   Floor[shift]=Close[shift];
   Ceil[shift]=0.0;
  }

//+------------------------------------------------------------------+
//| óñòàíîâêà óðîâíÿ ïîääåðæêè ÀÏòðåíäà                              |
//+------------------------------------------------------------------+
void SetBuyBuffer(int shift)
  {
   BuyBuffer[shift]=Close[shift]-kATR*ATR(PerATR,shift);
   SellBuffer[shift]=0.0;
  }

//+------------------------------------------------------------------+
//| óñòàíîâêà óðîâíÿ ïîääåðæêè ÄÀÓÍòðåíäà                            |
//+------------------------------------------------------------------+
void SetSellBuffer(int shift)
  {
   SellBuffer[shift]=Close[shift]+kATR*ATR(PerATR,shift);
   BuyBuffer[shift]=0.0;
  }

//+------------------------------------------------------------------+
//| ðåâåðñ òðåíäà è óñòàíîâêà íîâûõ óðîâíåé                          |
//+------------------------------------------------------------------+
void NewTrend(int shift)
  {
   if (Trend[shift+1]==1) 
      {
      Trend[shift]=-1;
      NewFloor(shift);
      SetSellBuffer(shift);
      }
   else 
      {
      Trend[shift]=1;
      NewCeil(shift);
      SetBuyBuffer(shift);
      }
   if ((Trend[shift+1]!=1)&&(Trend[shift+1]!=-1)) Print("Âíèìàíèå! Òðåíä íå îïðåäåëåí, òàêîãî áûòü íå ìîæåò");
  }

//+------------------------------------------------------------------+
//| ïðîäîëæåíèå òðåíäà                                               |
//+------------------------------------------------------------------+
void CopyLastValues(int shift)
  {
   SellBuffer[shift]=SellBuffer[shift+1];
   BuyBuffer[shift]=BuyBuffer[shift+1];
   Ceil[shift]=Ceil[shift+1];
   Floor[shift]=Floor[shift+1];
   Trend[shift]=Trend[shift+1];
  }
//+------------------------------------------------------------------+
//| ïðîäîëæåíèå òðåíäà                                               |
//+------------------------------------------------------------------+
void SendSMS(int shift)
  {
  if (sm_Bars!=Bars)
   sm_Bars=Bars;
   if ((Trend[shift+1]*Trend[shift+2]==-1)&&(shift==0)&&useSendMail) // ñìåíèëñÿ òðåíä
      {
      if (Trend[shift+1]==1)
         {
         SendMail("NRTR",Symbol()+" "+Period()+" ðàçâåðíóëñÿ ââåðõ, Bid="+NormalizeDouble(Bid,Digits));
         }
      else
         {
         SendMail("NRTR",Symbol()+" "+Period()+" ðàçâåðíóëñÿ âíèç, Bid="+Bid);
         }   
      }
   return;
  }


//+------------------------------------------------------------------+
//| Custor indicator deinitialization function                       |
//+------------------------------------------------------------------+
int deinit()
  {
//---- 
   
//----
   return(0);
  }
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   int    counted_bars=IndicatorCounted();
   int limit;
   if (counted_bars>0) limit=Bars-counted_bars;
   if (counted_bars<0) return(0);
   if (counted_bars==0) 
      {
      limit=Bars-PerATR-1;
      if (Close[limit+1]>Open[limit+1]) {Trend[limit+1]=1;Ceil[limit+1]=Close[limit+1];BuyBuffer[limit+1]=Close[limit+1]-kATR*ATR(PerATR,limit+1);}
      if (Close[limit+1]<Open[limit+1]) {Trend[limit+1]=-1;Floor[limit+1]=Close[limit+1];SellBuffer[limit+1]=Close[limit+1]+kATR*ATR(PerATR,limit+1);}
      if (Close[limit+1]==Open[limit+1]) {Trend[limit+1]=1;Ceil[limit+1]=Close[limit+1];BuyBuffer[limit+1]=Close[limit+1]-kATR*ATR(PerATR,limit+1);}
      }
//----
   for (int cnt=limit;cnt>=0;cnt--)
      {
      SendSMS(cnt);
      if (Uptrend(cnt))
         {
         //Print("UpTrend");
         if (BreakCeil(cnt))
            {
            NewCeil(cnt);
            SetBuyBuffer(cnt);
            Trend[cnt]=1;
            continue;
            }
         if (BreakUp(cnt))
            {
            NewTrend(cnt);
            continue;
            }   
         CopyLastValues(cnt);
         }
      else
         {
         //Print("DownTrend");
         if (BreakFloor(cnt))
            {
            NewFloor(cnt);
            SetSellBuffer(cnt);
            Trend[cnt]=-1;
            continue;
            }
         if (BreakDown(cnt))
            {
            NewTrend(cnt);
            continue;
            }   
         CopyLastValues(cnt);
         }
      } 

//----
   return(0);
  }
//+------------------------------------------------------------------+

Comments