Timed_exit_alert_for_webhookLibrary "Timed_exit_alert_for_webhook"
TODO: add library description here
fun(x) TODO: add function description here
Parameters:
x : TODO: add parameter x description here
Returns: TODO: add what function returns
for exiting FCM like Tradovate and AMP using API and python MT5 and Webhooks
the writer take no responsibility for trades made using this script its written for informational purposes only
"alert" için komut dosyalarını ara
MakeLoveNotWarLibrary "MakeLoveNotWar"
Make Love Not War, place a flag of support on your chart!
flag(pos, text_size) Make Love Not War function.
Parameters:
pos : string, position.
text_size : string, text size.
Returns: table.
The Divergent LibraryLibrary "TheDivergentLibrary"
The Divergent Library is only useful when combined with the Pro version of The Divergent - Advanced divergence indicator . This is because the Basic (free) version of The Divergent does not expose the "Divergence Signal" value.
Usage instructions:
1. Create a new chart
2. Add The Divergent (Pro) indicator to your chart
3. Create a new strategy, import this library, add a "source" input, link it to "The Divergent: Divergence Signal", and use the library to decode the divergence signals from The Divergent (You can find example strategy code published in our profile)
4. Act on the divergences signalled by The Divergent
---
isRegularBullishEnabled(context) Returns a boolean value indicating whether Regular Bullish divergence detection is enabled in The Divergent.
Parameters:
context : The context of The Divergent Library.
Returns: A boolean value indicating whether Regular Bullish divergence detection is enabled in The Divergent.
isHiddenBullishEnabled(context) Returns a boolean value indicating whether Hidden Bullish divergence detection is enabled in The Divergent.
Parameters:
context : The context of The Divergent Library.
Returns: A boolean value indicating whether Hidden Bullish divergence detection is enabled in The Divergent.
isRegularBearishEnabled(context) Returns a boolean value indicating whether Regular Bearish divergence detection is enabled in The Divergent.
Parameters:
context : The context of The Divergent Library.
Returns: A boolean value indicating whether Regular Bearish divergence detection is enabled in The Divergent.
isHiddenBearishEnabled(context) Returns a boolean value indicating whether Hidden Bearish divergence detection is enabled in The Divergent.
Parameters:
context : The context of The Divergent Library.
Returns: A boolean value indicating whether Hidden Bearish divergence detection is enabled in The Divergent.
getPivotDetectionSource(context) Returns the 'Pivot Detection Source' setting of The Divergent. The returned value can be either "Oscillator" or "Price".
Parameters:
context : The context of The Divergent Library.
Returns: One of the following string values: "Oscillator" or "Price".
getPivotDetectionMode(context) Returns the 'Pivot Detection Mode' setting of The Divergent. The returned value can be either "Bodies" or "Wicks".
Parameters:
context : The context of The Divergent Library.
Returns: One of the following string values: "Bodies" or "Wicks".
isLinked(context) Returns a boolean value indicating the link status to The Divergent indicator.
Parameters:
context : The context of The Divergent Library.
Returns: A boolean value indicating the link status to The Divergent indicator.
init(firstBarSignal, displayLinkStatus, debug) Initialises The Divergent Library's context with the signal produced by The Divergent on the first bar. The value returned from this function is called the "context of The Divergent Library". Some of the other functions of this library requires you to pass in this context.
Parameters:
firstBarSignal : The signal from The Divergent indicator on the first bar.
displayLinkStatus : A boolean value indicating whether the Link Status window should be displayed in the bottom left corner of the chart. Defaults to true.
debug : A boolean value indicating whether the Link Status window should display debug information. Defaults to false.
Returns: A bool array containing the context of The Divergent Library.
processSignal(signal) Processes a signal from The Divergent and returns a 5-tuple with the decoded signal: [ int divergenceType, int priceBarIndexStart, int priceBarIndexEnd, int oscillatorBarIndexStart, int oscillatorBarIndexEnd]. `divergenceType` can be one of the following values: na → No divergence was detected, 1 → Regular Bullish, 2 → Regular Bullish early, 3 → Hidden Bullish, 4 → Hidden Bullish early, 5 → Regular Bearish, 6 → Regular Bearish early, 7 → Hidden Bearish, 8 → Hidden Bearish early.
Parameters:
signal : The signal from The Divergent indicator.
Returns: A 5-tuple with the following values: [ int divergenceType, int priceBarIndexStart, int priceBarIndexEnd, int oscillatorBarIndexStart, int oscillatorBarIndexEnd].
DiscordWebhookFunctionLibrary "DiscordWebhookFunction"
discordMarkdown(_str, _italic, _bold, _code, _strike, _under) Convert string to markdown formatting User can combine any function at the same time.
Parameters:
_str : String input
_italic : Italic
_bold : Bold
_code : Code markdown
_strike : Strikethrough
_under : Underline
Returns: string Markdown formatted string.
discordWebhookJSON(_username, _avatarImgUrl, _contentText, _bodyTitle, _descText, _bodyUrl, _embedCol, _timestamp, _authorName, _authorUrl, _authorIconUrl, _footerText, _footerIconUrl, _thumbImgUrl, _imageUrl) Convert data to JSON format for Discord Webhook Integration.
Parameters:
_username : Override bot (webhook) username string / name,
_avatarImgUrl : Override bot (webhook) avatar by image URL,
_contentText : Main content page message,
_bodyTitle : Custom Webhook's embed message body title,
_descText : Webhook's embed message body description,
_bodyUrl : Webhook's embed body direct link URL,
_embedCol : Webhook's embed color,
_timestamp : Timestamp,
_authorName : Webhook's embed author name / title,
_authorUrl : Webhook's embed author direct link URL,
_authorIconUrl : Webhook's embed author icon by image URL,
_footerText : Webhook's embed footer text / title,
_footerIconUrl : Webhook's embed footer icon by image URL,
_thumbImgUrl : Webhook's embed thumbnail image URL,
_imageUrl : Webhook's embed body image URL.
Returns: string Single-line JSON format
[ALERTS] MA Cross HildiIch habe nur einige Modifikationen vorgenommen, so dass es meinen Bedürfnissen gerecht wird. Das Skript dient lediglich dazu die gleiche Einstellungen auf mehreren Konten nutzen zu können. Allein die Farbe und die Symbole habe ich noch nicht Automatisiert übertragen.
mfg Hildi Channel
Alert WhiteBox ShiftMAStrategy
The blue line is SMA .
The lime line = SMA - the shift parameter (%).
Red line = SMA + shift parameter (%).
Strategy uses limit orders. For opening of positions and for closing of positions.
If the price is lower than the lime line - opens a long position.
If the price is higher than the red line - opens a short position.
The position is closed on the blue line ( SMA ). Long and short.
Customizable trailing Stop For Manual EntriesHere's how to create a trailing stop with a manual buy order, on an exchange that does not support native trailing stops. Code can easily be copy+pasted into your normal algos.
To set the entry price for your manual trade, specify the bar time when the trade was made. Note that the time you specify needs to correspond to an opening time on your chart--if it's a 3 hour chart, 6 pm or 9 pm will work, but 8 PM will not. It's not as bad as it sounds though, read on :)
Per usual I keep multiple options open.
Special features in this script:
Change time frame for trailing
Specify trailing parameter (high, close, hlc3, etc.)
Change time frame for stop loss trigger (use a shorter time frame for earlier exits!)
Specify trigger parameter (close, low, hlc3, etc.)
Remember that annoying issue where you might not be able to precisely specify entry price, because you want to use 3 hour closing prices for your trailing stop but you bought in at 7:41 pm? Add this indicator to a 1 minute chart and set your start time to 19:41, then set the trailing time frame to 3 hours!
Next stop is v2, where we take profits along the way before stop loss gets triggered.
Best Indicators for Day Trading//@version=5
indicator("Best Indicators for Day Trading", shorttitle="Day Trading Indicators", overlay= true)
//---------------------------- MA's ----------------------------//
priceSource = input.source(close, title='Price Source For The Moving Averages', group='Moving Average')
IgnoreExtendedHours = input.bool(true, title='Ignore Extended Hours', group='Moving Average')
resolution = timeframe.period
price = request.security(syminfo.tickerid, resolution, priceSource)
shortMAPeriod = input.int(8, title='MA 1', group='Moving Average', inline='short')
shortMAType = input.string(defval='EMA', title='', confirm=false, options= , group='Moving Average', inline='short')
longMAPeriod = input.int(21, title='MA 2', group='Moving Average', inline='long')
longMAType = input.string(defval='EMA', title='', confirm=false, options= , group='Moving Average', inline='long')
i_timeframe_signal = input.timeframe(title='Crossover MAs Timeframe', defval='', group='Moving Average')
useTextLabels = input.bool(true, title='Use Text-Based Crossover Labels?', group='Moving Average')
showBonusMA1 = input.bool(true, title='Bonus MA', group='Moving Average', inline='bma1')
bonusMA1Period = input.int(34, title='',group='Moving Average', inline='bma1')
bonus1MAType = input.string(defval='EMA', title='', confirm=false, options= , group='Moving Average', inline='bma1')
i_timeframe_bma1 = input.timeframe(title='', defval='', group='Moving Average', inline='bma1')
ZLMASmooth = 3
f_security(_sym, _res, _src) =>
request.security(_sym, _res, _src , barmerge.gaps_off, lookahead=barmerge.lookahead_off)
ticker = ticker.new(syminfo.prefix, syminfo.ticker, IgnoreExtendedHours ? session.regular : syminfo.session)
// MA calculation
short = shortMAType == 'SMA' ? f_security(ticker, i_timeframe_signal, ta.sma(price, shortMAPeriod)) : shortMAType == 'EMA' ? f_security(ticker, i_timeframe_signal, ta.ema(price, shortMAPeriod)) : shortMAType == 'WMA' ? f_security(ticker, i_timeframe_signal, ta.wma(price, shortMAPeriod)) : shortMAType == 'HMA' ? f_security(ticker, i_timeframe_signal, ta.hma(price, shortMAPeriod)) : shortMAType == 'ALMA' ? f_security(ticker, i_timeframe_signal, ta.alma(price, shortMAPeriod, 0.85, 6)) : shortMAType == 'LIN' ? f_security(ticker, i_timeframe_signal, ta.linreg(price, shortMAPeriod, 0)) : shortMAType == 'ZLMA' ? f_security(ticker, i_timeframe_signal, 2 * ta.wma(ta.wma(price, shortMAPeriod), ZLMASmooth) - ta.wma(ta.wma(ta.wma(price, shortMAPeriod), ZLMASmooth), shortMAPeriod)) : na
long = longMAType == 'SMA' ? f_security(ticker, i_timeframe_signal, ta.sma(price, longMAPeriod)) : longMAType == 'EMA' ? f_security(ticker, i_timeframe_signal, ta.ema(price, longMAPeriod)) : longMAType == 'WMA' ? f_security(ticker, i_timeframe_signal, ta.wma(price, longMAPeriod)) : longMAType == 'HMA' ? f_security(ticker, i_timeframe_signal, ta.hma(price, longMAPeriod)) : longMAType == 'ALMA' ? f_security(ticker, i_timeframe_signal, ta.alma(price, longMAPeriod, 0.85, 6)) : longMAType == 'LIN' ? f_security(ticker, i_timeframe_signal, ta.linreg(price, longMAPeriod, 0)) : longMAType == 'ZLMA' ? f_security(ticker, i_timeframe_signal, 2 * ta.wma(ta.wma(price, longMAPeriod), ZLMASmooth) - ta.wma(ta.wma(ta.wma(price, longMAPeriod), ZLMASmooth), longMAPeriod)) : na
bonus1 = bonus1MAType == 'SMA' ? f_security(ticker, i_timeframe_bma1, ta.sma(price, bonusMA1Period)) : bonus1MAType == 'EMA' ? f_security(ticker, i_timeframe_bma1, ta.ema(price, bonusMA1Period)) : bonus1MAType == 'WMA' ? f_security(ticker, i_timeframe_bma1, ta.wma(price, bonusMA1Period)) : bonus1MAType == 'HMA' ? f_security(ticker, i_timeframe_bma1, ta.hma(price, bonusMA1Period)) : bonus1MAType == 'ALMA' ? f_security(ticker, i_timeframe_bma1, ta.alma(price, bonusMA1Period, 0.85, 6)) : bonus1MAType == 'LIN' ? f_security(ticker, i_timeframe_bma1, ta.linreg(price, bonusMA1Period, 0)) : bonus1MAType == 'ZLMA' ? f_security(ticker, i_timeframe_bma1, 2 * ta.wma(ta.wma(price, bonusMA1Period), ZLMASmooth) - ta.wma(ta.wma(ta.wma(price, bonusMA1Period), ZLMASmooth), bonusMA1Period)) : na
// trend direction/color
TrendingUp() =>
short > long
TrendingDown() =>
short < long
Uptrend() =>
TrendingUp() and TrendingDown()
Downtrend() =>
TrendingDown() and TrendingUp()
trendColor = TrendingUp() ? color.new(color.green, 85) : TrendingDown() ? color.new(color.red, 85) : color.new(color.blue, 85)
MA1 = plot(short, title='Short Period Moving Average', color=color.fuchsia, linewidth=2, style=plot.style_line)
MA2 = plot(long, title='Long Period Moving Average', color=color.navy, linewidth=1, style=plot.style_line)
fill(MA1, MA2, color=trendColor, title='Short/Long Divergence Fill')
plot(showBonusMA1 ? bonus1 : na, title='MA 3', color=color.white, linewidth=1, style=plot.style_line)
// Short & Long Moving Averages cross alert
MAcrossing = ta.cross(short, long) ? short : na
plot(MAcrossing , title='Calls/Puts Crossing Icon', style=plot.style_cross, linewidth=3, color=trendColor)
// Bull and Bear Alerts
Bull = ta.crossover(short, long)
Bear = ta.crossunder(short, long)
plotshape(Bull, title='Calls Label', color=color.new(color.green, 25), textcolor=useTextLabels ? color.white : color.new(color.white, 100), style=useTextLabels ? shape.labelup : shape.triangleup, text='Calls', location=location.belowbar)
plotshape(Bear, title='Puts Label', color=color.new(color.red, 25), textcolor=useTextLabels ? color.white : color.new(color.white, 100), style=useTextLabels ? shape.labeldown : shape.triangledown, text='Puts', location=location.abovebar)
if Bull
alert('Calls Alert: 8ema crossed over 21ema', alert.freq_once_per_bar_close)
if Bear
alert('Puts Alert: 8ema crossed under 21ema', alert.freq_once_per_bar_close)
//---------------------------- VWAP ----------------------------//
vwapprice = input(defval=hlc3, title="VWAP Source", group='VWAP')
enable_vwap = input(true, title="Enable VWAP", group='VWAP')
vwapResolution = input.timeframe(title = "VWAP Resolution", defval = "", group='VWAP')
vwapFunction = ta.vwap(vwapprice)
vwapSecurity = request.security(syminfo.tickerid, vwapResolution, vwapFunction)
plot(enable_vwap ? vwapSecurity : na, title="VWAP", color=color.yellow, linewidth=2, editable=true)
//---------------------------- FVG ----------------------------//
showFractals = input(false,title="Show Fractals?", group="Fair Value Gap")
showBrekout = input(false,title="Show Market Structure Breakouts?", group="Fair Value Gap")
breakType = input.string("Body",title="Fractal Break Type:",options= , group="Fair Value Gap")
n = input.int(title="Periods", defval=2, minval=2, group="Fair Value Gap")
showImbalance = input(true,title="Show Breakout Imbalances", group="Fair Value Gap")
showOtherImbalance = input(true,title="Show Other Imbalances", group="Fair Value Gap")
imbGreenClr = input.color(color.new(color.green,65),title="Up:",inline="i_1", group="Fair Value Gap")
imbRedClr = input.color(color.new(color.red,65),title="Down:",inline="i_1", group="Fair Value Gap")
imbRestClr = input.color(color.new(color.yellow,65), title="Other:",inline="i_1", group="Fair Value Gap")
showBoxes = input(false,title="Show OrderBlocks?", group="Fair Value Gap")
changeColor = input(false,title="Change OrderBlock Colors?", group="Fair Value Gap")
transGreenClr = input.color(color.new(color.green,80),title="Bg:",inline="a_1", group="Fair Value Gap")
greenClr = input.color(color.new(color.green,0),title="Border:",inline="a_1", group="Fair Value Gap")
transRedClr = input.color(color.new(color.red,80),title="Bg:",inline="b_1", group="Fair Value Gap")
redClr = input.color(color.new(color.red,0),title="Border:",inline="b_1", group="Fair Value Gap")
//Fractals{
// UpFractal
bool upflagDownFrontier = true
bool upflagUpFrontier0 = true
bool upflagUpFrontier1 = true
bool upflagUpFrontier2 = true
bool upflagUpFrontier3 = true
bool upflagUpFrontier4 = true
for i = 1 to n
upflagDownFrontier := upflagDownFrontier and (high < high )
upflagUpFrontier0 := upflagUpFrontier0 and (high < high )
upflagUpFrontier1 := upflagUpFrontier1 and (high <= high and high < high )
upflagUpFrontier2 := upflagUpFrontier2 and (high <= high and high <= high and high < high )
upflagUpFrontier3 := upflagUpFrontier3 and (high <= high and high <= high and high <= high and high < high )
upflagUpFrontier4 := upflagUpFrontier4 and (high <= high and high <= high and high <= high and high <= high and high < high )
flagUpFrontier = upflagUpFrontier0 or upflagUpFrontier1 or upflagUpFrontier2 or upflagUpFrontier3 or upflagUpFrontier4
upFractal = (upflagDownFrontier and flagUpFrontier)
//DownFractal
bool downflagDownFrontier = true
bool downflagUpFrontier0 = true
bool downflagUpFrontier1 = true
bool downflagUpFrontier2 = true
bool downflagUpFrontier3 = true
bool downflagUpFrontier4 = true
for i = 1 to n
downflagDownFrontier := downflagDownFrontier and (low > low )
downflagUpFrontier0 := downflagUpFrontier0 and (low > low )
downflagUpFrontier1 := downflagUpFrontier1 and (low >= low and low > low )
downflagUpFrontier2 := downflagUpFrontier2 and (low >= low and low >= low and low > low )
downflagUpFrontier3 := downflagUpFrontier3 and (low >= low and low >= low and low >= low and low > low )
downflagUpFrontier4 := downflagUpFrontier4 and (low >= low and low >= low and low >= low and low >= low and low > low )
flagDownFrontier = downflagUpFrontier0 or downflagUpFrontier1 or downflagUpFrontier2 or downflagUpFrontier3 or downflagUpFrontier4
downFractal = (downflagDownFrontier and flagDownFrontier)
//}
var float topValue = na, var float bottomValue = na
var int lastRedIndex = na, var float lastRedLow = na, var float lastRedHigh = na
var int lastGreenIndex = na, var float lastGreenLow = na, var float lastGreenHigh = na
var line topLine = na, var line bottomLine = na
var box demandBox = na, var box supplyBox = na
var box imbalanceBox = na
var bool checkUpImbalance = false
var bool checkDownImbalance = false
var topBreakBlock = false, var bottomBreakBlock = false
var isLongBreak = false, var isShortBreak = false
var arrBoxes = array.new_box(0)
topBreakCheckSource = breakType == "Wick+Body" ? high : close
bottomBreakCheckSource = breakType == "Wick+Body" ? low : close
//IMBALANCE
//Data
L1 = low
H3 = high
H1 = high
L3 = low
FVGUp = H3 < L1 ? 1 : 0
plotFVGU = FVGUp ? H3 : na
plotFVGUL = FVGUp ? L1 : na
FVGDown = L3 > H1 ? 1 : 0
plotFVGD = FVGDown ? L3 : na
plotFVGH = FVGDown ? H1 : na
if FVGUp and showOtherImbalance and checkUpImbalance == false
imbalanceBox := box.new(bar_index-2, plotFVGU,bar_index,plotFVGUL, bgcolor=imbRestClr, border_color=imbRestClr)
if FVGDown and showOtherImbalance and checkDownImbalance == false
imbalanceBox := box.new(bar_index-2, plotFVGH,bar_index,plotFVGD, bgcolor=imbRestClr, border_color=imbRestClr)
//Last red check
if close < open
lastRedIndex := bar_index
lastRedLow := low
lastRedHigh := high
//Last green check
if close > open
lastGreenIndex := bar_index
lastGreenLow := low
lastGreenHigh := high
//Check Imbalance
if checkUpImbalance
checkUpImbalance := false
imbTop = low
imbBottom = high
if imbTop > imbBottom and showImbalance
imbalanceBox := box.new(bar_index-2, imbTop,bar_index,imbBottom, bgcolor=imbGreenClr, border_color=imbGreenClr)
if checkDownImbalance
checkDownImbalance := false
imbTop = low
imbBottom = high
if imbTop > imbBottom and showImbalance
imbalanceBox := box.new(bar_index-2, imbTop,bar_index,imbBottom, bgcolor=imbRedClr, border_color=imbRedClr)
//Top break
if ta.crossover(topBreakCheckSource,topValue) and topBreakBlock == false
topBreakBlock := true
isLongBreak := true
checkUpImbalance := true
if showBrekout
line.set_x2(topLine,bar_index)
if showBoxes
demandBox := box.new(lastRedIndex-1, lastRedHigh,lastRedIndex+1,lastRedLow, bgcolor=transGreenClr, border_color=greenClr)
array.push(arrBoxes,demandBox)
//Bottom break
if ta.crossunder(bottomBreakCheckSource,bottomValue) and bottomBreakBlock == false
bottomBreakBlock := true
isShortBreak := true
checkDownImbalance := true
if showBrekout
line.set_x2(bottomLine,bar_index)
if showBoxes
supplyBox := box.new(lastGreenIndex-1, lastGreenHigh,lastGreenIndex+1,lastGreenLow, bgcolor=transRedClr, border_color=redClr)
array.push(arrBoxes,supplyBox)
//New up fractal
if upFractal
topBreakBlock := false
isLongBreak := false
topValue := high
if showBrekout
topLine := line.new(bar_index ,topValue,bar_index,topValue, color=color.teal, style=line.style_dotted, width=2)
if isLongBreak == false
line.delete(topLine )
//New down fractal
if downFractal
bottomBreakBlock := false
isShortBreak := false
bottomValue := low
if showBrekout
bottomLine := line.new(bar_index ,bottomValue,bar_index,bottomValue, color=color.maroon, style=line.style_dotted, width=2)
if isShortBreak == false
line.delete(bottomLine )
//Box state update
//activeBoxes = box.all
activeBoxes = arrBoxes
if array.size(activeBoxes) > 0 and changeColor
for i = 0 to array.size(activeBoxes) - 1
bVal = box.get_bottom(array.get(activeBoxes, i))
tVal = box.get_top(array.get(activeBoxes, i))
if close < bVal
box.set_bgcolor(array.get(activeBoxes, i),transRedClr)
box.set_border_color(array.get(activeBoxes, i),redClr)
if close > tVal
box.set_bgcolor(array.get(activeBoxes, i),transGreenClr)
box.set_border_color(array.get(activeBoxes, i),greenClr)
//PLOTS
plotshape(showFractals ? downFractal : na,style=shape.triangleup, location=location.belowbar, offset=-n, color=color.new(color.gray,80), size = size.tiny)
plotshape(showFractals ? upFractal : na, style=shape.triangledown, location=location.abovebar, offset=-n, color=color.new(color.gray,80), size = size.tiny)
//---------------------------- Bollinger Bands ----------------------------//
bbshow = input.bool(true, "Show Bollinger Bands?", group="Bollinger Bands")
bblength = input.int(20, minval=1, group="Bollinger Bands")
bbsrc = input(close, title="Source", group="Bollinger Bands")
bbmult = input.float(2.0, minval=0.001, maxval=50, title="StdDev", group="Bollinger Bands")
bbbasis = ta.sma(bbsrc, bblength)
bbdev = bbmult * ta.stdev(bbsrc, bblength)
bbupper = bbbasis + bbdev
bblower = bbbasis - bbdev
//Input Checkbox
basis_checkbok = input.bool(title="Basis", defval = true)
bboffset = input.int(0, "Offset", minval = -499, maxval = 500)
//Plot
plot(basis_checkbok ? bbbasis : na, "Basis", color=#872323, offset = bboffset)
p1 = plot(bbshow ? bbupper : na, "Upper", color=color.teal, offset = bboffset)
p2 = plot(bbshow ? bblower : na, color = color.teal)
fill(p1, p2, title = "Background", color=#198787)
//---------------------------- Support and Resistance ----------------------------//
prd = input.int(defval=10, title='Pivot Period', minval=4, maxval=30, group="S&R")
ppsrc = input.string(defval='High/Low', title='Source', options= , group="S&R")
maxnumpp = input.int(defval=20, title=' Maximum Number of Pivot', minval=5, maxval=100, group="S&R")
ChannelW = input.int(defval=10, title='Maximum Channel Width %', minval=1, group="S&R")
maxnumsr = input.int(defval=5, title=' Maximum Number of S/R', minval=1, maxval=10, group="S&R")
min_strength = input.int(defval=2, title=' Minimum Strength', minval=1, maxval=10, group="S&R")
labelloc = input.int(defval=20, title='Label Location', group="S&R", tooltip='Positive numbers reference future bars, negative numbers reference histical bars')
linestyle = input.string(defval='Dashed', title='Line Style', options= , group="S&R")
linewidth = input.int(defval=2, title='Line Width', minval=1, maxval=4, group="S&R")
resistancecolor = input.color(defval=color.red, title='Resistance Color', group="S&R")
supportcolor = input.color(defval=color.lime, title='Support Color', group="S&R")
showpp = input(false, title='Show Point Points')
float src1 = ppsrc == 'High/Low' ? high : math.max(close, open)
float src2 = ppsrc == 'High/Low' ? low : math.min(close, open)
float ph = ta.pivothigh(src1, prd, prd)
float pl = ta.pivotlow(src2, prd, prd)
plotshape(ph and showpp, text='H', style=shape.labeldown, color=na, textcolor=color.new(color.red, 0), location=location.abovebar, offset=-prd)
plotshape(pl and showpp, text='L', style=shape.labelup, color=na, textcolor=color.new(color.lime, 0), location=location.belowbar, offset=-prd)
Lstyle = linestyle == 'Dashed' ? line.style_dashed : linestyle == 'Solid' ? line.style_solid : line.style_dotted
//calculate maximum S/R channel zone width
prdhighest = ta.highest(300)
prdlowest = ta.lowest(300)
cwidth = (prdhighest - prdlowest) * ChannelW / 100
var pivotvals = array.new_float(0)
if ph or pl
array.unshift(pivotvals, ph ? ph : pl)
if array.size(pivotvals) > maxnumpp // limit the array size
array.pop(pivotvals)
get_sr_vals(ind) =>
float lo = array.get(pivotvals, ind)
float hi = lo
int numpp = 0
for y = 0 to array.size(pivotvals) - 1 by 1
float cpp = array.get(pivotvals, y)
float wdth = cpp <= lo ? hi - cpp : cpp - lo
if wdth <= cwidth // fits the max channel width?
lo := cpp <= lo ? cpp : lo
hi := cpp > lo ? cpp : hi
numpp += 1
numpp
var sr_up_level = array.new_float(0)
var sr_dn_level = array.new_float(0)
sr_strength = array.new_float(0)
find_loc(strength) =>
ret = array.size(sr_strength)
for i = ret > 0 ? array.size(sr_strength) - 1 : na to 0 by 1
if strength <= array.get(sr_strength, i)
break
ret := i
ret
ret
check_sr(hi, lo, strength) =>
ret = true
for i = 0 to array.size(sr_up_level) > 0 ? array.size(sr_up_level) - 1 : na by 1
//included?
if array.get(sr_up_level, i) >= lo and array.get(sr_up_level, i) <= hi or array.get(sr_dn_level, i) >= lo and array.get(sr_dn_level, i) <= hi
if strength >= array.get(sr_strength, i)
array.remove(sr_strength, i)
array.remove(sr_up_level, i)
array.remove(sr_dn_level, i)
ret
else
ret := false
ret
break
ret
var sr_lines = array.new_line(11, na)
var sr_labels = array.new_label(11, na)
for x = 1 to 10 by 1
rate = 100 * (label.get_y(array.get(sr_labels, x)) - close) / close
label.set_text(array.get(sr_labels, x), text=str.tostring(label.get_y(array.get(sr_labels, x))) + '(' + str.tostring(rate, '#.##') + '%)')
label.set_x(array.get(sr_labels, x), x=bar_index + labelloc)
label.set_color(array.get(sr_labels, x), color=label.get_y(array.get(sr_labels, x)) >= close ? color.red : color.lime)
label.set_textcolor(array.get(sr_labels, x), textcolor=label.get_y(array.get(sr_labels, x)) >= close ? color.white : color.black)
label.set_style(array.get(sr_labels, x), style=label.get_y(array.get(sr_labels, x)) >= close ? label.style_label_down : label.style_label_up)
line.set_color(array.get(sr_lines, x), color=line.get_y1(array.get(sr_lines, x)) >= close ? resistancecolor : supportcolor)
if ph or pl
//because of new calculation, remove old S/R levels
array.clear(sr_up_level)
array.clear(sr_dn_level)
array.clear(sr_strength)
//find S/R zones
for x = 0 to array.size(pivotvals) - 1 by 1
= get_sr_vals(x)
if check_sr(hi, lo, strength)
loc = find_loc(strength)
// if strength is in first maxnumsr sr then insert it to the arrays
if loc < maxnumsr and strength >= min_strength
array.insert(sr_strength, loc, strength)
array.insert(sr_up_level, loc, hi)
array.insert(sr_dn_level, loc, lo)
// keep size of the arrays = 5
if array.size(sr_strength) > maxnumsr
array.pop(sr_strength)
array.pop(sr_up_level)
array.pop(sr_dn_level)
for x = 1 to 10 by 1
line.delete(array.get(sr_lines, x))
label.delete(array.get(sr_labels, x))
for x = 0 to array.size(sr_up_level) > 0 ? array.size(sr_up_level) - 1 : na by 1
float mid = math.round_to_mintick((array.get(sr_up_level, x) + array.get(sr_dn_level, x)) / 2)
rate = 100 * (mid - close) / close
array.set(sr_labels, x + 1, label.new(x=bar_index + labelloc, y=mid, text=str.tostring(mid) + '(' + str.tostring(rate, '#.##') + '%)', color=mid >= close ? color.red : color.lime, textcolor=mid >= close ? color.white : color.black, style=mid >= close ? label.style_label_down : label.style_label_up))
array.set(sr_lines, x + 1, line.new(x1=bar_index, y1=mid, x2=bar_index - 1, y2=mid, extend=extend.both, color=mid >= close ? resistancecolor : supportcolor, style=Lstyle, width=linewidth))
f_crossed_over() =>
ret = false
for x = 0 to array.size(sr_up_level) > 0 ? array.size(sr_up_level) - 1 : na by 1
float mid = math.round_to_mintick((array.get(sr_up_level, x) + array.get(sr_dn_level, x)) / 2)
if close <= mid and close > mid
ret := true
ret
ret
f_crossed_under() =>
ret = false
for x = 0 to array.size(sr_up_level) > 0 ? array.size(sr_up_level) - 1 : na by 1
float mid = math.round_to_mintick((array.get(sr_up_level, x) + array.get(sr_dn_level, x)) / 2)
if close >= mid and close < mid
ret := true
ret
ret
alertcondition(f_crossed_over(), title='Resistance Broken', message='Resistance Broken')
alertcondition(f_crossed_under(), title='Support Broken', message='Support Broken')
SmartSkull 15 minutes//@version=5
indicator("LegendGPT – First 15m Extremes + Second 15m Breakout FVG + Alerts", overlay=true, max_boxes_count=500)
// SETTINGS
boxColor = input.color(color.new(color.gray, 85), "Opening Box Color")
fvgBullColor = input.color(color.new(color.green, 85), "Bullish FVG Color")
fvgBearColor = input.color(color.new(color.red, 85), "Bearish FVG Color")
sessionTZ = "America/New_York"
nasdaqOpenHour = 9
nasdaqOpenMinute = 30
// 15m data for box
time15_tf = request.security(syminfo.tickerid, "15", time, lookahead=barmerge.lookahead_on)
high15_tf = request.security(syminfo.tickerid, "15", high, lookahead=barmerge.lookahead_on)
low15_tf = request.security(syminfo.tickerid, "15", low, lookahead=barmerge.lookahead_on)
// First 15m candle start
isFirst15mActive = (hour(time15_tf, sessionTZ) == nasdaqOpenHour and minute(time15_tf, sessionTZ) == nasdaqOpenMinute)
isSecond15mActive = (hour(time15_tf, sessionTZ) == nasdaqOpenHour and minute(time15_tf, sessionTZ) == nasdaqOpenMinute + 15)
// STATE VARS
var box openingRangeBox = na
var float session1mHigh = na
var int session1mHighBar = na
var float session1mLow = na
var int session1mLowBar = na
var bool extremesMarked = false
var bool bullBreakout = false
var bool bearBreakout = false
var bool fvgDrawn = false
var box fvgBox = na
var label fvgFilledLabel = na
newDay = time("D", sessionTZ) != time("D", sessionTZ)
// RESET DAILY
if newDay
if not na(openingRangeBox)
box.delete(openingRangeBox)
if not na(fvgBox)
box.delete(fvgBox)
if not na(fvgFilledLabel)
label.delete(fvgFilledLabel)
session1mHigh := na
session1mHighBar := na
session1mLow := na
session1mLowBar := na
extremesMarked := false
bullBreakout := false
bearBreakout := false
fvgDrawn := false
// Only run on 1-minute timeframe
if timeframe.multiplier == 1
// CREATE OPENING RANGE BOX for first 15m
if isFirst15mActive and na(openingRangeBox)
openingRangeBox := box.new(left=bar_index, top=high15_tf, right=bar_index + 15, bottom=low15_tf, bgcolor=boxColor, border_color=color.new(color.black, 90))
// Track highest/lowest 1m candle during first 15m
if isFirst15mActive
if na(session1mHigh)
session1mHigh := high
session1mHighBar := bar_index
session1mLow := low
session1mLowBar := bar_index
else
if high > session1mHigh
session1mHigh := high
session1mHighBar := bar_index
if low < session1mLow
session1mLow := low
session1mLowBar := bar_index
// When first 15m ends, mark extremes
if isFirst15mActive and not isFirst15mActive and not extremesMarked
// Green box for highest 1m candle
box.new(left=session1mHighBar, top=session1mHigh, right=session1mHighBar + 1, bottom=session1mHigh, border_color=color.green, bgcolor=color.new(color.green, 80))
// Red box for lowest 1m candle
box.new(left=session1mLowBar, top=session1mLow, right=session1mLowBar + 1, bottom=session1mLow, border_color=color.red, bgcolor=color.new(color.red, 80))
extremesMarked := true
// SECOND 15m: Check breakout of high/low
if isSecond15mActive
// Bullish breakout
if not bullBreakout and high > session1mHigh
bullBreakout := true
bearBreakout := false
alert("LegendGPT: Bullish Breakout above first 15m high", alert.freq_once_per_bar)
// Bearish breakout
if not bearBreakout and low < session1mLow
bearBreakout := true
bullBreakout := false
alert("LegendGPT: Bearish Breakout below first 15m low", alert.freq_once_per_bar)
// After breakout in second 15m, look for first FVG
if isSecond15mActive and not fvgDrawn
// Bullish FVG condition
if bullBreakout and low > high
fvgBox := box.new(left=bar_index - 1, top=high , right=bar_index, bottom=low, bgcolor=fvgBullColor, border_color=color.green)
fvgDrawn := true
alert("LegendGPT: Bullish FVG formed after breakout", alert.freq_once_per_bar)
// Bearish FVG condition
if bearBreakout and high < low
fvgBox := box.new(left=bar_index - 1, top=high, right=bar_index, bottom=low , bgcolor=fvgBearColor, border_color=color.red)
fvgDrawn := true
alert("LegendGPT: Bearish FVG formed after breakout", alert.freq_once_per_bar)
// PERSISTENT FVG: delete when filled
if not na(fvgBox)
fvgTop = box.get_top(fvgBox)
fvgBottom = box.get_bottom(fvgBox)
if high >= fvgBottom and low <= fvgTop
box.delete(fvgBox)
fvgBox := na
fvgDrawn := false
if not na(fvgFilledLabel)
label.delete(fvgFilledLabel)
fvgFilledLabel := label.new(bar_index, close, text="FVG filled", style=label.style_label_center, color=color.blue, textcolor=color.white, size=size.tiny)
alert("LegendGPT: FVG filled (mitigation)", alert.freq_once_per_bar)
INFLECTION NEXUS - Shadow Portfolio AdaptiveINFLECTION NEXUS - SPA (Shadow Portfolio Adaptive)
Foreword: The Living Algorithm
For decades, technical analysis has been a conversation between a trader and a static chart. We draw our lines, we apply our indicators with their fixed-length inputs, and we hope that our rigid tools can somehow capture the essence of a market that is fluid, chaotic, and perpetually evolving. When our tools fail, we are told to "adapt." But what if the tools themselves could learn that lesson? What if our indicators could adapt not just for us, but with us?
This script, INFLECTION NEXUS - SPA, is the first step in that direction. It is an experimental framework, a research project shared publicly, built around a radical new core: the Shadow Portfolio Adaptive (SPA) Engine . Let's be clear from the outset: the signal logic you see—the buy and sell labels—is a refined version from my previous work, "Turning Point." The signals are not the star of this show. This entire publication is a showcase of the groundbreaking, self-learning engine that now powers them.
You will likely feel that this system is overwhelmingly complex when you first load it. That is by design. This is not another simple crossover indicator. This is a look under the hood of a system designed to emulate the perpetual learning cycle of a human mind. My goal with this document is to break down every single component, every color, every number, into simple, understandable pieces. We will go through this step-by-step, so that by the end, you will not only understand how it works, but you will appreciate the depth of the analysis it performs on your behalf.
This is a beta release. Not all planned features are fully functional, and I will be updating it as the research continues. But the core engine is here, and it represents a new paradigm. Prepare to engage with a script that doesn't just analyze the market—it actively seeks to understand it.
Chapter 1: The Paradigm Shift - Why the SPA Engine is a Leap Forward
To grasp the innovation here, we must first deconstruct the old way of thinking about "adaptive" indicators.
Part A: The Traditional Model - Driving by the Rear-View Mirror
Imagine a self-driving car that can only make adjustments after it has already completed a trip. This is, in essence, how most "adaptive" trading systems work. Their process is fundamentally reactive and inefficient:
Wait for a Signal: The system is idle until its specific, hard-coded logic (e.g., a moving average crossover) generates a buy or sell signal.
Wait for an Outcome: It then waits for that entire trade to play out and close, resulting in a win or a loss.
Collect Limited Data: It only learns from the performance of its own signals. If the market is moving but not generating signals, the system is blind and learns nothing.
Require a Massive Sample Size: To avoid making changes based on random luck, it must wait for a huge number of trades—often 50, 100, or even more—before it has a statistically significant sample of wins and losses.
Make a Belated Adjustment: Finally, after this long "warm-up" period, it will make a tiny, retrospective adjustment to its parameters.
The fatal flaw is obvious: this model is always adapting to a market that no longer exists. It is slow, data-starved, and hopelessly biased by its own signal logic.
Part B: The SPA Model - The Proactive Co-Pilot
The Shadow Portfolio Adaptive (SPA) engine is a complete re-imagining of this process. It is not a reactive historian; it is a proactive, ever-present co-pilot, constantly learning and recalibrating.
It Never Waits: The SPA engine does not wait for a signal to learn. From the moment you load it on the chart, its Shadow Portfolio begins running constant, 5-bar long and short trades in the background. It is not testing a "signal"; it is testing the very fabric of the market, bar by bar.
It is Data-Saturated: Because it learns from every 5-bar slice of price action, the SPA engine gathers a colossal amount of unbiased data. While a traditional system might learn from one trade every 50 bars, the SPA engine learns from a long and a short trade every single bar after its initial cycle.
Instantaneous Market Awareness - The End of the "Warm-Up": This is the core innovation. A traditional adaptive system is effectively useless for the first 50-100 trades. The SPA engine's warm-up period is exactly five bars . On the 6th bar of the chart, the first shadow trade closes, a data point is generated, and the learning process begins. From the 6th bar onward, the engine is market-aware and capable of making intelligent adjustments. The SPA engine isn't adapting to old wins and losses. It is adapting, in near real-time, to the market's ever-shifting character, volatility, and personality.
Chapter 2: The Anatomy of the SPA Engine - A Toddler's Guide to a Complex Brain
The engine is composed of three primary systems that work in a beautiful, interconnected symphony. Let's break them down.
Section 1: The Shadow Portfolio (The Information Harvester)
What it is, Simply: Think of this as the script's eyes and ears. It's a team of 10 virtual traders (5 long, 5 short) who are constantly taking small, quick trades to feel out the market.
How it Works, Simply: On every new bar, a new "long" trader and a new "short" trader enter the market. Exactly 5 bars later, they close their positions. This cycle is perpetual and relentless.
The Critical 'Why': Because these virtual traders enter and exit based on a fixed time (5 bars), not on a "good" or "bad" signal, their results are completely unbiased . They are simply measuring: "What happened to price over the last 5 bars?" This provides the raw, untainted truth about the market's behavior that the rest of the system needs to learn effectively.
The Golden Metric (ATR Normalization): The engine doesn't just look at dollar P&L. It's smarter than that. It asks a more intelligent question: "How much did this trade make relative to the current volatility?"
Analogy: Imagine a flea and an elephant. If they both jump 1 inch, who is more impressive? The flea. The SPA engine understands this. A $10 profit when the market is dead quiet is far more significant than a $10 profit during a wild, volatile swing.
The Formula: realized_atr = (close - trade.entry) / trade.atr_entry. It takes the raw profit and divides it by the Average True Range (a measure of volatility) at the moment of entry. This gives a pure, "apples-to-apples" score for every single trade, which is the foundational data point for all learning.
Section 2: The Cognitive Map (The Long-Term Brain)
What it is, Simply: This is the engine's deep memory, its library of experiences. Imagine a giant, 64-square chessboard (8x8 grid). Each square on the board represents a very specific type of market environment.
The Two Dimensions of Thought (The 'How'): How does it know which square we are on? It looks at two things:
The Market's Personality (X-Axis): Is the market behaving like a disciplined soldier, marching in a clear trend? Or is it like a chaotic, unpredictable child, running all over the place? The engine calculates a "Regime" score to figure this out.
The Market's Energy Level (Y-Axis): Is the market sleepy and quiet, or is it wide-awake and hyperactive? The engine measures "Normalized Volatility" to determine this.
The Power of Generalization (The 'Why'): When a Shadow Portfolio trade closes, its result is recorded in the corresponding square on the chessboard. But here's the clever part: it also shares a little bit of that lesson with the squares immediately next to it (using a Gaussian Kernel).
Analogy: If you touch a hot stove and learn "don't touch," your brain is smart enough to know you probably shouldn't touch the hot oven door next to it either, even if you haven't touched it directly. The Cognitive Map does the same thing, allowing it to make intelligent inferences even in market conditions it has seen less frequently. Each square remembers what indicator settings worked best in that specific environment.
Section 3: The Adaptive Engine (The Central Nervous System)
What it is, Simply: This is the conductor of the orchestra. It takes information from all other parts of the system and decides exactly what to do.
The Symphony of Inputs: It listens to three distinct sources of information before making a decision:
The Short-Term Memory (Rolling Stats): It looks at the performance of the last rollN shadow trades. This is its immediate, recent experience.
The Long-Term Wisdom (Cognitive Map): It consults the grand library of the Cognitive Map to see what has worked best in the current market type over the long haul.
The Gut Instinct (Bin Learning): It keeps a small "mini-batch" of the most recent trades. If this batch shows a very strong, sudden pattern, it can trigger a rapid, reflexive adjustment, like pulling your hand away from a flame.
The Fusion Process: It then blends these three opinions together in a sophisticated way. It gives more weight to the opinions it's more confident in (e.g., a Cognitive Map square with hundreds of trades of experience) and uses your Adaptation Intensity (dialK) input to decide how much to listen to its "gut instinct." The final decision is then smoothed to ensure the indicator's parameters change in a stable, intelligent way.
Chapter 3: The Control Panel - A Granular Guide to the Inputs
Every input is a lever to tune the engine. Let's demystify them.
🧾 Signal Engine (Original): These inputs control the "Turning Point" signal logic.
What they are: Toggles for Reversal Mode (catch tops/bottoms) and Breakout Mode (follow the trend), plus filters like Require New Extreme to ensure signals come from points of extension.
How to use them: For a ranging market, you might favor Reversal mode. For a strongly trending market, Breakout mode might be better. These settings fine-tune the final alert, which is powered by the adaptive engine.
🎛️ Master Control:
Adaptation Intensity (dialK): THIS IS THE MOST IMPORTANT INPUT. It controls the personality of the learning engine.
Low Setting (1-5): Creates a "Wise Old Professor" engine. It's patient, learns from larger batches of data, and makes slow, deliberate, and highly confident adjustments. Use this for stable assets like indices or blue-chip stocks.
High Setting (15-20): Creates a "Hyper-Reactive Day Trader" engine. It learns from tiny samples, trusts its gut instinct, and makes large, aggressive adjustments to keep up with a frantic market. Use this for highly volatile assets like crypto or meme stocks.
🧠 Adaptive Engine & 🎯 Learning:
What they are: The deep mechanics of the learning process. Base Learn Rate is the fundamental step size of adjustments. Rolling Window Size is the length of its "short-term memory." Adaptation Momentum controls how smoothly the parameters transition to their new learned values.
How to use them: For most users, the defaults are well-balanced. Advanced users can tweak these to make the engine even more or less sensitive to new information.
🗺️ Cognitive Map, STM & Checkpoints:
What they are: Controls for the engine's brain. Enable Cognitive Map turns on the long-term memory.
The Checkpoint System - Your "Save Game" Feature: This is incredibly powerful.
To Save: Toggle Emit Checkpoint Now. Go to your alert log, and you will see a very long string of text. Copy this entire string.
To Load: Paste that string into the Memory Checkpoint input box. Toggle Apply Checkpoint On Next Bar. The script will instantly load its entire "brain"—every learned parameter and all 64 cells of the Cognitive Map. You can train the engine on one chart and transfer its intelligence to another.
Chapter 4: The Command Center - Decoding the Dashboard
This is your window into the engine's mind. Do not be intimidated. Let's break it down.
PANEL A (INFLECTION NEXUS): The high-level overview.
Market Context: See how the engine classifies the market's Trend and Regime (personality).
Shadow Portfolio Summary: The engine's report card. Watch the Win Rate and Avg P&L to see the quality of the raw data it's learning from.
PANEL B (SHADOW PORTFOLIO ADAPTIVE): The deep diagnostics.
Performance Metrics: Advanced stats like Sharpe Ratio (return vs. risk) and Sortino Ratio (return vs. downside risk). This tells you about the quality and consistency of the market movements the engine is analyzing.
Adaptive Parameters (Live vs Base): THIS IS THE MOST IMPORTANT SECTION. It shows the engine's Live parameters right next to your (Base) inputs.
How to interpret it: If you see the Live ATR Len is 45 while your Base input is 20, the engine is telling you: "The market is in a long, smooth trend right now. Short-term noise is a trap. I have learned that we must use a longer-term perspective to see clearly." This section translates the engine's learning directly into actionable insight.
Memory Log: A live ticker of the engine's thoughts, showing every trade it learns from and every adaptation it makes.
Chapter 5: Reading the Canvas - On-Chart Visuals
The Bands (Green/Blue Lines): These are not static Supertrend lines. They are the
physical manifestation of the engine's current thinking. As the engine learns and adapts its ATR Period and Multiplier, you will see these bands widen, tighten, and adjust their distance from price. They are alive.
The Labels (BUY/SELL): These are the final output of the "Turning Point" logic, now supercharged and informed by the fully adaptive SPA engine.
The Purple Pulse (Dot and Background Glow): This is your visual cue that the engine is "thinking." Every time you see this pulse, it means the SPA has just completed a learning cycle and updated its parameters. It is actively recalibrating itself to the market.
Chapter 6: A Personal Manifesto on Innovation
I want to conclude with a personal note on why I dedicate countless hours to building systems like this and sharing them openly.
My purpose is to drive innovation, period. I am not in this space to follow the crowd or to re-package old ideas. The world does not need a 100th version of a slightly modified MACD. Real progress comes from venturing into the wilderness, from asking difficult questions, and from pursuing concepts that lie at the very edge of possibility.
I am not afraid of being wrong. I am not afraid of being bested by my peers. In fact, I welcome it. If another developer takes an idea from this engine, improves it, and builds something even more magnificent, that is a profound win for our entire community. The only failure I recognize is the failure to try. The only trap I fear is the creative complacency of producing sterile, recycled work just to appease the status quo.
I love this community, and I believe with every fiber of my being that we have barely scratched the surface of what can be discovered and created. This script is my contribution to that shared journey. It is a tool, an idea, and a challenge to all of us: let's keep pushing.
DISCLAIMER: This script is an experimental framework provided for educational and research purposes ONLY. It is not financial advice. All trading involves substantial risk of loss. Past performance is not indicative of future results. Please use this tool responsibly and as part of a comprehensive trading plan.
As the great computer scientist Herbert A. Simon, a pioneer of artificial intelligence, famously said:
"Learning is any process by which a system improves performance from experience."
May this engine enhance your experience.
— Dskyz, for DAFE Trading Systems
EMA Volume Confluence + Trend Bands[BBM]# EMA Volume Confluence + Trend Bands Indicator
## Overview
A professional day trading indicator designed to eliminate false breakouts and early entries by combining multiple confirmation signals. Perfect for futures and crypto traders holding positions 1-2 days max.
## What It Does
- **Filters out false signals** by requiring EMA crossovers, volume spikes, VWAP confirmation, AND momentum alignment
- **Shows volatility-based trend bands** to identify genuine breakouts vs noise
- **Provides clear entry signals** only when ALL conditions align
- **Real-time metrics dashboard** showing RSI, volume, VWAP position, and band status
## Signal Types
- **LONG/SHORT triangles**: High-probability EMA cross entries with full confirmation
- **BO (Breakout) crosses**: Volatility expansion breakouts with volume support
- **Yellow background**: Volume spike in progress - watch for signals
- **Colored bands**: Trade inside the channel or wait for confirmed breakouts
## Recommended Settings
### For Crypto (High Volatility)
- **Volume Spike Multiplier**: 2.0x (crypto has bigger spikes)
- **Band Multiplier**: 2.5-3.0 (wider bands for volatility)
- **Best Timeframes**: 5min, 15min
- **RSI Settings**: Keep default (70/30)
### For Futures (E-mini, Oil, Gold)
- **Volume Spike Multiplier**: 1.3-1.5x (tighter volume filter)
- **Band Multiplier**: 1.5-2.0 (narrower for cleaner signals)
- **Best Timeframes**: 1min, 5min, 15min
- **RSI Settings**: Keep default (70/30)
### For Swing/Position (1-2 day holds)
- **Volume Spike Multiplier**: 1.5x
- **Band Multiplier**: 2.0
- **Best Timeframes**: 1H, 4H
- **Consider**: Adjust RSI to 65/35 for less filtering on larger timeframes
## Pro Tips
1. **Best trades**: LONG/SHORT signals that appear right as price touches the bands
2. **Avoid**: Signals when RSI is extended (red/green in table)
3. **Volume is key**: No yellow background = probably skip the signal
4. **VWAP acts as bias**: Above = favor longs, Below = favor shorts
5. **Band breakouts (BO)**: These are your highest conviction momentum plays
## Risk Management
- Use the Band Multiplier (ATR-based) to gauge volatility
- "Above/Below" band position = extended move, consider taking profits
- "Inside" band position = consolidation, best for entries
- Higher volume multiplier = fewer but higher quality signals
## Alert Setup
Set alerts for:
- "Long Entry" - Full EMA setup
- "Short Entry" - Full EMA setup
- "Breakout Long" - Band breakout with volume
- "Breakout Short" - Band breakdown with volume
---
**Note**: This indicator prioritizes quality over quantity. You'll get fewer signals, but they have much better win rates because they require multiple confirmations. Perfect for traders tired of getting whipsawed by false breakouts!
ZigzagLiteLibrary "ZigzagLite"
Lighter version of the Zigzag Library. Without indicators and sub-component divisions
method getPrices(pivots)
Gets the array of prices from array of Pivots
Namespace types: array
Parameters:
pivots (array) : array array of Pivot objects
Returns: array array of pivot prices
method getBars(pivots)
Gets the array of bars from array of Pivots
Namespace types: array
Parameters:
pivots (array) : array array of Pivot objects
Returns: array array of pivot bar indices
method getPoints(pivots)
Gets the array of chart.point from array of Pivots
Namespace types: array
Parameters:
pivots (array) : array array of Pivot objects
Returns: array array of pivot points
method getPoints(this)
Gets the array of chart.point from Zigzag Object
Namespace types: Zigzag
Parameters:
this (Zigzag) : Zigzag object
Returns: array array of pivot points
method calculate(this, ohlc, ltfHighTime, ltfLowTime)
Calculate zigzag based on input values and indicator values
Namespace types: Zigzag
Parameters:
this (Zigzag) : Zigzag object
ohlc (array) : Array containing OHLC values. Can also have custom values for which zigzag to be calculated
ltfHighTime (int) : Used for multi timeframe zigzags when called within request.security. Default value is current timeframe open time.
ltfLowTime (int) : Used for multi timeframe zigzags when called within request.security. Default value is current timeframe open time.
Returns: current Zigzag object
method calculate(this)
Calculate zigzag based on properties embedded within Zigzag object
Namespace types: Zigzag
Parameters:
this (Zigzag) : Zigzag object
Returns: current Zigzag object
method nextlevel(this)
Calculate Next Level Zigzag based on the current calculated zigzag object
Namespace types: Zigzag
Parameters:
this (Zigzag) : Zigzag object
Returns: Next Level Zigzag object
method clear(this)
Clears zigzag drawings array
Namespace types: array
Parameters:
this (array) : array
Returns: void
method clear(this)
Clears zigzag drawings array
Namespace types: array
Parameters:
this (array) : array
Returns: void
method drawplain(this)
draws fresh zigzag based on properties embedded in ZigzagDrawing object without trying to calculate
Namespace types: ZigzagDrawing
Parameters:
this (ZigzagDrawing) : ZigzagDrawing object
Returns: ZigzagDrawing object
method drawplain(this)
draws fresh zigzag based on properties embedded in ZigzagDrawingPL object without trying to calculate
Namespace types: ZigzagDrawingPL
Parameters:
this (ZigzagDrawingPL) : ZigzagDrawingPL object
Returns: ZigzagDrawingPL object
method drawfresh(this, ohlc)
draws fresh zigzag based on properties embedded in ZigzagDrawing object
Namespace types: ZigzagDrawing
Parameters:
this (ZigzagDrawing) : ZigzagDrawing object
ohlc (array) : values on which the zigzag needs to be calculated and drawn. If not set will use regular OHLC
Returns: ZigzagDrawing object
method drawcontinuous(this, ohlc)
draws zigzag based on the zigzagmatrix input
Namespace types: ZigzagDrawing
Parameters:
this (ZigzagDrawing) : ZigzagDrawing object
ohlc (array) : values on which the zigzag needs to be calculated and drawn. If not set will use regular OHLC
Returns:
PivotCandle
PivotCandle represents data of the candle which forms either pivot High or pivot low or both
Fields:
_high (series float) : High price of candle forming the pivot
_low (series float) : Low price of candle forming the pivot
length (series int) : Pivot length
pHighBar (series int) : represents number of bar back the pivot High occurred.
pLowBar (series int) : represents number of bar back the pivot Low occurred.
pHigh (series float) : Pivot High Price
pLow (series float) : Pivot Low Price
Pivot
Pivot refers to zigzag pivot. Each pivot can contain various data
Fields:
point (chart.point) : pivot point coordinates
dir (series int) : direction of the pivot. Valid values are 1, -1, 2, -2
level (series int) : is used for multi level zigzags. For single level, it will always be 0
ratio (series float) : Price Ratio based on previous two pivots
sizeRatio (series float) : ratio of current zigzag wave size in comparison to last zigzag wave in the same direction
barRatio (series float) : Bar Ratio based on previous two pivots
ZigzagFlags
Flags required for drawing zigzag. Only used internally in zigzag calculation. Should not set the values explicitly
Fields:
newPivot (series bool) : true if the calculation resulted in new pivot
doublePivot (series bool) : true if the calculation resulted in two pivots on same bar
updateLastPivot (series bool) : true if new pivot calculated replaces the old one.
Zigzag
Zigzag object which contains whole zigzag calculation parameters and pivots
Fields:
length (series int) : Zigzag length. Default value is 5
numberOfPivots (series int) : max number of pivots to hold in the calculation. Default value is 20
offset (series int) : Bar offset to be considered for calculation of zigzag. Default is 0 - which means calculation is done based on the latest bar.
level (series int) : Zigzag calculation level - used in multi level recursive zigzags
zigzagPivots (array) : array which holds the last n pivots calculated.
flags (ZigzagFlags) : ZigzagFlags object which is required for continuous drawing of zigzag lines.
ZigzagObject
Zigzag Drawing Object
Fields:
zigzagLine (series line) : Line joining two pivots
zigzagLabel (series label) : Label which can be used for drawing the values, ratios, directions etc.
ZigzagProperties
Object which holds properties of zigzag drawing. To be used along with ZigzagDrawing
Fields:
lineColor (series color) : Zigzag line color. Default is color.blue
lineWidth (series int) : Zigzag line width. Default is 1
lineStyle (series string) : Zigzag line style. Default is line.style_solid.
showLabel (series bool) : If set, the drawing will show labels on each pivot. Default is false
textColor (series color) : Text color of the labels. Only applicable if showLabel is set to true.
maxObjects (series int) : Max number of zigzag lines to display. Default is 300
xloc (series string) : Time/Bar reference to be used for zigzag drawing. Default is Time - xloc.bar_time.
curved (series bool) : Boolean field to print curved zigzag - used only with polyline implementation
force_overlay (series bool) : force drawing in price overlay
ZigzagDrawing
Object which holds complete zigzag drawing objects and properties.
Fields:
zigzag (Zigzag) : Zigzag object which holds the calculations.
properties (ZigzagProperties) : ZigzagProperties object which is used for setting the display styles of zigzag
drawings (array) : array which contains lines and labels of zigzag drawing.
ZigzagDrawingPL
Object which holds complete zigzag drawing objects and properties - polyline version
Fields:
zigzag (Zigzag) : Zigzag object which holds the calculations.
properties (ZigzagProperties) : ZigzagProperties object which is used for setting the display styles of zigzag
zigzagLabels (array)
zigzagLine (series polyline) : polyline object of zigzag lines
LW Outside Day Flip【SpeculationLab】Applicable Timeframe
⚠️ Note: This indicator is primarily designed for the Daily timeframe.
Larry Williams’ original discussion and statistics were based on daily data. While it can technically be applied to other timeframes, results may vary. It is strongly recommended to use it on daily charts.
Overview
This indicator marks a classic “Outside Day + Extreme Close” price action pattern. The idea comes from Larry Williams’ Long-Term Secrets to Short-Term Trading (2nd edition, Chapter 7).
The indicator does not execute trades or generate alerts — it simply plots visual markers on the chart when the pattern conditions are met, to assist research and review.
Logic
Outside Bar Condition
Current high > previous high
Current low < previous low
Extreme Close Filter
Long signal: Close < previous low
Short signal: Close > previous high
Confirmation
Signals are only confirmed at bar close (barstate.isconfirmed), to avoid repainting during intrabar movement.
Chart Display
When a long signal is triggered, a green downward triangle is plotted above the bar.
When a short signal is triggered, a red upward triangle is plotted below the bar.
Signals are overlaid directly on the price chart (overlay=true) and serve only as visual cues.
Usage Notes
Best used as a filter or secondary confirmation tool, not as a standalone entry trigger.
Consider combining with higher timeframe trend, key support/resistance, or volume analysis.
Entries, stop losses, and profit targets should be defined and tested independently by the trader.
Limitations and Risks
In strong trending markets, these signals may fail.
In low-liquidity or gapping conditions, accuracy may be reduced.
A single candlestick pattern cannot ensure consistent profitability.
Disclaimer
This script is for educational and research purposes only. It is not financial advice. Trading carries risk, and users are solely responsible for their own decisions and results.
===================
指标适用范围
⚠️ 特别提示：本指标主要适用于日线图（Daily Timeframe）。
Larry Williams 的原始讨论与统计均基于日线数据。虽然技术上可以在其它周期应用，但效果可能会不同，建议严格以日线作为主要参考周期。
功能概述
本指标用于在图表上标记一种经典的“外包线 + 极端收盘”的价格行为形态。思路参考 Larry Williams 在《Long-Term Secrets to Short-Term Trading》（第二版，第七章）中对日线“Outside Day”与反向收盘的讨论。指标不包含交易执行或提醒功能，仅在满足条件时绘制信号标记，用于辅助研究。
计算逻辑
外包线（Outside Bar）判定
最高价高于前一根K线的最高价；
最低价低于前一根K线的最低价。
极端收盘过滤
做多信号（Long）：收盘价低于前一根K线的最低价；
做空信号（Short）：收盘价高于前一根K线的最高价。
确认方式
仅在K线收盘后确认（避免盘中信号反复出现/消失）。
绘图说明
触发做多条件时，在K线 上方 绘制 绿色 向下三角形标记。
触发做空条件时，在K线 下方 绘制 红色 向上三角形标记。
信号直接叠加在价格图上（overlay=true），仅作提示。
使用建议
建议作为筛选条件或二次确认工具，不要单独作为入场依据；
可以配合趋势方向、关键支撑/阻力、成交量等其他因素一起使用；
入场、止损与止盈需由使用者自行定义和验证。
限制与风险
在强趋势行情中，信号可能失效；
在低流动性或跳空行情中，信号准确度下降；
单一形态不能保证稳定盈利。
免责声明
本指标仅用于教育与研究，不构成投资建议。实际交易风险由使用者自行承担。
MTF Squeeze Analyzer - [tradeviZion]MTF Squeeze Analyzer
Multi-Timeframe Squeeze Pro Analyzer Tool
Overview:
The MTF Squeeze Analyzer is a comprehensive tool designed to help traders monitor the TTM Squeeze indicator across multiple timeframes in a streamlined and efficient manner. Built with Pine Script™ version 5, this indicator enhances your market analysis by providing detailed insights into squeeze conditions and momentum shifts, enabling you to make more informed trading decisions.
Key Features:
1. Multi-Timeframe Monitoring:
Comprehensive Coverage: Track squeeze conditions across multiple timeframes, including 1-minute, 5-minute, 15-minute, 30-minute, 1-hour, 2-hour, 4-hour, and daily charts.
Squeeze Counts: Keep count of the number of consecutive bars the price has been within each squeeze level (low, mid, high), helping you assess the strength and duration of consolidation periods.
2. Dynamic Table Display:
Customizable Appearance: Adjust table position, text size, and colors to suit your preferences.
Color-Coded Indicators: Easily identify squeeze levels and momentum shifts with intuitive color schemes.
Message Integration: Features rotating messages to keep you engaged and informed.
3. Alerts for Key Market Events:
Squeeze Start and Fire Alerts: Receive notifications when a squeeze starts or fires on your selected timeframes.
Custom Squeeze Count Alerts: Set thresholds for squeeze counts and get alerted when these levels are reached, allowing you to anticipate potential breakouts.
Fully Customizable: Choose which alerts you want to receive and tailor them to your trading strategy.
4. Momentum Analysis:
Momentum Oscillator: Visualize momentum using a histogram that changes color based on momentum shifts.
Detailed Insights: Determine whether momentum is increasing or decreasing to make more strategic trading decisions.
How It Works:
The indicator is based on the TTM Squeeze concept, which identifies periods of low volatility where the market is "squeezing" before a potential breakout. It analyzes the relationship between Bollinger Bands and Keltner Channels to determine squeeze conditions and uses linear regression to calculate momentum.
1. Squeeze Levels:
No Squeeze (Green): Market is not in a squeeze.
Low Compression Squeeze (Gray): Mild consolidation, potential for a breakout.
Mid Compression Squeeze (Red): Moderate consolidation, higher breakout potential.
High Compression Squeeze (Orange): Strong consolidation, significant breakout potential.
2. Squeeze Counts:
Tracks the number of consecutive bars in each squeeze condition.
Helps identify how long the market has been consolidating, providing clues about potential breakout timing.
3. Momentum Histogram:
Upward Momentum: Shown in aqua or blue, indicating increasing or decreasing upward momentum.
Downward Momentum: Displayed in red or yellow, representing increasing or decreasing downward momentum.
Using Alerts:
Stay ahead of market movements with customizable alerts:
1. Enable Alerts in Settings:
Squeeze Start Alert: Get notified when a new squeeze begins.
Squeeze Fire Alert: Be alerted when a squeeze ends, signaling a potential breakout.
Squeeze Count Alert: Set a specific number of bars for a squeeze condition, and receive an alert when this count is reached.
2. Set Up Alerts on Your Chart:
Click on the indicator name and select " Add Alert on MTF Squeeze Analyzer ".
Choose your desired alert conditions and customize the notification settings.
Click " Create " to activate the alerts.
How to Set It Up:
1. Add the Indicator to Your Chart:
Search for " MTF Squeeze Analyzer " in the TradingView Indicators library.
Add it to your chart.
2. Customize Your Settings:
Table Display:
Choose whether to show the table and select its position on the chart.
Adjust text size and colors to enhance readability.
Timeframe Selection:
Select the timeframes you want to monitor.
Enable or disable specific timeframes based on your trading strategy.
Colors & Styles:
Customize colors for different squeeze levels and momentum shifts.
Adjust header and text colors to match your chart theme.
Alert Settings:
Enable alerts for squeeze start, squeeze fire, and squeeze counts.
Set your preferred squeeze type and count threshold for alerts.
3. Interpret the Data:
Table Information:
The table displays the squeeze status and counts for each selected timeframe.
Colors indicate the type of squeeze, making it easy to assess market conditions at a glance.
Momentum Histogram:
Use the histogram to gauge the strength and direction of market momentum.
Observe color changes to identify shifts in momentum.
Why Use MTF Squeeze Analyzer ?
Enhanced Market Insight:
Gain a deeper understanding of market dynamics by monitoring multiple timeframes simultaneously.
Identify potential breakout opportunities by analyzing squeeze durations and momentum shifts.
Customizable and User-Friendly:
Tailor the indicator to fit your trading style and preferences.
Easily adjust settings without needing to delve into the code.
Time-Efficient:
Save time by viewing all relevant squeeze information in one place.
Reduce the need to switch between different charts and timeframes.
Stay Informed with Alerts:
Never miss a critical market movement with fully customizable alerts.
Focus on other tasks while the indicator monitors the market for you.
Acknowledgment:
This tool builds upon the foundational work of John Carter , who developed the TTM Squeeze concept. It also incorporates enhancements from LazyBear and Makit0 , providing a more versatile and powerful indicator. MTF Squeeze Analyzer extends these concepts by adding multi-timeframe analysis, squeeze counting, and advanced alerting features, offering traders a comprehensive solution for market analysis.
Note: Always practice proper risk management and test the indicator thoroughly to ensure it aligns with your trading strategy. Past performance is not indicative of future results.
Trade smarter with TradeVizion—unlock your trading potential today!
Bjorgum Double Tap█ OVERVIEW
Double Tap is a pattern recognition script aimed at detecting Double Tops and Double Bottoms. Double Tap can be applied to the broker emulator to observe historical results, run as a trading bot for live trade alerts in real time with entry signals, take profit, and stop orders, or to simply detect patterns.
█ CONCEPTS
How Is A Pattern Defined?
Doubles are technical formations that are both reversal patterns and breakout patterns. These formations typically have a distinctive “M” or a “W” shape with price action breaking beyond the neckline formed by the center of the pattern. They can be recognized when a pivot fails to break when tested for a second time and the retracement that follows breaks beyond the key level opposite. This can trap entrants that were playing in the direction of the prior trend. Entries are made on the breakout with a target projected beyond the neckline equal to the height of the pattern.
Pattern Recognition
Patterns are recognized through the use of zig-zag; a method of filtering price action by connecting swing highs and lows in an alternating fashion to establish trend, support and resistance, or derive shapes from price action. The script looks for the highest or lowest point in a given number of bars and updates a list with the values as they form. If the levels are exceeded, the values are updated. If the direction changes and a new significant point is made, a new point is added to the list and the process starts again. Meanwhile, we scan the list of values looking for the distinctive shape to form as previously described.
█ STRATEGY RESULTS
Back Testing
Historical back testing is the most common method to test a strategy due in part to the general ease of gathering quick results. The underlying theory is that any strategy that worked well in the past is likely to work well in the future, and conversely, any strategy that performed poorly in the past is likely to perform poorly in the future. It is easy to poke holes in this theory, however, as for one to accept it as gospel, one would have to assume that future results will match what has come to pass. The randomness of markets may see to it otherwise, so it is important to scrutinize results. Some commonly used methods are to compare to other markets or benchmarks, perform statistical analysis on the results over many iterations and on differing datasets, walk-forward testing, out-of-sample analysis, or a variety of other techniques. There are many ways to interpret the results, so it is important to do research and gain knowledge in the field prior to taking meaningful conclusions from them.
👉 In short, it would be naive to place trust in one good backtest and expect positive results to continue. For this reason, results have been omitted from this publication.
Repainting
Repainting is simply the difference in behaviour of a strategy in real time vs the results calculated on the historical dataset. The strategy, by default, will wait for confirmed signals and is thus designed to not repaint. Waiting for bar close for entires aligns results in the real time data feed to those calculated on historical bars, which contain far less data. By doing this we align the behaviour of the strategy on the 2 data types, which brings significance to the calculated results. To override this behaviour and introduce repainting one can select "Recalculate on every tick" from the properties tab. It is important to note that by doing this alerts may not align with results seen in the strategy tester when the chart is reloaded, and thus to do so is to forgo backtesting and restricts a strategy to forward testing only.
👉 It is possible to use this script as an indicator as opposed to a full strategy by disabling "Use Strategy" in the "Inputs" tab. Basic alerts for detection will be sent when patterns are detected as opposed to complex order syntax. For alerts mid-bar enable "Recalculate on every tick" , and for confirmed signals ensure it is disabled.
█ EXIT ORDERS
Limit and Stop Orders
By default, the strategy will place a stop loss at the invalidation point of the pattern. This point is beyond the pattern high in the case of Double Tops, or beneath the pattern low in the case of Double Bottoms. The target or take profit point is an equal-legs measurement, or 100% of the pattern height in the direction of the pattern bias. Both the stop and the limit level can be adjusted from the user menu as a percentage of the pattern height.
Trailing Stops
Optional from the menu is the implementation of an ATR based trailing stop. The trailing stop is designed to begin when the target projection is reached. From there, the script looks back a user-defined number of bars for the highest or lowest point +/- the ATR value. For tighter stops the user can look back a lesser number of bars, or decrease the ATR multiple. When using either Alertatron or Trading Connector, each change in the trail value will trigger an alert to update the stop order on the exchange to reflect the new trail price. This reduces latency and slippage that can occur when relying on alerts only as real exchange orders fill faster and remain in place in the event of a disruption in communication between your strategy and the exchange, which ensures a higher level of safety.
👉 It is important to note that in the case the trailing stop is enabled, limit orders are excluded from the exit criteria. Rather, the point in time that the limit value is exceeded is the point that the trail begins. As such, this method will exit by stop loss only.
█ ALERTS
Five Built-in 3rd Party Destinations
The following are five options for delivering alerts from Double Tap to live trade execution via third party API solutions or chat bots to share your trades on social media. These destinations can be selected from the input menu and alert syntax will automatically configure in alerts appropriately to manage trades.
Custom JSON
JSON, or JavaScript Object Notation, is a readable format for structuring data. It is used primarily to transmit data between a server and a web application. In regards to this script, this may be a custom intermediary web application designed to catch alerts and interface with an exchange API. The JSON message is a trade map for an application to read equipped with where its been, where its going, targets, stops, quantity; a full diagnostic of the current state and its previous state. A web application could be configured to follow the messages sent in this format and conduct trades in sync with alerts running on the TV server.
Below is an example of a rendered JSON alert:
{
"passphrase": "1234",
"time": "2022-05-01T17:50:05Z",
"ticker": "ETHUSDTPERP",
"plot": {
"stop_price": 2600.15,
"limit_price": 3100.45
},
"strategy": {
"position_size": 0.1,
"order_action": "buy",
"market_position": "long",
"market_position_size": 0,
"prev_market_position": "flat",
"prev_market_position_size": 0
}
}
Trading Connector
Trading Connector is a third party fully autonomous Chrome extension designed to catch alert webhooks from TradingView and interface with MT4/MT5 to execute live trades from your machine. Alerts to Trading Connector are simple; just select the destination from the input drop down menu, set your ticker in the "TC Ticker" box in the "Alert Strings" section and enter your URL in the alert window when configuring your alert.
Alertatron
Alertatron is an automated algo platform for cryptocurrency trading that is designed to automate your trading strategies. Although the platform is currently restricted to crypto, it offers a versatile interface with high flexibility syntax for complex market orders and conditions. To direct alerts to Alertatron, select the platform from the 3rd party drop down, configure your API key in the ”Alertatron Key” box and add your URL in the alert message box when making alerts.
3 Commas
3 Commas is an easy and quick to use click-and-go third party crypto API solution. Alerts are simple without overly complex syntax. Messages are simply pasted into alerts and executed as alerts are triggered. There are 4 boxes at the bottom of the "Inputs" tab where the appropriate messages to be placed. These messages can be copied from 3 Commas after the bots are set up and pasted directly into the settings menu. Remember to select 3 Commas as a destination from the third party drop down and place the appropriate URL in the alert message window.
Discord
Some may wish to share their trades with their friends in a Discord chat via webhook chat bot. Messages are configured to notify of the pattern type with targets and stop values. A bot can be configured through the integration menu in a Discord chat to which you have appropriate access. Select Discord from the 3rd party drop down menu and place your chat bot URL in the alert message window when configuring alerts.
👉 For further information regarding alert setup, refer to the platform specific instructions given by the chosen third party provider.
█ IMPORTANT NOTES
Setting Alerts
For alert messages to be properly delivered on order fills it is necessary to place the following placeholder in the alert message box when creating an alert.
{{strategy.order.alert_message}}
This placeholder will auto-populate the alert message with the appropriate syntax that is designated for the 3rd party selected in the user menu.
Order Sizing and Commissions
The values that are sent in alert messages are populated from live metrics calculated by the strategy. This means that the actual values in the "Properties" tab are used and must be set by the user. The initial capital, order size, commission, etc. are all used in the calculations, so it is important to set these prior to executing live trades. Be sure to set the commission to the values used by the exchange as well.
👉 It is important to understand that the calculations on the account size take place from the beginning of the price history of the strategy. This means that if historical results have inflated or depleted the account size from the beginning of trade history until now, the values sent in alerts will reflect the calculated size based on the inputs in the "Properties" tab. To start fresh, the user must set the date in the "Inputs" tab to the current date as to remove trades from the trade history. Failure to follow this instruction can result in an unexpected order size being sent in the alert.
█ FOR PINECODERS
• With the recent introduction of matrices in Pine, the script utilizes a matrix to track pivot points with the bars they occurred on, while tracking if that pivot has been traded against to prevent duplicate detections after a trade is exited.
• Alert messages are populated with placeholders ; capability that previously was only possible in alertcondition() , but has recently been extended to `strategy.*()` functions for use in the `alert_message` argument. This allows delivery of live trade values to populate in strategy alert messages.
• New arguments have been added to strategy.exit() , which allow differentiated messages to be sent based on whether the exit occurred at the stop or the limit. The new arguments used in this script are `alert_profit` and `alert_loss` to send messages to Discord
FibonacciRetracementHi all!
This library will help you draw Fibonacci retracement levels (zones). The code is from my indicator "Fibonacci retracement" (). You can see that description for more information about the behaviour and example of how to use this library. The code is almost the same with the addition of alerts. If the alert frequency is 'alert.freq_once_per_bar_close' alert messages will be concatenated and have a header saying how many messages it contains (if it's more than 1).
Hope this is of help!
Library "FibonacciRetracement"
ConcateAlerts(context)
Concatenates all alerts from the bar to one string (separated by new lines) and clears alert messages on the current bar.
Parameters:
context (Context)
AddAlert(context, message, unshiftInsteadOfPush)
Parameters:
context (Context)
message (string)
unshiftInsteadOfPush (bool)
Range(context, structure, settings)
Will return values if new levels/zones should be drawn.
Parameters:
context (Context) : The 'Context' for the Fibonacci retracement.
structure (Structure type from mickes/PriceAction/1) : The current 'Structure' from the 'MarketStructure' library.
settings (Settings) : The 'Settings' object for the 'Context'.
Returns: A tuple with the start and end pivot if new zones should be drawn, ' ' otherwise.
DrawAll(context, settings, start, end)
Draws lines and labels for the zone. It will also set the 'Price' value that will be used for absolute positions.
Parameters:
context (Context) : The 'Context' for the Fibonacci retracement.
settings (Settings) : The 'Settings' object for the 'Context'.
start (Pivot type from mickes/PriceAction/1)
end (Pivot type from mickes/PriceAction/1)
AlertActive(context, settings)
Will alert for all zones that are active. If multiple alert messages are added they will be concatenated (separated by a new line) with a header saying how many messages the alert contains.
Parameters:
context (Context) : The 'Context' for the Fibonacci retracement. This contains the zones that will be alerted if price (wick or close according to the settings) enters it.
settings (Settings) : The 'Settings' object for the 'Context'.
TrendlineSettings
Holds all the values for 'TrendlineSettings'.
Fields:
Enabled (series bool) : If the trendline should be visible or not.
Color (series color) : The color of the trendline.
Style (series string) : The style of the trendline (as a string).
GenericZonesSettings
Holds all the values for 'GenericZonesSettings', that will be applicable to all drawn objects.
Fields:
ExtendRight (series bool) : If all lines should extend to the right or not.
Style (series string) : The style of all drawn lines
Reverse (series bool) : If true, all lines will be reversed.
Prices (series bool) : If price levels should be shown or not.
Levels (series bool) : If levels should be shown or not.
LevelsValue (series string) : Either 'Value' or 'Percent'. Defined if value or percentage should be shown.
FontSize (series int) : The for size of the text in labels drawn.
LabelsPosition (series string) : Coul be 'Left', 'Rigth' or 'Adapt'. 'Adapt' will try to adapt the labels position to the prices.
ZoneSettings
Holds all the values for 'ZoneSettings'.
Fields:
Enabled (series bool) : If this zone is enabled or not.
Level (series float) : The level of the zone.
Color (series color) : The color that will be displayed.
Price (series float) : The price of the level. Will be set internally.
Settings
Holds all the values for 'Settings'.
Fields:
PivotLeftLength (series int) : The left length used to find pivots through the 'MarketStructure' library.
PivotRightLength (series int) : The right length used to find pivots through the 'MarketStructure' library.
Trendline (TrendlineSettings) : The settings for the 'Trendline' object.
GenericZonesSettings (GenericZonesSettings) : The setting applicable to all zones.
AlertFrequency (series string) : The frequency for the alerts. If 'alert.freq_once_per_bar_close', alert messages will be concatenated and have a header saying how many messages it contains (if it's more than 1).
AlertPrice (series string) : The price that has to enter a zone. Can be 'Close' (the closing price) or 'Wick' (the whole candle needs to be in the zone).
Zone1 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone2 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone3 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone4 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone5 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone6 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone7 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone8 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone9 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone10 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone11 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone12 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone13 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone14 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone15 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone16 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone17 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone18 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone19 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone20 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone21 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone22 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone23 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Zone24 (ZoneSettings) : The 'ZoneSettings' that represents this zone.
Context
Holds all the values for 'Context'.
Fields:
Lines (array) : All the drawn lines for the current 'Context'.
Labels (array) : All the drawn labels for the current 'Context'.
Boxes (array) : All the drawn boxes for the current 'Context'.
Alerts (array) : All the alert messages on the current tick.
Start (series int) : The start bar index of the current 'Context'.
Easy MA SignalsEasy MA Signals
Overview
Easy MA Signals is a versatile Pine Script indicator designed to help traders visualize moving average (MA) trends, generate buy/sell signals based on crossovers or custom price levels, and enhance chart analysis with volume-based candlestick coloring. Built with flexibility in mind, it supports multiple MA types, crossover options, and customizable signal appearances, making it suitable for traders of all levels. Whether you're a day trader, swing trader, or long-term investor, this indicator provides actionable insights while keeping your charts clean and intuitive.
Configure the Settings
The indicator is divided into three input groups for ease of use:
General Settings:
Candlestick Color Scheme: Choose from 10 volume-based color schemes (e.g., Sapphire Pulse, Emerald Spark) to highlight high/low volume candles. Select “None” for TradingView’s default colors.
Moving Average Length: Set the MA period (default: 20). Adjust for faster (lower values) or slower (higher values) signals.
Moving Average Type: Choose between SMA, EMA, or WMA (default: EMA).
Show Buy/Sell Signals: Enable/disable signal plotting (default: enabled).
Moving Average Crossover: Select a crossover type (e.g., MA vs VWAP, MA vs SMA50) for signals or “None” to disable.
Volume Influence: Adjust how volume impacts candlestick colors (default: 1.2). Higher values make thresholds stricter.
Signal Appearance Settings:
Buy/Sell Signal Shape: Choose shapes like triangles, arrows, or labels for signals.
Buy/Sell Signal Position: Place signals above or below bars.
Buy/Sell Signal Color: Customize colors for better visibility (default: green for buy, red for sell).
Custom Price Alerts:
Custom Buy/Sell Alert Price: Set specific price levels for alerts (default: 0, disabled). Enter a non-zero value to enable.
Set Up Alerts
To receive notifications (e.g., sound, popup, email) when signals or custom price levels are hit:
Click the Alert button (alarm clock icon) in TradingView.
Select Easy MA Signals as the condition and choose one of the four alert types:
MA Crossover Buy Alert: Triggers on MA crossover buy signals.
MA Crossover Sell Alert: Triggers on MA crossover sell signals.
Custom Buy Alert: Triggers when price crosses above the custom buy price.
Custom Sell Alert: Triggers when price crosses below the custom sell price.
Enable Play Sound and select a sound (e.g., “Bell”).
Set the frequency (e.g., Once Per Bar Close for confirmed signals) and create the alert.
Analyze the Chart
Moving Average Line: Displays the selected MA with color changes (green for bullish, red for bearish, gray for neutral) based on price position relative to the MA.
Buy/Sell Signals: Appear as shapes or labels when crossovers or custom price levels are hit.
Candlestick Colors: If a color scheme is selected, candles change color based on volume strength (high, low, or neutral), aiding in trend confirmation.
Why Use Easy MA Signals?
Easy MA Signals is designed to simplify technical analysis while offering advanced customization. It’s ideal for traders who want:
A clear visualization of MA trends and crossovers.
Flexible signal generation based on MA crossovers or custom price levels.
Volume-enhanced candlestick coloring to identify market strength.
Easy-to-use settings with tooltips for beginners and pros alike.
This script is particularly valuable because it combines multiple features into one indicator, reducing chart clutter and providing actionable insights without overwhelming the user.
Benefits of Easy MA Signals
Highly Customizable: Supports SMA, EMA, and WMA with adjustable lengths.
Offers multiple crossover options (VWAP, SMA10, SMA20, etc.) for tailored strategies.
Custom price alerts allow precise targeting of key levels.
Volume-Based Candlestick Coloring: 10 unique color schemes highlight volume strength, helping traders confirm trends.
Adjustable volume influence ensures adaptability to different markets.
Flexible Signal Visualization: Choose from various signal shapes (triangles, arrows, labels) and positions (above/below bars).
Customizable colors improve visibility on any chart background.
Alert Integration: Built-in alert conditions for crossovers and custom prices support sound, email, and app notifications.
Easy setup for real-time trading decisions.
User-Friendly Design: Organized input groups with clear tooltips make configuration intuitive.
Suitable for beginners and advanced traders alike.
Example Use Cases
Swing Trading with MA Crossovers:
Scenario: A trader wants to trade Bitcoin (BTC/USD) on a 4-hour chart using an EMA crossover strategy.
Setup:
Set Moving Average Type to EMA, Length to 20.
Set Moving Average Crossover to “MA vs SMA50”.
Enable Show Buy/Sell Signals and choose “arrowup” for buy, “arrowdown” for sell.
Select “Emerald Spark” for candlestick colors to highlight volume surges.
Usage: Buy when the EMA20 crosses above the SMA50 (green arrow appears) and volume is high (dark green candles). Sell when the EMA20 crosses below the SMA50 (red arrow). Set alerts for real-time notifications.
Scalping with Custom Price Alerts:
Scenario: A day trader monitors Tesla (TSLA) on a 5-minute chart and wants alerts at specific support/resistance levels.
Setup:
Set Custom Buy Alert Price to 150.00 (support) and Custom Sell Alert Price to 160.00 (resistance).
Use “labelup” for buy signals and “labeldown” for sell signals.
Keep Moving Average Crossover as “None” to focus on price alerts.
Usage: Receive a sound alert and label when TSLA crosses 150.00 (buy) or 160.00 (sell). Use volume-colored candles to confirm momentum before entering trades.
When NOT to Use Easy MA Signals
High-Frequency Trading: Reason: The indicator relies on moving averages and volume, which may lag in ultra-fast markets (e.g., sub-second trades). High-frequency traders may need specialized tools with real-time tick data.
Alternative: Use order book or market depth indicators for faster execution.
Low-Volatility or Sideways Markets:
Reason: MA crossovers and custom price alerts can generate false signals in choppy, range-bound markets, leading to whipsaws.
Alternative: Use oscillators like RSI or Bollinger Bands to trade within ranges.
This indicator is tailored more towards less experienced traders. And as always, paper trade until you are comfortable with how this works if you're unfamiliar with trading! We hope you enjoy this and have great success. Thanks for your interested in Easy MA Signals!
WillStop Pro [tradeviZion]WillStop Pro : A Step-by-Step Guide for Beginners to Master Trend Trading
Welcome to an in-depth guide to the WillStop Pro indicator. This article will walk you through the key features, how to use them effectively, and how this tool can help you navigate the markets confidently. WillStop Pro is based on principles established by Larry Williams, a well-known figure in trading, and aims to help you manage trades more effectively without overcomplicating things.
This guide will help you understand the basics of the WillStop Pro indicator, how to interpret its signals, and how to use it step-by-step to manage risk and identify opportunities in your trading journey. We will also cover the underlying logic and calculations for advanced users interested in more details.
What is the WillStop Pro Indicator?
The WillStop Pro indicator is a user-friendly tool that helps traders establish stop levels dynamically. It helps you figure out optimal points to enter or exit trades, while managing risk effectively during changing market conditions. The indicator tracks trending markets and sets price levels as stops for ongoing trades, making it suitable both for deciding when to enter and exit trades.
The indicator is beginner-friendly because it simplifies complex calculations and presents the results visually. This allows traders to focus more on their decision-making process instead of spending time with complex analysis.
WillStop Pro adapts to different market conditions, whether you're trading stocks, forex, commodities, or cryptocurrencies. It adjusts stop levels dynamically based on current market momentum, providing a practical way to manage both risk and reward.
Another significant benefit of WillStop Pro is that it works well with other indicators. Beginners can use it on its own or combine it with other tools like moving averages or oscillators to form a comprehensive trading strategy. Whether you are trading daily or looking at longer-term trends, WillStop Pro helps you manage your trades effectively.
Key Features of WillStop Pro
Dynamic Stop Levels : WillStop Pro calculates real-time stop levels for both long (buy) and short (sell) positions. This helps you protect your profits and reduce risk. The stop levels adjust based on the current market environment, making them more adaptable compared to fixed stop levels.
Advanced Stop Settings : There are optional settings to make the stop calculations more advanced, which take into consideration previous price movements to refine where the stops should be placed. These settings provide more precise control over your trades.
Break Signals and Alerts : The indicator provides visual signals, like arrows, to show when a stop level has been broken. This makes it easier for you to identify possible reversals and understand when the market direction is changing.
Comprehensive Table Display : A small table on the chart shows the current trend, the stop level, and whether advanced mode is active. This simple display provides an overview of the market, making decision-making easier.
Based on Larry Williams' Methodology : WillStop Pro builds upon Larry Williams' ideas, which are designed to capture major market trends while managing risk effectively. It provides a systematic way to follow these strategies without requiring deep technical analysis skills.
How Are Stop Levels Calculated? (For Advanced Users)
The WillStop Pro indicator determines stop levels by evaluating highs, lows, and closing prices over a specific lookback period. It uses this information to identify key points that justify adjusting your stop level, and there are separate approaches for both long and short positions.
Below, we explain the mathematical logic behind the stop calculations, along with some code snippets to give advanced users a clearer understanding.
For Long Stops (buy positions): The indicator looks for the highest closing price within the lookback period and continues until it finds three valid bars that meet certain criteria. Stops are adjusted to skip bars that have consecutive upward closes to ensure that the stop is placed at a level that offers solid support. Specifically, the function iterates over recent bars to determine the highest closing value, and checks for specific conditions before finalizing the stop level. Here is an excerpt of the relevant code:
getTrueLow(idx) => math.min(low , close )
findStopLevels() =>
float highestClose = close
int highestCloseIndex = 0
for i = 0 to lookback
if close > highestClose
highestClose := close
highestCloseIndex := i
// Logic to adjust based on up close skipping
int longCount = 0
int longCurrentIndex = highestCloseIndex
while longCount < 3 and longCurrentIndex < 100
if not isInsideBar(longCurrentIndex)
longCount += 1
longCurrentIndex += 1
// Determine the lowest low for the stop level
float longStopLevel = high * 2
for i = searchIndex to highestCloseIndex
longStopLevel := math.min(longStopLevel, getTrueLow(i))
// Apply offset
longStopLevel := longStopLevel - (offsetTicks * tickSize)
In this code snippet, the function findStopLevels() calculates the long stop level by first identifying the highest close within the lookback period and then finding a suitable support level while skipping certain conditions, such as inside bars or consecutive upward closes. Finally, the user-defined offset ( offsetTicks ) is applied to determine the stop level.
For Short Stops (sell positions): Similarly, the indicator finds the lowest closing price within the lookback period and then identifies three bars that fit the conditions for a short stop. It avoids using bars with consecutive down closes to help find a more robust resistance level. Here's a relevant code snippet:
getTrueHigh(idx) => math.max(high , close )
findStopLevels() =>
float lowestClose = close
int lowestCloseIndex = 0
for i = 0 to lookback
if close < lowestClose
lowestClose := close
lowestCloseIndex := i
// Logic to adjust based on down close skipping
int shortCount = 0
int shortCurrentIndex = lowestCloseIndex
while shortCount < 3 and shortCurrentIndex < 100
if not isInsideBar(shortCurrentIndex)
shortCount += 1
shortCurrentIndex += 1
// Determine the highest high for the stop level
float shortStopLevel = 0
for i = searchIndex to lowestCloseIndex
shortStopLevel := math.max(shortStopLevel, getTrueHigh(i))
// Apply offset
shortStopLevel := shortStopLevel + (offsetTicks * tickSize)
Here, findStopLevels() calculates the short stop level by finding the lowest closing price within the lookback period. It then determines the highest value that acts as a resistance level, excluding bars that do not fit certain criteria.
Volume Confirmation for Alert Accuracy : To further enhance the stop level accuracy, volume is used as a confirmation filter. The average volume (volAvg) is calculated over a 20-period moving average, and alerts are only generated if the volume exceeds a defined threshold (volMultiplier). This ensures that price movements are significant enough to consider as meaningful signals.
volAvg = ta.sma(volume, 20)
isVolumeConfirmed() =>
result = requireVolumeConfirmation ? volume > (volAvg * volMultiplier) : true
result
This additional logic ensures that stop level breaks or adjustments are not triggered during periods of low trading activity, thus enhancing the reliability of the generated signals.
These calculations are at the core of WillStop Pro's ability to determine dynamic stop levels that respond effectively to market movements, helping traders manage risk by placing stops at levels that make sense given historical price and volume data.
How to Identify Opportunities with WillStop Pro
WillStop Pro provides various signals that help you decide when to enter or exit a trade:
When a Stop Level is Broken: If a stop level (support for long positions or resistance for short positions) is broken, it may indicate a reversal. WillStop Pro visually plots arrows whenever a stop level is breached, making it easy for you to see where changes might occur. This feature helps traders identify momentum shifts quickly.
Support and Resistance Levels: The indicator plots support and resistance levels, which show key zones to watch for opportunities. These levels often act as psychological barriers in the market, where price action may either reverse or stall temporarily.
Dynamic State Management: The indicator shifts between long and short states based on price action, providing real-time feedback. This helps traders stick to their trading plan without second-guessing the market.
A major advantage of WillStop Pro is that it responds well to changing market conditions. By identifying when key support or resistance levels break, it allows you to adjust your strategies and react to new opportunities accordingly. Whether the market is trending strongly or staying within a range, WillStop Pro provides valuable information to help guide your trades.
Setting Up Alerts
Alerts are an important feature in trading, especially when you can’t be in front of your charts all the time. WillStop Pro has been enhanced to include flexible alert settings to help you stay on top of your trades without constantly monitoring the charts.
Enable Alerts: There is a master switch to enable or disable all alerts. This way, you can control whether you want to be notified of events at any time.
Alert Frequency: Choose between receiving alerts Once Per Bar or Once Per Bar Close . This helps you manage the frequency of alerts and decide if you need real-time updates or want confirmation after a bar closes.
Break Alerts: These alerts notify you when a stop level has been broken. This can help you catch potential reversals or trading opportunities as soon as they happen.
Strong Break Alerts: Alerts are available for strong breaks, which occur when the price breaks stop levels with confirmation based on additional price, volume, and momentum criteria. These alerts help identify significant shifts in the market.
Level Change Alerts: These alerts tell you whenever a new stop level is calculated, keeping you updated about changes in market dynamics. You can set a Minimum Level Change % to ensure that alerts are only triggered when the stop level changes significantly.
Require Volume Confirmation: You can opt to receive alerts only if the volume is above a certain threshold. This confirmation helps reduce false signals by ensuring that significant price changes are backed by increased trading activity.
Volume Multiplier: The volume multiplier allows you to set a minimum volume requirement that must be met for an alert to trigger. This ensures that alerts are triggered only when there is sufficient trading interest.
Here is a part of the updated alert logic that has been implemented in the indicator:
// Alert on break conditions
if alertsEnabled
if alertOnBreaks
if longStopBroken and isVolumeConfirmed()
alert(createAlertMessage("Support Break - Short Signal", useAdvancedStops), alertFreq)
if shortStopBroken and isVolumeConfirmed()
alert(createAlertMessage("Resistance Break - Long Signal", useAdvancedStops), alertFreq)
// Strong break alerts
if alertOnStrongBreaks
if longStopBroken and isStrongBreak(false)
alert(createAlertMessage("Strong Support Break - Short Signal", useAdvancedStops), alertFreq)
if shortStopBroken and isStrongBreak(true)
alert(createAlertMessage("Strong Resistance Break - Long Signal", useAdvancedStops), alertFreq)
// Level change alerts
if alertOnLevelChanges and isSignificantChange() and isVolumeConfirmed()
alert(createAlertMessage("Significant Level Change", useAdvancedStops), alertFreq)
Setting alerts allows you to react to market changes without having to watch the charts constantly. Alerts are particularly helpful if you have other responsibilities and can’t be actively monitoring your trades all day.
Understanding the Table Display
The WillStop Pro indicator provides a status table that gives an overview of the current market state. Here’s what the table shows:
Indicator Status: The table indicates whether the indicator is in a LONG or SHORT state. This helps you quickly understand the market trend.
Stop Level: The active stop level is shown, whether it is acting as support (long) or resistance (short). This is important for knowing where to set your protective stops.
Mode: The table also displays whether the advanced calculation mode is being used. This keeps you informed about how stop levels are being calculated and why they are positioned where they are.
Empowering Messages: The table also includes motivational messages that rotate periodically, such as 'Trade with Clarity, Stop with Precision' and 'Let Winners Run, Cut Losses Short.' These messages are designed to keep you focused, motivated, and disciplined during your trading journey.
The table is simple and easy to follow, helping you maintain discipline in your trading plan. By having all the essential information in one place, the table reduces the need to make quick, emotional decisions and promotes more thoughtful analysis.
Tips for Using WillStop Pro Effectively
Here are some practical ways to make the most of the WillStop Pro indicator:
Start with Default Settings: If you’re new to the indicator, start with the default settings. This will give you an idea of how stop levels are determined and how they adjust to different markets.
Experiment with Advanced Settings: Once you are comfortable, try using the advanced stop settings to see how they refine the stop levels. This can be useful in certain market conditions to improve accuracy.
Use Alerts to Stay Updated: Set up alerts for when a stop level is broken or when new levels are calculated. This helps you take action without constantly watching the chart. Swing traders may find alerts especially helpful for monitoring longer-term moves.
Monitor the Status Table: Keep an eye on the status table to understand the current market condition. Whether the indicator is in a LONG or SHORT state can help you make more informed decisions.
Focus on Risk Management: WillStop Pro is designed to help you manage risk by dynamically adjusting stop levels. Make sure you are using these levels to protect your trades, especially during strong trends or volatile periods.
Acknowledging Larry Williams' Influence
WillStop Pro is inspired by the work of Larry Williams, who described the approach as one of his best trading techniques. His method aims to ride major market trends while reducing the risk of giving back gains during corrections. WillStop Pro builds upon this approach, adding features like advanced stop settings and visual alerts that make it easier to apply in modern markets.
By using WillStop Pro, you are essentially leveraging a well-established trading strategy with additional tools that help improve its effectiveness. The indicator is designed to provide a reliable way to manage trades, stay on top of market conditions, and reduce emotional decision-making.
Conclusion: Why WillStop Pro is Great for Beginners and Advanced Users
The WillStop Pro is a powerful yet easy-to-use tool that helps traders ride trends while managing risk during market corrections. It can be used both for entering and exiting trades, and its visual features make it accessible for those who are new to trading, while the underlying logic appeals to advanced users seeking greater control and understanding.
WillStop Pro is more than just a tool for setting stops. It is a comprehensive solution for managing trades, with features like dynamic stop levels, customizable alerts, and an easy-to-understand status table. This combination of simplicity and advanced features makes it suitable for beginners as well as more experienced traders.
We hope this guide helps you get started with WillStop Pro and improves your trading confidence. Remember to start with the basics, explore the advanced features, and set alerts to stay informed without getting overwhelmed. Whether you’re just beginning or want to simplify your strategy, WillStop Pro is a valuable tool to have in your trading arsenal.
Trading can be challenging, but the right tools make it more manageable. WillStop Pro helps you keep track of market movements, identify opportunities, and manage risk effectively. Give it a try and see how it can improve your trading decisions and help you navigate the markets more efficiently.
By incorporating WillStop Pro into your strategy, you are following a systematic approach that has been refined over time. It’s designed to help you make sense of the markets, plan your trades, and manage your risks with greater clarity and confidence.
Note: Always practice proper risk management and thoroughly test the indicator to ensure it aligns with your trading strategy. Past performance is not indicative of future results.
Trade smarter with TradeVizion—unlock your trading potential today!
Uptrick: DPO Signal & Zone Indicator
## **Uptrick: DPO Signal & Zone Indicator**
### **Introduction:**
The **Uptrick: DPO Signal & Zone Indicator** is a sophisticated technical analysis tool tailored to provide insights into market momentum, identify potential trading signals, and recognize extreme market conditions. It leverages the Detrended Price Oscillator (DPO) to strip out long-term trends from price movements, allowing traders to focus on short-term fluctuations and cyclical behavior. The indicator integrates multiple components, including a Detrended Price Oscillator, a Signal Line, a Histogram, and customizable alert levels, to deliver a robust framework for market analysis and trading decision-making.
### **Detailed Breakdown:**
#### **1. Detrended Price Oscillator (DPO):**
- **Purpose and Functionality:**
- The DPO is designed to filter out long-term trends from the price data, isolating short-term price movements. This helps in understanding the cyclical patterns and momentum of an asset, allowing traders to detect periods of acceleration or deceleration that might be overlooked when focusing solely on long-term trends.
- **Calculation:**
- **Formula:** `dpo = close - ta.sma(close, smaLength)`
- **`close`:** The asset’s closing price for each period in the dataset.
- **`ta.sma(close, smaLength)`:** The Simple Moving Average (SMA) of the closing prices over a period defined by `smaLength`.
- The DPO is derived by subtracting the SMA value from the current closing price. This calculation reveals how much the current price deviates from the moving average, effectively detrending the price data.
- **Interpretation:**
- **Positive DPO Values:** Indicate that the current price is higher than the moving average, suggesting bullish market conditions and a potential upward trend.
- **Negative DPO Values:** Indicate that the current price is lower than the moving average, suggesting bearish market conditions and a potential downward trend.
- **Magnitude of DPO:** Reflects the strength of momentum. Larger positive or negative values suggest stronger momentum in the respective direction.
#### **2. Signal Line:**
- **Purpose and Functionality:**
- The Signal Line is a smoothed average of the DPO, intended to act as a reference point for generating trading signals. It helps to filter out short-term fluctuations and provides a clearer perspective on the prevailing trend.
- **Calculation:**
- **Formula:** `signalLine = ta.sma(dpo, signalLength)`
- **`ta.sma(dpo, signalLength)`:** The SMA of the DPO values over a period defined by `signalLength`.
- The Signal Line is calculated by applying a moving average to the DPO values. This smoothing process reduces noise and highlights the underlying trend direction.
- **Interpretation:**
- **DPO Crossing Above Signal Line:** Generates a buy signal, suggesting that short-term momentum is turning bullish relative to the longer-term trend.
- **DPO Crossing Below Signal Line:** Generates a sell signal, suggesting that short-term momentum is turning bearish relative to the longer-term trend.
- **Signal Line’s Role:** Provides a benchmark for assessing the strength of the DPO. The interaction between the DPO and the Signal Line offers actionable insights into potential entry or exit points.
#### **3. Histogram:**
- **Purpose and Functionality:**
- The Histogram visualizes the difference between the DPO and the Signal Line. It provides a graphical representation of momentum strength and direction, allowing traders to quickly gauge market conditions.
- **Calculation:**
- **Formula:** `histogram = dpo - signalLine`
- The Histogram is computed by subtracting the Signal Line value from the DPO value. Positive values indicate that the DPO is above the Signal Line, while negative values indicate that the DPO is below the Signal Line.
- **Interpretation:**
- **Color Coding:**
- **Green Bars:** Represent positive values, indicating bullish momentum.
- **Red Bars:** Represent negative values, indicating bearish momentum.
- **Width of Bars:** Indicates the strength of momentum. Wider bars signify stronger momentum, while narrower bars suggest weaker momentum.
- **Zero Line:** A horizontal gray line that separates positive and negative histogram values. Crosses of the histogram through this zero line can signal shifts in momentum direction.
#### **4. Alert Levels:**
- **Purpose and Functionality:**
- Alert levels define specific thresholds to identify extreme market conditions, such as overbought and oversold states. These levels help traders recognize potential reversal points and extreme market conditions.
- **Inputs:**
- **`alertLevel1`:** Defines the upper threshold for identifying overbought conditions.
- **Default Value:** 0.5
- **`alertLevel2`:** Defines the lower threshold for identifying oversold conditions.
- **Default Value:** -0.5
- **Interpretation:**
- **Overbought Condition:** When the DPO exceeds `alertLevel1`, indicating that the market may be overbought. This condition suggests that the asset could be due for a correction or reversal.
- **Oversold Condition:** When the DPO falls below `alertLevel2`, indicating that the market may be oversold. This condition suggests that the asset could be poised for a rebound or reversal.
#### **5. Visual Elements:**
- **DPO and Signal Line Plots:**
- **DPO Plot:**
- **Color:** Blue
- **Width:** 2 pixels
- **Purpose:** To visually represent the deviation of the current price from the moving average.
- **Signal Line Plot:**
- **Color:** Red
- **Width:** 1 pixel
- **Purpose:** To provide a smoothed reference for the DPO and generate trading signals.
- **Histogram Plot:**
- **Color Coding:**
- **Green:** For positive values, signaling bullish momentum.
- **Red:** For negative values, signaling bearish momentum.
- **Style:** Histogram bars are displayed with varying width to represent the strength of momentum.
- **Zero Line:** A gray horizontal line separating positive and negative histogram values.
- **Overbought/Oversold Zones:**
- **Background Colors:**
- **Green Shading:** Applied when the DPO exceeds `alertLevel1`, indicating an overbought condition.
- **Red Shading:** Applied when the DPO falls below `alertLevel2`, indicating an oversold condition.
- **Horizontal Lines:**
- **Dotted Green Line:** At `alertLevel1`, marking the upper alert threshold.
- **Dotted Red Line:** At `alertLevel2`, marking the lower alert threshold.
- **Purpose:** To provide clear visual cues for extreme market conditions, aiding in the identification of potential reversal points.
#### **6. Trading Signals and Alerts:**
- **Buy Signal:**
- **Trigger:** When the DPO crosses above the Signal Line.
- **Visual Representation:** A "BUY" label appears below the price bar in the specified buy color.
- **Purpose:** Indicates a potential buying opportunity as short-term momentum turns bullish.
- **Sell Signal:**
- **Trigger:** When the DPO crosses below the Signal Line.
- **Visual Representation:** A "SELL" label appears above the price bar in the specified sell color.
- **Purpose:** Indicates a potential selling opportunity as short-term momentum turns bearish.
- **Overbought/Oversold Alerts:**
- **Overbought Alert:** Triggered when the DPO crosses below `alertLevel1`.
- **Oversold Alert:** Triggered when the DPO crosses above `alertLevel2`.
- **Visual Representation:** Labels "OVERBOUGHT" and "OVERSOLD" appear with distinctive colors and sizes to highlight extreme conditions.
- **Purpose:** To signal potential reversal points and extreme market conditions that may lead to price corrections or trend reversals.
- **Alert Conditions:**
- **DPO Cross Above Signal Line:** Alerts traders when the DPO crosses above the Signal Line, generating a buy signal.
- **DPO Cross Below Signal Line:** Alerts traders when the DPO crosses below the Signal Line, generating a sell signal.
- **DPO Above Upper Alert Level:** Alerts when the DPO is above `alertLevel1`, indicating an overbought condition.
- **DPO Below Lower Alert Level:** Alerts when the DPO is below `alertLevel2`, indicating an oversold condition.
- **Purpose:** To provide real-time notifications of significant market events, enabling traders to make informed decisions promptly.
### **Practical Applications:**
#### **1. Trend Following Strategies:**
- **Objective:**
- To capture and ride the prevailing market trends by entering trades that align with the direction of the momentum.
- **How to Use:**
- Monitor buy and sell signals generated by the DPO crossing the Signal Line. A buy signal suggests a bullish trend and a potential long trade, while a sell signal suggests a bearish trend and a potential short trade.
- Use the Histogram to confirm the strength of the trend. Expanding green bars indicate strong bullish momentum, while expanding red bars indicate strong bearish momentum.
- **Advantages:**
- Helps traders stay aligned with the market trend, increasing the likelihood of capturing substantial price moves.
#### **2. Reversal Trading:**
- **Objective:**
- To identify potential market reversals
by detecting overbought and oversold conditions.
- **How to Use:**
- Look for overbought and oversold signals based on the DPO crossing `alertLevel1` and `alertLevel2`. These conditions suggest that the market may be due for a reversal.
- Confirm reversal signals with the Histogram. A decrease in histogram bars (from green to red or vice versa) may support the reversal hypothesis.
- **Advantages:**
- Provides early warnings of potential market reversals, allowing traders to position themselves before significant price changes occur.
#### **3. Momentum Analysis:**
- **Objective:**
- To gauge the strength and direction of market momentum for making informed trading decisions.
- **How to Use:**
- Analyze the Histogram to assess momentum strength. Positive and expanding histogram bars indicate increasing bullish momentum, while negative and expanding bars suggest increasing bearish momentum.
- Use momentum insights to validate or question existing trading positions and strategies.
- **Advantages:**
- Offers valuable information about the market's momentum, helping traders confirm the validity of trends and trading signals.
### **Customization and Flexibility:**
The **Uptrick: DPO Signal & Zone Indicator** offers extensive customization options to accommodate diverse trading preferences and market conditions:
- **SMA Length and Signal Line Length:**
- Adjust the `smaLength` and `signalLength` parameters to control the sensitivity and responsiveness of the DPO and Signal Line. Shorter lengths make the indicator more responsive to price changes, while longer lengths provide smoother, less volatile signals.
- **Alert Levels:**
- Modify `alertLevel1` and `alertLevel2` to fit varying market conditions and volatility. Setting these levels appropriately helps tailor the indicator to different asset classes and trading strategies.
- **Color and Shape Customization:**
- Customize the colors and sizes of buy/sell signals, histogram bars, and alert levels to enhance visual clarity and align with personal preferences. This customization helps ensure that the indicator integrates seamlessly with a trader's charting setup.
### **Conclusion:**
The **Uptrick: DPO Signal & Zone Indicator** is a multifaceted analytical tool that combines the power of the Detrended Price Oscillator with customizable visual elements and alert levels to deliver a comprehensive approach to market analysis. By offering insights into momentum strength, trend direction, and potential reversal points, this indicator equips traders with valuable information to make informed decisions and enhance their trading strategies. Its flexibility and customization options ensure that it can be adapted to various trading styles and market conditions, making it a versatile addition to any trader's toolkit.
MACD All In One Screener [ChartPrime]INTRODUCTION
MACD All In One Screener (ChartPrime) is a multi instrument, multi timeframe indicator designed to provide traders with a comprehensive solution to monitoring the market. This indicator is designed to be easy to use and visually appealing while also being highly flexible and feature rich. Users can pick up to 10 symbols not including the chart's symbol and set up alerts for many different signals that the MACD produces. One standout feature of this indicator is its ability to display not only each symbol individually as a MACD but you can also view its chart from within this indicator. This removes the need to flip between symbols to see the price action for your basket.
On top of that we have designed this indicator to be friendly with "indicator on indicator" by providing outputs for all of the standards of price that users may want. Included is an overview section that shows all of the symbols signals symbolically over time. Additionally we have included a table for easy monitoring. This table includes the symbol, its timeframe, the current alert, and its histogram state. To make things as user friendly as possible we have also included rich error handling that tells you exactly what is wrong with your configuration.
HOW TO USE
To use this indicator, simply add it to your chart and navigate to the settings. From there select the symbols you want to monitor and the timeframes you want to use. Next you want to navigate down to the alerts section to select the what alerts you want to receive, and what symbols you want to get alerts for. Finally, you wan to create your alert using "Any alert() function call". Now your screener is all set up!
OVERVIEW OF INPUTS
View allows you to select what the indicator currently displays. You can pick from any one of the selected symbols, an overview of all of the symbols, or simply nothing. If you want to only use the table, "None" is provided so you can move the indicator into the chart panel.
View Toggle lets you pick from displaying the MACD for the selected symbol or the Price Action as a candle chart. To see your "indicator on indicator" you will have to select a symbol from the view list. There is a bug where if you select "Overview" while you are using "indicator on indicator" your added indicator will see the last symbol you viewed. To fix this, simply change the setting of your overlaid indicator and it will correct its self.
History Length is the number of historical bars to calculate over. This feature is here to prevent the indicator from breaking due to uneven historical data between the symbols.
Show Price Line toggles a dotted line that follows the current symbols closing price when "Price" is selected under the "View Toggle" dropdown.
Show Symbol Label toggles a label that displays the current symbols name and timeframe. This only impacts the single symbol view.
Overview Label Color adjusts the color of the symbol labels for both overview and single symbol view.
MA Type lets you pick what kind of moving average you want to use for the oscillator or signal. You can pick from the standard SMA or EMA.
Fast Length is a standard input for MACD. This lets you pick the period of the fast MA.
Slow Length , just like Fast Lenght, is a standard input for MACD. This lets you pick the period of the slow MA.
Signal Length is another standard input for MACD. This lets you configure the period of the signal MA.
MACD Cross Overlay Icon is a toggle to display MACD crosses when viewing a single symbol's MACD. When the MACD has a bullish cross it will plot a bullish dot, and when it has a bearish cross it will plot a bearish dot. This is purely visual.
Regular Bullish and Bearish toggles the visual display of the divergences on the single symbol view. This does not effect the indicators ability do send alerts.
Divergence Look Right adjusts the number of bars into the future to look for confirmation of a signal. This directly impacts lag but enhances stability.
Divergence Look Left adjusts the number of bars into the past to check for a signal. A longer period will filter out smaller moves
Maximum Lookback adjusts the maximum size of a divergence.
Minimum Lookback adjusts the minimum size of a divergence.
Divergence Drawings picks how you want to visualize the divergence. You can pick from displaying it as a line, a label, or both.
Enable Table toggles the overview table. When enabled it will show you the enabled symbols and their current state. From left to right: symbol name, timeframe, current alert, and histogram state.
Position picks where on the chart you want the table to be.
Text Color adjusts the text color of the table.
BG Color adjusts the background color of the table.
Frame Color adjust the frame color of the table.
Current Symbol Time Frame adjusts the timeframe of the chart's symbol.
Symbol 1 - 10 pick "Symbol's" symbol and timeframe. To use higher timeframes, the symbol's have to be the same type. You can't have a crypto and a stock using HTF at the same time as they don't have the same sessions and will result in an error. You can use unsafe mode (as described below) to potentially get around this.
Enable Symbol when enabled it will give you alerts for the symbol. This also enables the symbol in the overview. If this is disabled it won't send alerts, and it will not show up in overview, or the table.
Wait for Close enables waiting for the bar to close before printing an alert.
Alert Symbol Size picks what size you want the overview symbols to be.
Enable Cross Over 0 Alert: MACD crosses over the 0 line.
Enable Cross Under 0 Alert: MACD crosses under the 0 line.
Enable MACD Cross Bullish Alert: Bullish MACD cross.
Enable MACD Cross Bearish Alert: Bearish MACD cross.
Enable Histogram Bullish Turn Alert: MACD begins to turn bullish but hasn't crossed.
Enable Histogram Bearish Turn Alert: MACD begins to turn bearish but hasn't crossed.
Enable Histogram Bullish Continuation Alert: MACD is in a bullish cross state and it was declining but began rising again.
Enable Histogram Bearish Continuation Alert: MACD is in a bearish cross state and it was rising but began falling again.
Enable Bullish/Bearish Divergence Alert enables divergence alerts. Divergences are lagging, especially on a higher timeframe. These alerts will also tell you the time in the past when the divergence occurred.
Color Section is provided to allow for personalization of the indicator. Everything can be adjusted here.
Disable Error Checking: Only enable this if you want to bypass the built in error checking. This will enable 'Safe Requesting'. Safe Requesting will only request enabled symbols and you will not be able to view symbols that are not enabled in this mode. Only use this if you want to mix symbol types and you know it will work. (An example would be viewing stocks and SPY at the same time.)
CONCLUSION
The MACD All In One Screener (ChartPrime) is a versatile indicator designed to monitor multiple symbols across various timeframes. The flexibility in customization, from MACD settings to visual alerts and table presentations, allows users to tailor the screener to their needs and preferences. We hope you find this as useful and interesting as we do and wish you good luck in the market!
Enjoy
