| //+------------------------------------------------------------------+
|
| //| SuperTrendSignalAlerts.mq4 |
|
| //| Copyright 2026, Allan Niñal |
|
| //| https://www.allanninal.dev/mql5 |
|
| //+------------------------------------------------------------------+
|
| //| MT4 edition of SuperTrend Signal Alerts: the same calculation as |
|
| //| the MT5 indicator (bands at hl2 -/+ multiplier x ATR that only |
|
| //| ratchet in the direction of the trend; the trend flips when the |
|
| //| close breaks the opposite band; ATR is Wilder's RMA, as ta.atr, |
|
| //| or an SMA of the true range; optional EMA and RSI filters on the |
|
| //| arrows and alerts). |
|
| //| Arrows and alerts come from closed bars only, so a signal never |
|
| //| appears and then disappears. The line moves on the live bar. |
|
| //| MT4 differences: the line is two buffers (blue/red), and the |
|
| //| arrow gap is a fraction of ATR (MT4 has no pixel shift). |
|
| //| Buffers for iCustom match MT5: 0 line, 2 buy, 3 sell. |
|
| //+------------------------------------------------------------------+
|
| // Licence: Mozilla Public License 2.0. This Source Code Form is subject
|
| // to the terms of the MPL, v. 2.0. If a copy of the MPL was not
|
| // distributed with this file, You can obtain one at
|
| // https://mozilla.org/MPL/2.0/
|
| // Origin: the SuperTrend method (ATR bands that only ratchet with the trend) is by
|
| // Olivier Seban; the TradingView "SuperTrend" script is by KivancOzbilgic. This file is
|
| // an independent MQL implementation of that published method.
|
| // SPDX-License-Identifier: MPL-2.0
|
| #property copyright "Copyright 2026, Allan Niñal <https://www.allanninal.dev/mql5>"
|
| #property link "https://www.allanninal.dev/mql5"
|
| #property version "1.1"
|
| #property strict
|
| #property description "SuperTrend line with buy/sell arrows on closed bars, optional EMA and RSI filters."
|
| #property description "Alerts: pop-up, sound, push, e-mail. Non-repainting: signals only on closed bars."
|
| #property indicator_chart_window
|
| #property indicator_buffers 6
|
| #property indicator_color1 clrNONE
|
| #property indicator_color2 clrDodgerBlue
|
| #property indicator_width2 2
|
| #property indicator_color3 clrDodgerBlue
|
| #property indicator_width3 2
|
| #property indicator_color4 clrTomato
|
| #property indicator_width4 2
|
| #property indicator_color5 clrTomato
|
| #property indicator_width5 2
|
| #property indicator_color6 clrGoldenrod
|
|
|
| enum ENUM_ST_ATR
|
| {
|
| ST_ATR_RMA=0, // RMA / Wilder (same as ta.atr)
|
| ST_ATR_SMA=1 // SMA of the true range
|
| };
|
|
|
| input int InpATR = 10; // ATR period
|
| input double InpMult = 3.0; // ATR multiplier
|
| input ENUM_ST_ATR InpMethod = ST_ATR_RMA; // ATR method
|
| input bool InpUseEMA = false; // Only signals with the EMA trend
|
| input int InpEMA = 200; // EMA period
|
| input bool InpShowEMA = true; // Draw the EMA (when the filter is on)
|
| input bool InpUseRSI = false; // Buy only RSI above 50, sell only below
|
| input int InpRSI = 14; // RSI period
|
| input bool InpShowLine = true; // Draw the SuperTrend line
|
| input double InpArrowGap = 0.3; // Arrow distance from the candle (x ATR)
|
|
|
| #include "SignalAlerts.mqh"
|
|
|
| //--- series-indexed (0 = live bar), as every MT4 buffer
|
| double g_line[],g_upl[],g_buy[],g_sell[],g_dnl[],g_ema_draw[];
|
| double g_up[],g_dn[],g_trend[],g_atr[],g_ema[],g_rsi[],g_gain[],g_loss[];
|
| const string PRODUCT="SuperTrend";
|
|
|
| int OnInit()
|
| {
|
| CkDebugStart(PRODUCT,"1.1",InpDebug,StringFormat("ATR %d, multiplier %.2f, method %d, EMA filter %d (%d), RSI filter %d (%d), arrow gap %s, line %d, alerts popup %d sound %d push %d e-mail %d",
|
| InpATR,InpMult,(int)InpMethod,(int)InpUseEMA,InpEMA,(int)InpUseRSI,InpRSI,DoubleToString(InpArrowGap,2),(int)InpShowLine,(int)InpAlertPopup,(int)InpAlertSound,(int)InpAlertPush,(int)InpAlertEmail));
|
| if(InpATR<1 || InpATR>1000 || InpMult<=0 || InpMult>100 || InpEMA<1 || InpEMA>5000 || InpRSI<1 || InpRSI>1000 || InpArrowGap<0)
|
| {
|
| Print("SuperTrend: ATR period 1-1000, multiplier above 0 up to 100, EMA period 1-5000, RSI period 1-1000, arrow distance 0 or more");
|
| CkDbg("init refused: parameters out of range");
|
| return(INIT_PARAMETERS_INCORRECT);
|
| }
|
| IndicatorBuffers(14);
|
| SetIndexBuffer(0,g_line);
|
| SetIndexBuffer(1,g_upl);
|
| SetIndexBuffer(2,g_buy);
|
| SetIndexBuffer(3,g_sell);
|
| SetIndexBuffer(4,g_dnl);
|
| SetIndexBuffer(5,g_ema_draw);
|
| SetIndexBuffer(6,g_up,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(7,g_dn,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(8,g_trend,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(9,g_atr,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(10,g_ema,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(11,g_rsi,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(12,g_gain,INDICATOR_CALCULATIONS);
|
| SetIndexBuffer(13,g_loss,INDICATOR_CALCULATIONS);
|
| SetIndexStyle(0,DRAW_NONE);
|
| SetIndexStyle(1,InpShowLine ? DRAW_LINE : DRAW_NONE);
|
| SetIndexStyle(4,InpShowLine ? DRAW_LINE : DRAW_NONE);
|
| SetIndexStyle(2,DRAW_ARROW);
|
| SetIndexStyle(3,DRAW_ARROW);
|
| SetIndexArrow(2,233);
|
| SetIndexArrow(3,234);
|
| SetIndexStyle(5,(InpUseEMA && InpShowEMA) ? DRAW_LINE : DRAW_NONE,STYLE_DOT);
|
| SetIndexLabel(0,"SuperTrend");
|
| SetIndexLabel(1,NULL);
|
| SetIndexLabel(2,"Buy");
|
| SetIndexLabel(3,"Sell");
|
| SetIndexLabel(4,NULL);
|
| SetIndexLabel(5,InpUseEMA ? "Trend EMA" : NULL);
|
| for(int b=0; b<14; b++)
|
| SetIndexEmptyValue(b,EMPTY_VALUE);
|
| IndicatorShortName(StringFormat("SuperTrend (%d, %.1f)",InpATR,InpMult));
|
| IndicatorDigits(_Digits);
|
| return(INIT_SUCCEEDED);
|
| }
|
|
|
| //--- strict a>b / a<b that ignore floating-point noise: a band can tie a close exactly in real arithmetic
|
| //--- (e.g. 0.00728/14*2+hl2 = 1.10704) and a last-bit difference would otherwise decide the trend flip
|
| bool Above(const double a,const double b) { return(a-b>1e-10*MathAbs(b)); }
|
| bool Below(const double a,const double b) { return(b-a>1e-10*MathAbs(b)); }
|
|
|
| //--- true range of the bar at series index s (n = bars in total; the oldest bar has no previous close)
|
| double TrueRange(const int s,const int n,const double &high[],const double &low[],const double &close[])
|
| {
|
| if(s==n-1)
|
| return(high[s]-low[s]);
|
| return(MathMax(high[s]-low[s],MathMax(MathAbs(high[s]-close[s+1]),MathAbs(low[s]-close[s+1]))));
|
| }
|
|
|
| //--- the two coloured halves of the line at series index s, joined to the bar before when the trend flips
|
| void Segments(const int s,const int n)
|
| {
|
| g_upl[s]=EMPTY_VALUE;
|
| g_dnl[s]=EMPTY_VALUE;
|
| if(g_line[s]==EMPTY_VALUE)
|
| return;
|
| bool up=(g_trend[s]==1.0);
|
| if(up)
|
| g_upl[s]=g_line[s];
|
| else
|
| g_dnl[s]=g_line[s];
|
| if(s+1>=n || g_line[s+1]==EMPTY_VALUE)
|
| return;
|
| //--- the older bar back to its own colour (a join from an earlier tick of this bar may be stale), then the join
|
| bool was_up=(g_trend[s+1]==1.0);
|
| g_upl[s+1]=(was_up ? g_line[s+1] : EMPTY_VALUE);
|
| g_dnl[s+1]=(was_up ? EMPTY_VALUE : g_line[s+1]);
|
| if(was_up!=up)
|
| {
|
| if(up)
|
| g_upl[s+1]=g_line[s+1];
|
| else
|
| g_dnl[s+1]=g_line[s+1];
|
| }
|
| }
|
|
|
| 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[])
|
| {
|
| if(rates_total<2)
|
| return(0);
|
| if(prev_calculated==0)
|
| CkDbg(StringFormat("full calculation, %d bars",rates_total));
|
| ArraySetAsSeries(time,true);
|
| ArraySetAsSeries(open,true);
|
| ArraySetAsSeries(high,true);
|
| ArraySetAsSeries(low,true);
|
| ArraySetAsSeries(close,true);
|
| int n=rates_total;
|
| //--- oldest bar first: i counts from the oldest bar (as in the MT5 code), s is the series index
|
| int first=(prev_calculated>0 ? n-prev_calculated : n-1);
|
| if(first>=n-1)
|
| first=n-1;
|
| for(int s=first; s>=0; s--)
|
| {
|
| int i=n-1-s;
|
| double tr=TrueRange(s,n,high,low,close);
|
| //--- ATR: Wilder's RMA seeded with the SMA of the first InpATR values, or a plain SMA
|
| g_atr[s]=EMPTY_VALUE;
|
| if(i>=InpATR-1)
|
| {
|
| if(InpMethod==ST_ATR_SMA || i==InpATR-1)
|
| {
|
| double sum=0;
|
| for(int k=s; k<s+InpATR; k++)
|
| sum+=TrueRange(k,n,high,low,close);
|
| g_atr[s]=sum/InpATR;
|
| }
|
| else
|
| g_atr[s]=(g_atr[s+1]*(InpATR-1)+tr)/InpATR;
|
| }
|
| //--- EMA of the close, seeded with the SMA of the first InpEMA closes
|
| if(i<InpEMA-1)
|
| g_ema[s]=EMPTY_VALUE;
|
| else
|
| if(i==InpEMA-1)
|
| {
|
| double sum=0;
|
| for(int k=0; k<InpEMA; k++)
|
| sum+=close[n-1-k];
|
| g_ema[s]=sum/InpEMA;
|
| }
|
| else
|
| g_ema[s]=g_ema[s+1]+2.0/(InpEMA+1)*(close[s]-g_ema[s+1]);
|
| g_ema_draw[s]=g_ema[s];
|
| //--- RSI (Wilder): RMA of gains and losses seeded with the SMA of the first InpRSI changes
|
| g_rsi[s]=EMPTY_VALUE;
|
| g_gain[s]=EMPTY_VALUE;
|
| g_loss[s]=EMPTY_VALUE;
|
| if(i>=InpRSI)
|
| {
|
| if(i==InpRSI)
|
| {
|
| double sg=0,sl=0;
|
| for(int k=1; k<=InpRSI; k++)
|
| {
|
| double ch=close[n-1-k]-close[n-k];
|
| sg+=MathMax(ch,0.0);
|
| sl+=MathMax(-ch,0.0);
|
| }
|
| g_gain[s]=sg/InpRSI;
|
| g_loss[s]=sl/InpRSI;
|
| }
|
| else
|
| {
|
| double ch=close[s]-close[s+1];
|
| g_gain[s]=(g_gain[s+1]*(InpRSI-1)+MathMax(ch,0.0))/InpRSI;
|
| g_loss[s]=(g_loss[s+1]*(InpRSI-1)+MathMax(-ch,0.0))/InpRSI;
|
| }
|
| if(g_loss[s]==0.0)
|
| g_rsi[s]=100.0;
|
| else
|
| if(g_gain[s]==0.0)
|
| g_rsi[s]=0.0;
|
| else
|
| g_rsi[s]=100.0-100.0/(1.0+g_gain[s]/g_loss[s]);
|
| }
|
| //--- SuperTrend bands and trend
|
| g_buy[s]=EMPTY_VALUE;
|
| g_sell[s]=EMPTY_VALUE;
|
| if(g_atr[s]==EMPTY_VALUE)
|
| {
|
| g_up[s]=EMPTY_VALUE;
|
| g_dn[s]=EMPTY_VALUE;
|
| g_trend[s]=EMPTY_VALUE;
|
| g_line[s]=EMPTY_VALUE;
|
| Segments(s,n);
|
| continue;
|
| }
|
| double src=(high[s]+low[s])/2.0;
|
| double up=src-InpMult*g_atr[s];
|
| double dn=src+InpMult*g_atr[s];
|
| bool fresh=(i==0 || g_up[s+1]==EMPTY_VALUE);
|
| double up1=(fresh ? up : g_up[s+1]);
|
| double dn1=(fresh ? dn : g_dn[s+1]);
|
| if(i>0 && Above(close[s+1],up1))
|
| up=MathMax(up,up1);
|
| if(i>0 && Below(close[s+1],dn1))
|
| dn=MathMin(dn,dn1);
|
| double trend=(fresh ? 1.0 : g_trend[s+1]);
|
| if(trend==-1.0 && Above(close[s],dn1))
|
| trend=1.0;
|
| else
|
| if(trend==1.0 && Below(close[s],up1))
|
| trend=-1.0;
|
| g_up[s]=up;
|
| g_dn[s]=dn;
|
| g_trend[s]=trend;
|
| g_line[s]=(trend==1.0 ? up : dn);
|
| Segments(s,n);
|
| //--- signals: the trend flips; only on closed bars (s>=1)
|
| if(fresh || s<1)
|
| continue;
|
| bool buy=(trend==1.0 && g_trend[s+1]==-1.0);
|
| bool sell=(trend==-1.0 && g_trend[s+1]==1.0);
|
| if(InpUseEMA)
|
| {
|
| buy=buy && g_ema[s]!=EMPTY_VALUE && close[s]>g_ema[s];
|
| sell=sell && g_ema[s]!=EMPTY_VALUE && close[s]<g_ema[s];
|
| }
|
| if(InpUseRSI)
|
| {
|
| buy=buy && g_rsi[s]!=EMPTY_VALUE && g_rsi[s]>50.0;
|
| sell=sell && g_rsi[s]!=EMPTY_VALUE && g_rsi[s]<50.0;
|
| }
|
| if(buy)
|
| {
|
| g_buy[s]=low[s]-InpArrowGap*g_atr[s];
|
| if(s==1)
|
| SignalAlert(PRODUCT,"BUY, trend up from "+DoubleToString(close[s],_Digits),time[s],prev_calculated>0);
|
| }
|
| if(sell)
|
| {
|
| g_sell[s]=high[s]+InpArrowGap*g_atr[s];
|
| if(s==1)
|
| SignalAlert(PRODUCT,"SELL, trend down from "+DoubleToString(close[s],_Digits),time[s],prev_calculated>0);
|
| }
|
| }
|
| return(rates_total);
|
| }
|
| //+------------------------------------------------------------------+
|
