Daily FiboPivots
Download scriptThis script is designed to automatically calculate and display Pivot Points, which are specific price levels used by traders to identify potential areas of support and resistance. Instead of requiring the user to calculate these values manually, the tool scans historical data to plot these levels directly onto the trading chart.
Core Functionality
1. Automatic Data Calculation The script looks back at the previous day's price action to determine three key pieces of information: the High, the Low, and the Closing price. Using these three numbers, it calculates a "Pivot" (the central balance point) and then generates several specific sub-levels:
- Resistance Levels (R1, R2, R3): These represent price targets or "ceilings" where the market might face selling pressure.
- Support Levels (S1, S2, S3): These represent price floors where the market might find buying interest.
2. Precise Time Alignment A significant part of this script's logic is dedicated to "Time Correction." Because markets operate across different time zones and various chart types (like 5-minute vs. 1-hour charts), the script includes a specialized search routine. This ensures that it accurately identifies the exact start and end of a trading day, even if there are gaps in the data or if the chart is set to a specific time frame.
3. Visual Mapping and Labels Once the math is complete, the script performs several visual actions:
- Plotting Lines: It draws the various levels (S1-S3, Pivot, R1-R3) as lines on your chart.
- Dynamic Labeling: It places text labels on the far right of the chart so you can immediately see the exact price value for each level (e.g., "Pivot 1.2345").
- Customizable Range: Users can choose how many days of historical data they want to see plotted at once, which helps keep the chart clean and prevents the software from slowing down by trying to calculate years of data simultaneously.
Key Features for the User
- Automatic Updates: The script handles the transition between days, recalculating the levels based on the most recent completed candle data.
- Compatibility: It includes a safety check to ensure it only runs on charts with a timeframe of 1 day or less, preventing errors on larger weekly or monthly views.
- Visual Clarity: By using different colors for Support (Blue/Green) and Resistance (Red/Orange), it provides an instant visual map of where the "battle lines" are drawn for the current trading session.
//+------------------------------------------------------------------+
//| Original Indicator Auto-Pivot Plotter Labels.mq4 Elton Treloar |
//| I called this one Pivot Point S&R + GMT correction |
//| and was made by Linuxser |
//| Thanks to Rosh form metaquotes forum for fix the redraw problem |
//+------------------------------------------------------------------+
#property copyright ""
#property link ""
#define IND_NAME "Pivot Point S&R"
#property indicator_chart_window
#property indicator_buffers 7
#property indicator_color1 LimeGreen
#property indicator_color2 Blue
#property indicator_color3 Red
#property indicator_color4 Blue
#property indicator_color5 Red
#property indicator_color6 Blue
#property indicator_color7 Red
//---- input parameters
extern int StartHour=0;
extern int StartMinute=0;
extern int DaysToPlot=15;
extern color SupportLabelColor=DodgerBlue;
extern color ResistanceLabelColor=OrangeRed;
extern color PivotLabelColor=Green;
extern int fontsize=8;
extern int LabelShift = 0;
//---- buffers
double R3Buffer[];
double R2Buffer[];
double R1Buffer[];
double PBuffer[];
double S1Buffer[];
double S2Buffer[];
double S3Buffer[];
string Pivot="Pivot",Sup1="S 1", Res1="R 1";
string Sup2="S 2", Res2="R 2", Sup3="S 3", Res3="R 3";
datetime LabelShiftTime;
double P,S1,R1,S2,R2,S3,R3;
//+------------------------------------------------------------------+
//| Custom indicator initialization function |
//+------------------------------------------------------------------+
int init()
{
//---- indicators
SetIndexStyle(0,DRAW_LINE,0,2);
SetIndexStyle(1,DRAW_LINE,0,2);
SetIndexStyle(2,DRAW_LINE,0,2);
SetIndexStyle(3,DRAW_LINE,0,2);
SetIndexStyle(4,DRAW_LINE,0,2);
SetIndexStyle(5,DRAW_LINE,0,2);
SetIndexStyle(6,DRAW_LINE,0,2);
SetIndexBuffer(0,PBuffer);
SetIndexBuffer(1,S1Buffer);
SetIndexBuffer(2,R1Buffer);
SetIndexBuffer(3,S2Buffer);
SetIndexBuffer(4,R2Buffer);
SetIndexBuffer(5,S3Buffer);
SetIndexBuffer(6,R3Buffer);
IndicatorShortName(IND_NAME);
//----
return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator deinitialization function |
//+------------------------------------------------------------------+
int deinit()
{
//----
ObjectDelete("Res3");
ObjectDelete("Res2");
ObjectDelete("Res1");
ObjectDelete("Pivot");
ObjectDelete("Sup1");
ObjectDelete("Sup2");
ObjectDelete("Sup3");
//----
return(0);
}
//+------------------------------------------------------------------+
//| Custom indicator iteration function |
//+------------------------------------------------------------------+
int start()
{
int counted_bars=IndicatorCounted();
//---- exit if period is greater than daily charts
if(Period() > 240)
{
Print("Error - Chart period is greater than 1 day.");
return(-1); // then exit
}
//---- indicator calculation
{
if (counted_bars==0)
if(counted_bars<0) return(-1);
//---- last counted bar will be recounted
if(counted_bars>0) counted_bars--;
}
// int limit=Bars-counted_bars;
int limit=2000;
int StartMinutesIntoDay=(StartHour*60)+StartMinute; // 8' o'clock x 60 = 480
int CloseMinutesIntoDay=StartMinutesIntoDay-Period(); //
// ****************************************************
// Check That cloes time isn't now a negative number.
// Correct if it is by adding a full day's worth
// of minutes.
// ****************************************************
if (CloseMinutesIntoDay<0)
{
CloseMinutesIntoDay=CloseMinutesIntoDay+1440;
}
// ****************************************************
// Establish the nuber of bars in a day.
// ****************************************************
int BarsInDay=1440/Period();
// ******************************************************************************************
// ******************************************************************************************
// Main Loop
// ******************************************************************************************
// ******************************************************************************************
for(int i=0; i<limit; i++)
{
// ***************************************************************************
// Only do all this if we are within the plotting range we want.
// i.e. DaysToPlot
// If DaysToPlot is "0" (zero) we plot ALL available data. This can be
// VERY slow with a large history and at small time frames. Expect to
// wait if plotting a year or more on a say a five minute chart. On my PC
// two years of data at Five Minutes takes around 30 seconds per indicator.
// i.e. 30 seconds for main pivot levels indicator then another 30 seconds
// to plot the seperate mid-levels indicator.
// ***************************************************************************
if ( (i<((DaysToPlot+1)*BarsInDay))||DaysToPlot==0) // Used to limit the number of days
{ // that are mapped out. Less waiting ;)
// *****************************************************
// Find previous day's opening and closing bars.
// *****************************************************
int PreviousClosingBar = FindLastTimeMatchFast(CloseMinutesIntoDay,i+1);
int PreviousOpeningBar = FindLastTimeMatchFast(StartMinutesIntoDay,PreviousClosingBar+1);
double PreviousHigh= High[PreviousClosingBar];
double PreviousLow = Low [PreviousClosingBar];
double PreviousClose = Close[PreviousClosingBar];
// *****************************************************
// Find previous day's high and low.
// *****************************************************
for (int SearchHighLow=PreviousClosingBar;SearchHighLow<(PreviousOpeningBar+1);SearchHighLow++)
{
if (High[SearchHighLow]>PreviousHigh) PreviousHigh=High[SearchHighLow];
if (Low[SearchHighLow]<PreviousLow) PreviousLow=Low[SearchHighLow];
}
// ************************************************************************
// Calculate Pivot lines and map into indicator buffers.
// ************************************************************************
{
double R = (PreviousHigh - PreviousLow);
double P = (PreviousHigh+PreviousLow+PreviousClose)/3;
double R3 = P + (R * 1.000);
double R2 = P + (R * 0.618);
double R1 = P + (R * 0.382);
double S1 = P - (R * 0.382);
double S2 = P - (R * 0.618);
double S3 = P - (R * 1.000);
LabelShiftTime = Time[LabelShift];
if (i==0)
{
Print(i);
ObjectCreate("Pivot", OBJ_TEXT, 0, LabelShiftTime, 0);
ObjectSetText("Pivot", " Pivot " +DoubleToStr(P,4),fontsize,"tahoma ",PivotLabelColor);
SetIndexLabel(0, "Pivot Point");
ObjectCreate("Sup1", OBJ_TEXT, 0, LabelShiftTime, 0);
ObjectSetText("Sup1", " S1 " +DoubleToStr(S1,4),fontsize,"tahoma ",SupportLabelColor);
SetIndexLabel(1, "S1");
ObjectCreate("Res1", OBJ_TEXT, 0, LabelShiftTime, 0);
ObjectSetText("Res1", " R1 " +DoubleToStr(R1,4),fontsize,"tahoma ",ResistanceLabelColor);
SetIndexLabel(2, "R1");
ObjectCreate("Sup2", OBJ_TEXT, 0, LabelShiftTime, 0);
ObjectSetText("Sup2", " S2 " +DoubleToStr(S2,4),fontsize,"tahoma ",SupportLabelColor);
SetIndexLabel(3, "S2");
ObjectCreate("Res2", OBJ_TEXT, 0, LabelShiftTime, 0);
ObjectSetText("Res2", " R2 " +DoubleToStr(R2,4),fontsize,"tahoma ",ResistanceLabelColor);
SetIndexLabel(4, "R2");
ObjectCreate("Sup3", OBJ_TEXT, 0, LabelShiftTime, 0);
ObjectSetText("Sup3", " S3 " +DoubleToStr(S3,4),fontsize,"tahoma ",SupportLabelColor);
SetIndexLabel(5, "S3");
ObjectCreate("Res3", OBJ_TEXT, 0, LabelShiftTime, 0);
ObjectSetText("Res3", " R3 " +DoubleToStr(R3,4),fontsize,"tahoma ",ResistanceLabelColor);
SetIndexLabel(6, "R3");
Print("ObjectSet Done");
ObjectMove("Res3", 0, LabelShiftTime,R3);
ObjectMove("Res2", 0, LabelShiftTime,R2);
ObjectMove("Res1", 0, LabelShiftTime,R1);
ObjectMove("Pivot", 0, LabelShiftTime,P);
ObjectMove("Sup1", 0, LabelShiftTime,S1);
ObjectMove("Sup2", 0, LabelShiftTime,S2);
ObjectMove("Sup3", 0, LabelShiftTime,S3);
Print("ObjectMove Done");
ObjectsRedraw();
Print("ObjectsRedraw Done");
}
}
}
R3Buffer[i]=R3;
R2Buffer[i]=R2;
R1Buffer[i]=R1;
PBuffer[i]=P;
S1Buffer[i]=S1;
S2Buffer[i]=S2;
S3Buffer[i]=S3;
}
// Extra1[i]=OpenPriceAt+i;
// **********************************************
// Calculate the mid-levels in to the buffers.
// (for mid-levels version)
// **********************************************(Twe)
// Res1[i] =((R1-P)/2)+P; //M3
// Res2[i] =((R2-R1)/2)+R1; //M4
// Res3[i] =((R3-R2)/2)+R2;
// Supp1[i]=((P-S1)/2)+S1; //M2
// Supp2[i]=((S1-S2)/2)+S2; //M1
// Supp3[i]=((S2-S3)/2)+S3;
//End of 'DaysToPlot 'if' statement.
// ***************************************************************************************
// End of Main Loop
// ***************************************************************************************
// *****************************************
// Return from Start() (Main Routine)
return(0);
}
//+-------------------------------------------------------------------------------------------------------+
// END Custom indicator iteration function
//+-------------------------------------------------------------------------------------------------------+
// *****************************************************************************************
// *****************************************************************************************
// -----------------------------------------------------------------------------------------
// The following routine will use "StartingBar"'s time and use it to find the
// general area that SHOULD contain the bar that matches "TimeToLookFor"
// -----------------------------------------------------------------------------------------
int FindLastTimeMatchFast(int TimeToLookFor,int StartingBar)
{
int StartingBarsTime=(TimeHour(Time[StartingBar])*60)+TimeMinute(Time[StartingBar]);
// ***************************************************
// Check that our search isn't on the otherside of
// the midnight boundary and correct for calculations
// ***************************************************
if (StartingBarsTime<TimeToLookFor)
{
StartingBarsTime=StartingBarsTime+1440;
}
// ***************************************************
// Find out where the bar SHOULD be in time.
// ***************************************************
int HowFarBack=StartingBarsTime-TimeToLookFor;
// ***************************************************
// Translate that into Bars
// ***************************************************
int HowManyBarsBack=HowFarBack/Period();
// ***************************************************
// We've found our starting point
// Calculate it's relative time in minutes.
// ***************************************************
int SuggestedBar=StartingBar+HowManyBarsBack;
int SuggestedBarsTime=(TimeHour(Time[SuggestedBar])*60)+TimeMinute(Time[SuggestedBar]);
// ***************************************************
// If we have what we're after let's just skip the
// crap and return the position of the bar in the
// chart to our main routine
// ***************************************************
if (SuggestedBarsTime==TimeToLookFor)
{
return(SuggestedBar);
}
// ***************************************************
// Else find the difference in time from where we
// were supposed to find the bar.
// ***************************************************
int DeltaTimeFound=TimeToLookFor-SuggestedBarsTime;
int DeltaBarFound=DeltaTimeFound/Period();
// ***************************************************
// I'd be worried if Delta was below zero. Would mean
// that we have EXTRA bars in that day. Unlikely in
// the extreme.
// So I'm only checking for the other case.
// ...now let's search in a narrow range to find that
// bar we are after...
// ***************************************************
if (DeltaTimeFound>0)
{
for (int SearchCount=SuggestedBar ;SearchCount>(SuggestedBar-DeltaBarFound-2) ;SearchCount--)
{
// ******************************************************************************
// Find time (in minutes) of the current bar AND the two bars either side of it.
// This is done to allow for any missing bars in the data. i.e. If THE bar you
// were after were to be missing you'd never get a valid close/open time.
// This is the same reason for searching rather than just looking back a certain
// number of bars from the close time. Missing bars upset the count back and
// screw up all pivot calculations. There is still room for error but it's improved.
// The best calculations will come from having the best data. ...of course. :)
// ******************************************************************************
//
int PreviousBarsTime=(TimeHour(Time[SearchCount+1])*60)+TimeMinute(Time[SearchCount+1]);
int CurrentBarsTime=(TimeHour(Time[SearchCount])*60)+TimeMinute(Time[SearchCount]);
int NextBarsTime=(TimeHour(Time[SearchCount-1])*60)+TimeMinute(Time[SearchCount-1]);
if (CurrentBarsTime==TimeToLookFor)
{
return(SearchCount); // *** If current bar is what we are after than lets get out.
// *** without mucking about with the rest of the checks.
}
// **********************************
// Check that previous bar doesn't
// lay on a different day.
// Adjust if it is
// **********************************
if(PreviousBarsTime>CurrentBarsTime)
{
PreviousBarsTime=PreviousBarsTime-1440;
}
// **********************************
// Check that following bar doesn't
// lay on a different day.
// Adjust if it is.
// **********************************
if(NextBarsTime<CurrentBarsTime)
{
NextBarsTime=NextBarsTime+1440;
}
// ******************************************
// If this is the best we can get
// to the actual bar we are after, then
// exit, returning current bar number.
// *******************************************
if(PreviousBarsTime<TimeToLookFor)
{
if( TimeToLookFor<NextBarsTime)
{
return(SearchCount);
}
}
}
}
return (SuggestedBar);
}
Comments