Indicators and strategies
Mickey's BBMickey's BB – Smart Reversal Detector with SL Tracking 🔁
This indicator combines the power of Bollinger Bands with engulfing candle patterns to identify high-probability reversal points.
✅ Buy Signal: Triggered when a red candle touches the lower Bollinger Band and is engulfed by a green candle within the next few candles.
✅ Sell Signal: Triggered when a green candle touches the upper Bollinger Band and is engulfed by a red candle within the next few candles.
✅ Smart Lookahead: Scans up to X candles ahead (user-defined) to confirm engulfing reversals — reducing noise in sideways markets.
✅ Dynamic Stop-Loss & Target: Automatically plots SL/TP levels based on user-defined % thresholds.
✅ SL HIT Labels: Highlights exactly when a stop-loss is breached, giving clear visual feedback on trade failures.
✅ Adaptive Market Filter: Signals are only shown when Bollinger Band width exceeds a minimum threshold — filtering out weak/noise signals in low volatility.
🔍 Ideal for reversal traders, scalpers, and those who love combining price action with volatility-based setups.
🛠️ Customizable Parameters:
SMA Period & Std Dev Multiplier (for BB)
SL/Target % levels
Engulf Lookahead range
Minimum BB width to filter signals
🎯 Build it into your strategy, set alerts, or just use it visually to time your entries and exits with clarity.
Scalping Strategy Pro | Supertrend + VWAP + RSIDashboard Features:
Current Signal (BUY / SELL / No Trade)
Entry Price, Stop Loss, Take Profit
Real-time Risk:Reward ratio
Signal color highlight (green for buy, red for sell)
Responsive & clean layout for mobile or PC
Prev days openLabels are offset to the right of Lines
You can adjust the number of opens back to display
If you want to change the format of the label please read the tool tip
Original FrizLabz
Prev days openLabels are offset to the right of Lines
You can adjust the number of opens back to display
If you want to change the format of the label please read the tool tip
Original FrizLabz
Momentum Shift [Bigbeluga]
This indicator identifies momentum shifts using a smoothed momentum calculation. It plots dynamic shift zones consisting of five levels that expand or contract based on price action. When momentum rises, the indicator creates an upward shift zone, and when momentum falls, it generates a downward shift zone. The shift zones dynamically react to price, stopping extension when a level is crossed.
🔵Key Features:
Smoothed Momentum Calculation:
➣ Utilizes a Hull Moving Average (HMA) to smooth momentum and reduce noise.
➣ Identifies momentum shifts with crossovers between the current momentum value and its previous state.
➣ Uses a gradient color scheme to highlight momentum strength.
Dynamic Shift Zones:
➣ When momentum rises, the indicator plots an upper shift zone with five incremental levels.
➣ When momentum falls, a lower shift zone is formed with five descending levels.
➣ Each level within the shift zone represents a progressively stronger momentum shift.
Level Extension Control:
➣ Shift zones stop extending once a level is crossed by price.
➣ Levels closer to price act as key momentum resistance or support zones.
➣ If price retraces after a shift, the remaining levels stay intact for further reference.
Momentum Direction Indications:
➣ Labels (▲ and ▼) appear at momentum shift points to indicate rising or falling momentum.
🔵Usage:
Momentum-Based Entries: Identify momentum shifts early by using shift zones as confirmation for trade entries.
Trend Continuation & Exhaustion: Observe which shift levels price respects—if momentum shift zones hold, the trend may continue; if they break, momentum may reverse.
Dynamic Support & Resistance: Use the five-level shift zones as temporary support and resistance areas that adapt to momentum shifts.
Momentum Strength Analysis: If price moves through multiple shift levels in one direction, it signals strong momentum in that direction.
Momentum Shift is a powerful tool for traders looking to analyze momentum shifts with structured visual zones. By combining smoothed momentum calculations with dynamic shift zones, this indicator provides a clear view of market momentum and helps traders navigate price action effectively.
Multi-EMA Crossover StrategyMulti-EMA Crossover Strategy
This strategy uses multiple exponential moving average (EMA) crossovers to identify bullish trends and execute long trades. The approach involves progressively stronger signals as different EMA pairs cross, indicating increasing bullish momentum. Each crossover triggers a long entry, and the intensity of bullish sentiment is reflected in the color of the bars on the chart. Conversely, bearish trends are represented by red bars.
Strategy Logic:
First Long Entry: When the 1-day EMA crosses above the 5-day EMA, it signals initial bullish momentum.
Second Long Entry: When the 3-day EMA crosses above the 10-day EMA, it confirms stronger bullish sentiment.
Third Long Entry: When the 5-day EMA crosses above the 20-day EMA, it indicates further trend strength.
Fourth Long Entry: When the 10-day EMA crosses above the 40-day EMA, it suggests robust long-term bullish momentum.
The bar colors reflect these conditions:
More blue bars indicate stronger bullish sentiment as more short-term EMAs are above their longer-term counterparts.
Red bars represent bearish conditions when short-term EMAs are below longer-term ones.
Example: Bitcoin Trading on a Daily Timeframe
Bullish Scenario:
Imagine Bitcoin is trading at $30,000 on March 31, 2025:
First Signal: The 1-day EMA crosses above the 5-day EMA at $30,000. This suggests initial upward momentum, prompting a small long entry.
Second Signal: A few days later, the 3-day EMA crosses above the 10-day EMA at $31,000. This confirms strengthening bullish sentiment; another long position is added.
Third Signal: The 5-day EMA crosses above the 20-day EMA at $32,500, indicating further upward trend development; a third long entry is executed.
Fourth Signal: Finally, the 10-day EMA crosses above the 40-day EMA at $34,000. This signals robust long-term bullish momentum; a fourth long position is entered.
Bearish Scenario:
Suppose Bitcoin reverses from $34,000 to $28,000:
The 1-day EMA crosses below the 5-day EMA at $33,500.
The 3-day EMA dips below the 10-day EMA at $32,000.
The 5-day EMA falls below the 20-day EMA at $30,000.
The final bearish signal occurs when the 10-day EMA drops below the 40-day EMA at $28,000.
The bars turn increasingly red as bearish conditions strengthen.
Advantages of This Strategy:
Progressive Confirmation: Multiple crossovers provide layered confirmation of trend strength.
Visual Feedback: Bar colors help traders quickly assess market sentiment and adjust positions accordingly.
Flexibility: Suitable for trending markets like Bitcoin during strong rallies or downturns.
Limitations:
Lagging Signals: EMAs are lagging indicators and may react slowly to sudden price changes.
False Breakouts: Crossovers in choppy markets can lead to whipsaws or false signals.
This strategy works best in trending markets and should be combined with additional risk management techniques, e.g., stop loss or optimal position sizes (Kelly Criterion).
Volume > 1.5x 20-Day Avg VolumeI am trying to understand on a 20 period basis if the volume spike is over 1.5 times the average. If this indicator works well the, it shows a triangle whenever the spike in the volume matches the rule.
Multi-Period VWAP30day 90day and 365day vwap
its just a vwap
that anchores 30day before the current day
anchores 90day before current day
anchores 365day before current day
BTC SCALPERS By Anup## *BTC Scalper by Anup – Precision Trading for BTC Scalpers*
🔹 *BTC Scalper by Anup* is a high-accuracy scalping indicator designed specifically for Bitcoin traders. This tool combines multiple confirmations to ensure precise entry and exit points, reducing false signals and improving profitability.
### *🚀 Key Features:*
✅ *EMA Crossover Strategy* – Uses EMA to identify trend reversals.
✅ *ATR Volatility Filter* – Ensures trades are executed only in high-volatility conditions.
✅ *RSI Confirmation* – Prevents overbought/oversold entries by confirming trend strength.
✅ *Stochastic Momentum Check* – Filters weak signals and confirms valid trade setups.
✅ *Buy & Sell Signals* – Clearly marked entries and exits for easy decision-making.
### *📈 How It Works:*
📌 *BUY Signal* – When the EMA crosses above , ATR confirms volatility, RSI is above 50, and Stochastic shows momentum.
📌 *SELL Signal* – When the EMA crosses below , ATR confirms volatility, RSI is below 50, and Stochastic indicates bearish momentum.
🚀 Perfect for *scalpers and day traders* looking for *fast & reliable trade signals* on BTC ONLY!
📍 *Timeframe Recommendation:* Best suited for *M5 to M15 charts* for short-term trades.
🔔 *Try BTC Scalper by Anup and take your BTC trading to the next level!*
BTC SCALPERS By Anup## *BTC Scalper by Anup – Precision Trading for BTC Scalpers*
🔹 *BTC Scalper by Anup* is a high-accuracy scalping indicator designed specifically for Bitcoin traders. This tool combines multiple confirmations to ensure precise entry and exit points, reducing false signals and improving profitability.
### *🚀 Key Features:*
✅ *EMA Crossover Strategy* – Uses * TWO EMA* to identify trend reversals.
✅ *ATR Volatility Filter* – Ensures trades are executed only in high-volatility conditions.
✅ *RSI Confirmation* – Prevents overbought/oversold entries by confirming trend strength.
✅ *Stochastic Momentum Check* – Filters weak signals and confirms valid trade setups.
✅ *Buy & Sell Signals By arrow* – Clearly marked entries and exits for easy decision-making.
### *📈 How It Works:*
📌 *BUY Signal* – When the *EMA to EMA crosses up*, ATR confirms volatility, RSI is above 50, and Stochastic shows momentum.
📌 *SELL Signal* – When the *EMA to ema crosses down*, ATR confirms volatility, RSI is below 50, and Stochastic indicates bearish momentum.
🚀 Perfect for *scalpers and day traders* looking for *fast & reliable trade signals* on BTC only!
📍 *Timeframe Recommendation:* Best suited for *M5 to M15 charts* for short-term trades.
🔔 *Try BTC Scalper by Anup and take your BTC trading to the next level!*
[TABLE] Moving Average Stage Indicator Table📈 MA Stage Indicator Table
🧠 Overview:
This script analyzes market phases based on moving average (MA) crossovers, classifying them into 6 distinct stages and displaying statistical summaries for each.
🔍 Key Features:
• Classifies market condition into Stage 1 to Stage 6 based on the relationship between MA1 (short), MA2 (mid), and MA3 (long)
• Provides detailed stats for each stage:
• Average Duration
• Average Width (MA distance)
• Slope (Angle) - High / Low / Average
• Shows current stage details in real-time
• Supports custom date range filtering
• Choose MA type: SMA or EMA
• Optional background coloring for stages
• Clean summary table displayed on the chart
ATR Probability + MAs + Bollinger Bands PROATR Probability + MAs + Bollinger Bands
Made by DeepSeek))
The Crypto Wizard# The Crypto Wizard (Cwiz)
## Advanced Trading Framework for Cryptocurrency Markets
! (placeholder.com)
The Crypto Wizard (Cwiz) offers a customizable, robust trading framework designed specifically for cryptocurrency market volatility. This open-source foundation provides essential components for building profitable automated trading strategies.
### Key Performance Indicators
| Metric | Value |
|--------|-------|
| Profit Factor | 1.992 |
| Sortino Ratio | 5.589 |
| Win Rate | ~40% |
| Max Drawdown | 15.82% |
### Core Features
- **Position Scaling System**: Intelligent position sizing with customizable multipliers and risk controls
- **Multi-layered Exit Strategy**: Combined take-profit, fixed stop-loss, and trailing stop mechanisms
- **Customizable Entry Framework**: Easily integrate your own entry signals and conditions
- **Comprehensive Visualization Tools**: Real-time performance tracking with position labels and indicators
### Setup Instructions
```pine PHEMEX:FARTCOINUSDT.P
// 1. Add to your chart and configure basic parameters
// 2. Adjust risk parameters based on your risk tolerance
// 3. Customize entry conditions or use defaults
// 4. Back-test across various market conditions
// 5. Enable live trading with careful monitoring
```
### Risk Management
Cwiz implements a sophisticated risk management system with:
- Automatic position size scaling
- User-defined maximum consecutive trades
- ATR-based dynamic stop loss placement
- Built-in circuit breakers for extreme market conditions
### Customization Options
The framework is designed for flexibility without compromising core functionality. Key customization points:
- Entry signal generation
- Position sizing parameters
- Stop loss and take profit multipliers
- Visualization preferences
### Recommended Usage
Best suited for volatile cryptocurrency markets with sufficient liquidity. Performs optimally in trending conditions but includes mechanisms to manage ranging markets.
---
*Disclaimer: Trading involves significant risk. Past performance is not indicative of future results. Always test thoroughly before live deployment.*
Adv EMA Cloud v6 (ADX, Alerts)Summary:
This indicator provides a multi-faceted view of market trends using Exponential Moving Averages (EMAs) arranged in visually intuitive clouds, enhanced with an optional ADX-based range filter and configurable alerts for key market conditions. It aims to help traders quickly gauge trend alignment across short, medium, and long timeframes while filtering signals during potentially choppy market conditions.
Key Features:
Multiple EMAs: Displays 10-period (Fast), 20-period (Mid), and 50-period (Slow) EMAs.
Long-Term Trend Filter: Includes a 200-period EMA to provide context for the overall dominant trend direction.
Dual EMA Clouds:
Fast/Mid Cloud (10/20 EMA): Fills the area between the 10 and 20 EMAs. Defaults to Green when 10 > 20 (bullish short-term momentum) and Red when 10 < 20 (bearish short-term momentum).
Mid/Slow Cloud (20/50 EMA): Fills the area between the 20 and 50 EMAs. Defaults to Aqua when 20 > 50 (bullish mid-term trend) and Fuchsia when 20 < 50 (bearish mid-term trend).
Optional ADX Range Filter: Uses the Average Directional Index (ADX) to identify potentially non-trending or choppy markets. When enabled and ADX falls below a user-defined threshold, the EMA clouds will turn grey, visually warning that trend-following signals may be less reliable.
Configurable Alerts: Provides several built-in alert conditions using Pine Script's alertcondition function:
Confluence Condition: Triggers when a 10/20 EMA crossover occurs while both EMA clouds show alignment (both bullish/green/aqua or both bearish/red/fuchsia) and price respects the 200 EMA filter and the ADX filter indicates a trend (if filters are enabled).
MA Filter Cross: Triggers when price crosses above or below the 200 EMA filter line.
Full Alignment Start: Triggers on the first bar where full bullish or bearish alignment occurs (both clouds aligned + MA filter respected + ADX trending, if filters are enabled).
How It Works:
EMA Calculation: Standard Exponential Moving Averages are calculated for the 10, 20, 50, and 200 periods based on the closing price.
Cloud Creation: The fill() function visually shades the area between the 10 & 20 EMAs and the 20 & 50 EMAs.
Cloud Coloring: The color of each cloud is determined by the relationship between the two EMAs that define it (e.g., if EMA 10 is above EMA 20, the first cloud is bullish-colored).
ADX Filter Logic: The script calculates the ADX value. If the "Use ADX Trend Filter?" input is checked and the calculated ADX is below the specified "ADX Trend Threshold", the script considers the market potentially ranging.
ADX Visual Effect: During detected ranging periods (if the ADX filter is active), the plotCloud12Color and plotCloud23Color variables are assigned a neutral grey color instead of their normal bullish/bearish colors before being passed to the fill() function.
Alert Logic: Boolean variables track the specific conditions (crossovers, cloud alignment, filter positions, ADX state). The alertcondition() function creates triggerable alerts based on these pre-defined conditions.
Potential Interpretation (Not Financial Advice):
Trend Alignment: When both clouds share the same directional color (e.g., both bullish - Green & Aqua) and price is on the corresponding side of the 200 EMA filter, it may suggest a stronger, more aligned trend. Conversely, conflicting cloud colors may indicate indecision or transition.
Dynamic Support/Resistance: The EMA lines themselves (especially the 20, 50, and 200) can sometimes act as dynamic levels where price might react.
Range Warning: Greyed-out clouds (when ADX filter is enabled) serve as a visual warning that trend-based strategies might face increased difficulty or whipsaws.
Confluence Alerts: The specific confluence alerts signal moments where multiple conditions align (crossover + cloud agreement + filters), which some traders might view as higher-probability setups.
Customization:
All EMA lengths (10, 20, 50, 200) are adjustable via the Inputs menu.
The ADX length and threshold are configurable.
The MA Trend Filter and ADX Trend Filter can be independently enabled or disabled.
Disclaimer:
This indicator is provided for informational and educational purposes only. Trading financial markets involves significant risk. Past performance is not indicative of future results. Always conduct your own thorough analysis and consider your risk tolerance before making any trading decisions. This indicator should be used in conjunction with other analysis methods and tools. Do not trade based solely on the signals or visuals provided by this indicator.
Custom EMAs, SMA y VWAP con Puntos en CrucesHighly configurable moving average indicator for each person's trading strategy.
PunkAlgo Oscillator [1.0]//@version=5
indicator(title='PunkAlgo Oscillator ', shorttitle='Punk Oscillator')
n1 = input(4, 'Channel Length')
n2 = input(15, 'Average Length')
obLevel1 = input(88, 'Over Bought Level 1')
obLevel2 = input(81, 'Over Bought Level 2')
osLevel1 = input(-83, 'Over Sold Level 1')
osLevel2 = input(-76, 'Over Sold Level 2')
ap = hlc3
esa = ta.ema(ap, n1)
d = ta.ema(math.abs(ap - esa), n1)
ci = (ap - esa) / (0.015 * d)
tci = ta.ema(ci, n2)
wt1 = tci
wt2 = ta.sma(wt1, 4)
var indbot=0
var indtop=0
if wt1 > wt2 and wt1 < wt2
indbot := bar_index
if wt1 < wt2 and wt1 > wt2
indtop := bar_index
bott = bar_index - indbot
topp = bar_index - indtop
// Histogram
lookbackPeriod = input(35, "Lookback Period")
// Calculate the percentage change in price for each bar
priceChange = close - close
priceChangePercentage = priceChange / close * 100
// Calculate the average volume over the lookback period
averageVolume = ta.ema(volume, lookbackPeriod)
// Initialize the counters for upward and downward trends
upwardTrends = 0
downwardTrends = 0
// Iterate over the lookback period and count the number of upward and downward trends
for i = 1 to lookbackPeriod
if priceChangePercentage > 0
upwardTrends := upwardTrends + 1
else if priceChangePercentage < 0
downwardTrends := downwardTrends + 1
// Calculate the probabilities of upward, downward, and neutral trends
totalTrends = upwardTrends + downwardTrends
probabilityUpward = math.round(upwardTrends / totalTrends, 2) * 100
probabilityDownward = math.round(downwardTrends / totalTrends, 2) * 100
// Determine the probability trend based on the probabilities
probabilityTrend = ""
if probabilityUpward > probabilityDownward
probabilityTrend := "Upward"
else if probabilityUpward < probabilityDownward
probabilityTrend := "Downward"
// Calculate the oscillator value based on the difference between upward and downward trends
oscillatorValue = probabilityUpward - probabilityDownward
// Determine the histogram color based on the difference between the oscillator value and zero line
histogramColor = oscillatorValue >= 0 ? (oscillatorValue < oscillatorValue ? color.new(#089981, 50) : color.new(#089981, 50)) : (oscillatorValue < oscillatorValue ? color.new(#f23645, 50) : color.new(#f23645, 50))
// Smoothning the Histogram
smooth_hist = input.bool(true, "Smoothen Histogram", inline="smooth_hist")
smoothning_scale = input.int(defval=3, title="", minval=1, maxval=10, step=1, inline="smooth_hist")
smooth_len = smoothning_scale * 2
smooth_hist_val = smooth_hist ? ta.ema(oscillatorValue, smooth_len) : oscillatorValue
// Plot the histogram
plot(smooth_hist_val, color=histogramColor, style=plot.style_area, linewidth=1, title="Probability Histogram")
// Histogram
plot(0, color=color.new(#787b86, 100))
top1 = plot(obLevel1, color=color.new(#4caf4f, 100))
top2 = plot(osLevel1, color=color.new(#ff5252, 100))
bottom1 = plot(obLevel2, color=color.new(#4caf4f, 100))
bottom2 = plot(osLevel2, color=color.new(#ff5252, 100))
fill(plot1=top1, plot2=bottom1, color=wt2 > 0 and (wt1 - wt2) > 0 ? #089981 : wt2 > 0 or (wt1 - wt2) > 0 ?color.new(#363a45, 60) : color.new(#363a45, 70))
fill(plot1=top2, plot2=bottom2, color=wt2 < 0 and (wt1 - wt2) < 0 ? #f23645 : wt2 < 0 or (wt1 - wt2) < 0 ? color.new(#363a45, 60) : color.new(#363a45, 70))
plot1 = plot(wt1, color=wt1 > wt2 ? color.new(color.green, 0) : color.gray ,title="Signal")
plot2 = plot(wt2, color=color.new(#ff5252, 100),title="Signal Dots")
fill(plot1=plot1, plot2=plot2, color=wt1 > wt2 ? color.rgb(8, 153, 129, 80) : color.rgb(120, 123, 134, 80),title="Signal Shadow")
plot(ta.cross(wt1, wt2) ? wt2 : na, color=color.new(color.black, 0), style=plot.style_circles, linewidth=3,title="Dot Shadows")
plot(ta.cross(wt1, wt2) ? wt2 : na, color=wt2 - wt1 > 0 ? color.gray : color.green , style=plot.style_circles, linewidth=2)
// Divergences Module
tsi1 = wt1
tsi2 = ta.sma(wt2, 4)
long = n1
short = n2
signal22 = n2
price = hlc3
src2 = hlc3
src = hlc3
input_src = tsi1
// Divergences Options
up = ta.rma(math.max(ta.change(src), 0), short)
down = ta.rma(-math.min(ta.change(src), 0), short)
lbR = input(title='Divergence Pivot Lookback Right', defval=1)
lbL = input(title='Divergence Pivot Lookback Left', defval=5)
rangeUpper = input(title='Max of Lookback Range', defval=100)
rangeLower = input(title='Min of Lookback Range', defval=2)
plotBull = input(title='Plot Bullish', defval=true)
plotHiddenBull = input(title='Plot Hidden Bullish', defval=false)
plotBear = input(title='Plot Bearish', defval=true)
plotHiddenBear = input(title='Plot Hidden Bearish', defval=false)
bearColor = color.new(#f23645, 10)
bullColor = color.new(#2157f3, 10)
hiddenBullColor = color.new(color.aqua, 0)
hiddenBearColor = color.new(color.orange, 0)
textColor = color.new(color.white, 0)
noneColor = color.new(color.white, 100)
osc = tsi1
plFound = na(ta.pivotlow(osc, lbL, lbR)) ? false : true
phFound = na(ta.pivothigh(osc, lbL, lbR)) ? false : true
_inRange(cond) =>
bars = ta.barssince(cond == true)
rangeLower <= bars and bars <= rangeUpper
//------------------------------------------------------------------------------
// Regular Bullish
// Osc: Higher Low
oscHL = osc > ta.valuewhen(plFound, osc , 1) and _inRange(plFound )
// Price: Lower Low
priceLL = low < ta.valuewhen(plFound, low , 1)
bullCond = plotBull and priceLL and oscHL and plFound
plot(plFound ? osc : na, offset=-lbR, title='Regular Bullish', linewidth=1, color=bullCond ? bullColor : noneColor, transp=0)
//------------------------------------------------------------------------------
// Hidden Bullish
// Osc: Lower Low
oscLL = osc < ta.valuewhen(plFound, osc , 1) and _inRange(plFound )
// Price: Higher Low
priceHL = low > ta.valuewhen(plFound, low , 1)
hiddenBullCond = plotHiddenBull and priceHL and oscLL and plFound
plot(plFound ? osc : na, offset=-lbR, title='Hidden Bullish', linewidth=1, color=hiddenBullCond ? hiddenBullColor : noneColor, transp=0)
//------------------------------------------------------------------------------
// Regular Bearish
// Osc: Lower High
oscLH = osc < ta.valuewhen(phFound, osc , 1) and _inRange(phFound )
// Price: Higher High
priceHH = high > ta.valuewhen(phFound, high , 1)
bearCond = plotBear and priceHH and oscLH and phFound
plot(phFound ? osc : na, offset=-lbR, title='Regular Bearish', linewidth=1, color=bearCond ? bearColor : noneColor, transp=0)
//------------------------------------------------------------------------------
// Hidden Bearish
// Osc: Higher High
oscHH = osc > ta.valuewhen(phFound, osc , 1) and _inRange(phFound )
// Price: Lower High
priceLH = high < ta.valuewhen(phFound, high , 1)
hiddenBearCond = plotHiddenBear and priceLH and oscHH and phFound
plot(phFound ? osc : na, offset=-lbR, title='Hidden Bearish', linewidth=1, color=hiddenBearCond ? hiddenBearColor : noneColor, transp=0)
// Signals Module
string TT_HARSI = 'Period for the RSI calculations used to generate the' + 'candles. This seperate from the RSI plot/histogram length.'
string TT_PBIAS = 'Smoothing feature for the OPEN of the HARSI candles.' + ' Increases bias toward the prior open value which can' + ' help provide better visualisation of trend strength.' + ' ** By changing the Open values, High and Low can also' + ' be distorted - however Close will remain unchanged.'
string TT_SMRSI = 'This option smoothes the RSI in a manner similar to HA' + ' open, but uses the realtime rsi rather than the prior' + ' close value.'
string TT_STOCH = 'Uses the RSI generated by the above settings, and as such' + ' will be affected by the smoothing option.'
string TT_STFIT = 'Adjusts the vertical scaling of the stochastic, can help' + ' to prevent distortion of other data in the channel.' + ' Has no impact cross conditions.'
////////////////////////////////////////////////////////////////////////////////
// //
// ====== INPUTS ====== //
// //
////////////////////////////////////////////////////////////////////////////////
// -- Candle config
string GROUP_CAND = 'Config » HARSI Candles'
i_lenHARSI = input.int(10, 'Length', group=GROUP_CAND, minval=1, tooltip=TT_HARSI)
i_smoothing = input.int(5, 'Open Smoothing', group=GROUP_CAND, minval=1, maxval=100, tooltip=TT_PBIAS)
string INLINE_COL = 'Colour Pallette'
i_colUp = input.color(color.teal, 'Colour Pallette ', group=GROUP_CAND, inline=INLINE_COL)
i_colDown = input.color(color.red, ' ', group=GROUP_CAND, inline=INLINE_COL)
i_colWick = input.color(color.gray, ' ', group=GROUP_CAND, inline=INLINE_COL)
// -- RSI plot config
string GROUP_PLOT = 'Config » RSI Plot'
i_source = input.source(ohlc4, 'Source', group=GROUP_PLOT)
i_lenRSI = input.int(7, 'Length', group=GROUP_PLOT, minval=1)
i_mode = input.bool(true, 'Smoothed Mode RSI?', group=GROUP_PLOT, tooltip=TT_SMRSI)
i_showPlot = input.bool(true, 'Show RSI Plot?', group=GROUP_PLOT)
i_showHist = input.bool(true, 'Show RSI Histogram?', group=GROUP_PLOT)
// -- Channel OB/OS config
string GROUP_CHAN = 'Config » OB/OS Boundaries'
i_upper = input.int(50, 'OB', group=GROUP_CHAN, inline='OB', minval=1, maxval=50)
i_upperx = input.int(30, 'OB Extreme', group=GROUP_CHAN, inline='OB', minval=1, maxval=50)
i_lower = input.int(-50, 'OS', group=GROUP_CHAN, inline='OS', minval=-50, maxval=-1)
i_lowerx = input.int(-30, 'OS Extreme', group=GROUP_CHAN, inline='OS', minval=-50, maxval=-1)
// Settins
// WaveTrend
wwttShow = input(false, title='Show WaveTrend')
wwttBuyShow = input(true, title='Show Buy dots')
wwttGoldShow = input(true, title='Show Gold dots')
wwttSellShow = input(true, title='Show Sell dots')
wwttDivShow = input(true, title='Show Div. dots')
vwapShow = input(true, title='Show Fast wwtt')
wwttChannelLen = input(9, title='wwtt Channel Length')
wwttAverageLen = input(12, title='wwtt Average Length')
wwttMASource = input(hlc3, title='wwtt MA Source')
wwttMALen = input(3, title='wwtt MA Length')
// WaveTrend Overbought & Oversold lines
OOBBLevel = input(53, title='wwtt Overbought Level 1')
OOBBLevel2 = input(60, title='wwtt Overbought Level 2')
OOBBLevel3 = input(100, title='wwtt Overbought Level 3')
oosLevel = input(-53, title='wwtt Oversold Level 1')
oosLevel2 = input(-60, title='wwtt Oversold Level 2')
oosLevel3 = input(-75, title='wwtt Oversold Level 3')
// Divergence wwtt
wwttShowDiv = input(true, title='Show wwtt Regular Divergences')
wwttShowHiddenDiv = input(false, title='Show wwtt Hidden Divergences')
showHiddenDiv_nl = input(true, title='Not apply OB/OS Limits on Hidden Divergences')
wwttDivOOBBLevel = input(45, title='wwtt Bearish Divergence min')
wwttDivoosLevel = input(-65, title='wwtt Bullish Divergence min')
// Divergence extra range
wwttDivOOBBLevel_addshow = input(true, title='Show 2nd wwtt Regular Divergences')
wwttDivOOBBLevel_add = input(15, title='wwtt 2nd Bearish Divergence')
wwttDivoosLevel_add = input(-40, title='wwtt 2nd Bullish Divergence 15 min')
// RSI+MFI
rsiMFIShow = input(true, title='Show MFI')
rsiMFIperiod = input(60, title='MFI Period')
rsiMFIMultiplier = input.float(150, title='MFI Area multiplier')
rsiMFIPosY = input(2.5, title='MFI Area Y Pos')
// RSI
rsiShow = input(false, title='Show RSI')
rsiSRC = input(close, title='RSI Source')
rsiLen = input(14, title='RSI Length')
rsiOversold = input.int(30, title='RSI Oversold', minval=29, maxval=100)
rsiOverbought = input.int(60, title='RSI Overbought', minval=0, maxval=60)
// Divergence RSI
rsiShowDiv = input(false, title='Show RSI Regular Divergences')
rsiShowHiddenDiv = input(false, title='Show RSI Hidden Divergences')
rsiDivOOBBLevel = input(60, title='RSI Bearish Divergence min')
rsiDivoosLevel = input(30, title='RSI Bullish Divergence min')
// Colors
colorRed = #ff0000
colorPurple = #e600e6
colorGreen = #3fff00
colorOrange = #e2a400
colorYellow = #ffe500
colorWhite = #ffffff
colorPink = #ff00f0
colorBluelight = #31c0ff
colorwwtt1 = #49536195
colorwwtt2 = #7b9fd596
colorwwtt2_ = #131722
colormacdwwtt1a = #4caf58
colormacdwwtt1b = #af4c4c
colormacdwwtt1c = #7ee57e
colormacdwwtt1d = #ff3535
colormacdwwtt2a = #305630
colormacdwwtt2b = #310101
colormacdwwtt2c = #132213
colormacdwwtt2d = #770000
////////////////////////////////////////////////////////////////////////////////
// //
// ====== FUNCTIONS ====== //
// //
////////////////////////////////////////////////////////////////////////////////
// FUNCTIONS
// zero median rsi helper function, just subtracts 50.
f_zrsi(_source, _length) =>
ta.rsi(_source, _length) - 50
// zero median stoch helper function, subtracts 50 and includes % scaling
f_zstoch(_source, _length, _smooth, _scale) =>
float _zstoch = ta.stoch(_source, _source, _source, _length) - 50
float _smoothed = ta.sma(_zstoch, _smooth)
float _scaled = _smoothed / 100 * _scale
_scaled
// mode selectable rsi function for standard, or smoothed output
f_rsi(_source, _length, _mode) =>
// get base rsi
float _zrsi = f_zrsi(_source, _length)
// smoothing in a manner similar to HA open, but rather using the realtime
// rsi in place of the prior close value.
var float _smoothed = na
_smoothed := na(_smoothed ) ? _zrsi : (_smoothed + _zrsi) / 2
// return the requested mode
_mode ? _smoothed : _zrsi
// RSI Heikin-Ashi generation function
f_rsiHeikinAshi(_length) =>
// get close rsi
float _closeRSI = f_zrsi(close, _length)
// emulate "open" simply by taking the previous close rsi value
float _openRSI = nz(_closeRSI , _closeRSI)
// the high and low are tricky, because unlike "high" and "low" by
// themselves, the RSI results can overlap each other. So first we just go
// ahead and get the raw results for high and low, and then..
float _highRSI_raw = f_zrsi(high, _length)
float _lowRSI_raw = f_zrsi(low, _length)
// ..make sure we use the highest for high, and lowest for low
float _highRSI = math.max(_highRSI_raw, _lowRSI_raw)
float _lowRSI = math.min(_highRSI_raw, _lowRSI_raw)
// ha calculation for close
float _close = (_openRSI + _highRSI + _lowRSI + _closeRSI) / 4
// ha calculation for open, standard, and smoothed/lagged
var float _open = na
_open := na(_open ) ? (_openRSI + _closeRSI) / 2 : (_open * i_smoothing + _close ) / (i_smoothing + 1)
// ha high and low min-max selections
float _high = math.max(_highRSI, math.max(_open, _close))
float _low = math.min(_lowRSI, math.min(_open, _close))
// return the OHLC values
// Divergences
f_top_fractal(src) =>
src < src and src < src and src > src and src > src
f_bot_fractal(src) =>
src > src and src > src and src < src and src < src
f_fractalize(src) =>
f_top_fractal(src) ? 1 : f_bot_fractal(src) ? -1 : 0
f_findDivs(src, topLimit, botLimit, useLimits) =>
fractalTop = f_fractalize(src) > 0 and (useLimits ? src >= topLimit : true) ? src : na
fractalBot = f_fractalize(src) < 0 and (useLimits ? src <= botLimit : true) ? src : na
highPrev = ta.valuewhen(fractalTop, src , 0)
highPrice = ta.valuewhen(fractalTop, high , 0)
lowPrev = ta.valuewhen(fractalBot, src , 0)
lowPrice = ta.valuewhen(fractalBot, low , 0)
bearSignal = fractalTop and high > highPrice and src < highPrev
bullSignal = fractalBot and low < lowPrice and src > lowPrev
bearDivHidden = fractalTop and high < highPrice and src > highPrev
bullDivHidden = fractalBot and low > lowPrice and src < lowPrev
// RSI+MFI
f_rsimfi(_period, _multiplier, _tf) =>
request.security(syminfo.tickerid, _tf, ta.sma((close - open) / (high - low) * _multiplier, _period) - rsiMFIPosY)
// WaveTrend
f_wavetrend(src, chlen, avg, malen, tf) =>
tfsrc = request.security(syminfo.tickerid, tf, src)
esa = ta.ema(tfsrc, chlen)
de = ta.ema(math.abs(tfsrc - esa), chlen)
ci = (tfsrc - esa) / (0.015 * de)
wwtt1 = request.security(syminfo.tickerid, tf, ta.ema(ci, avg))
wwtt2 = request.security(syminfo.tickerid, tf, ta.sma(wwtt1, malen))
wwttVwap = wwtt1 - wwtt2
wwttOversold = wwtt2 <= oosLevel
wwttOverbought = wwtt2 >= OOBBLevel
wwttCross = ta.cross(wwtt1, wwtt2)
wwttCrossUp = wwtt2 - wwtt1 <= 0
wwttCrossDown = wwtt2 - wwtt1 >= 0
wwttCrosslast = ta.cross(wwtt1 , wwtt2 )
wwttCrossUplast = wwtt2 - wwtt1 <= 0
wwttCrossDownlast = wwtt2 - wwtt1 >= 0
// MACD
f_macd(src, fastlen, slowlen, sigsmooth, tf) =>
fast_ma = request.security(syminfo.tickerid, tf, ta.ema(src, fastlen))
slow_ma = request.security(syminfo.tickerid, tf, ta.ema(src, slowlen))
macd = fast_ma - slow_ma
signal = request.security(syminfo.tickerid, tf, ta.sma(macd, sigsmooth))
hist = macd - signal
// Get higher timeframe candle
f_getTFCandle(_tf) =>
_open = request.security(ticker.heikinashi(syminfo.tickerid), _tf, open, barmerge.gaps_off, barmerge.lookahead_on)
_close = request.security(ticker.heikinashi(syminfo.tickerid), _tf, close, barmerge.gaps_off, barmerge.lookahead_on)
_high = request.security(ticker.heikinashi(syminfo.tickerid), _tf, high, barmerge.gaps_off, barmerge.lookahead_on)
_low = request.security(ticker.heikinashi(syminfo.tickerid), _tf, low, barmerge.gaps_off, barmerge.lookahead_on)
hl2 = (_high + _low) / 2.0
newBar = ta.change(_open)
candleBodyDir = _close > _open
////////////////////////////////////////////////////////////////////////////////
// //
// ====== SERIES, LINES and LABELS ====== //
// //
////////////////////////////////////////////////////////////////////////////////
// CALCULATE INDICATORS {
// RSI
rsi = ta.rsi(rsiSRC, rsiLen)
rsiColor = rsi <= rsiOversold ? colorGreen : rsi >= rsiOverbought ? colorRed : colorPurple
// Calculates WaveTrend
= f_wavetrend(wwttMASource, wwttChannelLen, wwttAverageLen, wwttMALen, timeframe.period)
// wwtt Divergences
= f_findDivs(wwtt2, wwttDivOOBBLevel, wwttDivoosLevel, true)
= f_findDivs(wwtt2, wwttDivOOBBLevel_add, wwttDivoosLevel_add, true)
= f_findDivs(wwtt2, 0, 0, false)
wwttBearDivHidden_ = showHiddenDiv_nl ? wwttBearDivHidden_nl : wwttBearDivHidden
wwttBullDivHidden_ = showHiddenDiv_nl ? wwttBullDivHidden_nl : wwttBullDivHidden
wwttBearDivColor = wwttShowDiv and wwttBearDiv or wwttShowHiddenDiv and wwttBearDivHidden_ ? colorRed : na
wwttBullDivColor = wwttShowDiv and wwttBullDiv or wwttShowHiddenDiv and wwttBullDivHidden_ ? colorGreen : na
wwttBearDivColor_add = wwttShowDiv and wwttDivOOBBLevel_addshow and wwttBearDiv_add or wwttShowHiddenDiv and wwttDivOOBBLevel_addshow and wwttBearDivHidden_add ? #9a0202 : na
wwttBullDivColor_add = wwttShowDiv and wwttDivOOBBLevel_addshow and wwttBullDiv_add or wwttShowHiddenDiv and wwttDivOOBBLevel_addshow and wwttBullDivHidden_add ? #1b5e20 : na
// RSI Divergences
= f_findDivs(rsi, rsiDivOOBBLevel, rsiDivoosLevel, true)
= f_findDivs(rsi, 0, 0, false)
rsiBearDivHidden_ = showHiddenDiv_nl ? rsiBearDivHidden_nl : rsiBearDivHidden
rsiBullDivHidden_ = showHiddenDiv_nl ? rsiBullDivHidden_nl : rsiBullDivHidden
rsiBearDivColor = rsiShowDiv and rsiBearDiv or rsiShowHiddenDiv and rsiBearDivHidden_ ? colorRed : na
rsiBullDivColor = rsiShowDiv and rsiBullDiv or rsiShowHiddenDiv and rsiBullDivHidden_ ? colorGreen : na
// Buy signal.
buySignal = wwttCross and wwttCrossUp and wwttOversold
buySignalDiv = wwttShowDiv and wwttBullDiv or wwttShowDiv and wwttBullDiv_add or rsiShowDiv and rsiBullDiv
buySignalDiv_color = wwttBullDiv ? colorGreen : wwttBullDiv_add ? color.new(colorGreen, 60) : rsiShowDiv ? colorGreen : na
// Sell signal
sellSignal = wwttCross and wwttCrossDown and wwttOverbought
sellSignalDiv = wwttShowDiv and wwttBearDiv or wwttShowDiv and wwttBearDiv_add or rsiShowDiv and rsiBearDiv
sellSignalDiv_color = wwttBearDiv ? colorRed : wwttBearDiv_add ? color.new(colorRed, 60) : rsiBearDiv ? colorRed : na
// standard, or ha smoothed rsi for the line plot and/or histogram
float RSI = f_rsi(i_source, i_lenRSI, i_mode)
// get OHLC values to use in the plotcandle()
= f_rsiHeikinAshi(i_lenHARSI)
// shadow, invisible
color colShadow = color.rgb(0, 0, 0, 100)
color colNone = color.rgb(0, 0, 0, 100)
// rsi color
//color colRSI = RSI >=30 ? color.red : color.gray
color colRSI = RSI < -31 ? color.lime : RSI > 31 ? color.red : color.gray
cross_up = RSI > 30
cross_down = RSI < -30
// candle body colouring
color bodyColour = C > O ? i_colUp : i_colDown
color wickColour = i_colWick
////////////////////////////////////////////////////////////////////////////////
// //
// ====== DRAWING and PLOTTING ====== //
// //
////////////////////////////////////////////////////////////////////////////////
plotchar(cross_down and wwttBuyShow and buySignal ? -107 : na, title='Buy circle', char='·', color=color.new(colorGreen, 10), location=location.absolute, size=size.small)
plotchar(cross_up and wwttSellShow and sellSignal ? 105 : na, title='Sell circle', char='·', color=color.new(colorRed, 10), location=location.absolute, size=size.small)
plotchar(cross_down and wwttDivShow and buySignalDiv and wwttBuyShow and buySignal ? -106 : na, title='Divergence buy circle', char='▲', color=buySignalDiv_color, location=location.absolute, size=size.tiny, offset=-2, transp=10)
plotchar(cross_up and wwttDivShow and sellSignalDiv and wwttSellShow and sellSignal ? 106 : na, title='Divergence sell circle', char='▼', color=sellSignalDiv_color, location=location.absolute, size=size.tiny, offset=-2, transp=10)
//Alerts
alertcondition((cross_down and wwttBuyShow and buySignal and wwttDivShow and buySignalDiv) or (cross_up and wwttSellShow and sellSignal and wwttDivShow and sellSignalDiv), title='Buy/Sell Signal', message='Buy/Sell Signal')
Relative Strength Index//@version=6
indicator(title="Relative Strength Index", shorttitle="RSI", format=format.price, precision=2, timeframe="", timeframe_gaps=true)
// RSI Settings
rsiLengthInput = input.int(14, minval=1, title="RSI Length", group="RSI Settings")
rsiSourceInput = input.source(close, "Source", group="RSI Settings")
calculateDivergence = input.bool(false, title="Calculate Divergence", group="RSI Settings", display = display.data_window, tooltip = "Calculating divergences is needed in order for divergence alerts to fire.")
// RSI Calculation
change = ta.change(rsiSourceInput)
up = ta.rma(math.max(change, 0), rsiLengthInput)
down = ta.rma(-math.min(change, 0), rsiLengthInput)
rsi = down == 0 ? 100 : up == 0 ? 0 : 100 - (100 / (1 + up / down))
// Smoothing MA inputs
GRP = "Smoothing"
TT_BB = "Only applies when 'SMA + Bollinger Bands' is selected. Determines the distance between the SMA and the bands."
maTypeInput = input.string("SMA", "Type", options = , group = GRP, display = display.data_window)
maLengthInput = input.int(14, "Length", group = GRP, display = display.data_window)
bbMultInput = input.float(2.0, "BB StdDev", minval = 0.001, maxval = 50, step = 0.5, tooltip = TT_BB, group = GRP, display = display.data_window)
var enableMA = maTypeInput != "None"
var isBB = maTypeInput == "SMA + Bollinger Bands"
// Smoothing MA Calculation
ma(source, length, MAtype) =>
switch MAtype
"SMA" => ta.sma(source, length)
"SMA + Bollinger Bands" => ta.sma(source, length)
"EMA" => ta.ema(source, length)
"SMMA (RMA)" => ta.rma(source, length)
"WMA" => ta.wma(source, length)
"VWMA" => ta.vwma(source, length)
// Calculate MA
smoothingMA = enableMA ? ma(rsi, maLengthInput, maTypeInput) : na
// Define RSI color based on position relative to MA
rsiColor = enableMA ? (rsi > smoothingMA ? color.green : color.red) : (rsi > rsi ? color.green : color.red)
// Plot RSI with dynamic color
rsiPlot = plot(rsi, "RSI", color = rsiColor)
// Horizontal lines
rsiUpperBand = hline(70, "RSI Upper Band (70)", color=#787B86, linestyle=hline.style_solid)
rsiUpperMidBand = hline(60, "RSI Upper Mid Band (60)", color=color.new(#787B86, 30), linestyle=hline.style_dashed)
midline = hline(50, "RSI Middle Band (50)", color=color.new(#787B86, 50))
rsiLowerMidBand = hline(40, "RSI Lower Mid Band (40)", color=color.new(#787B86, 30), linestyle=hline.style_dashed)
rsiLowerBand = hline(30, "RSI Lower Band (30)", color=#787B86, linestyle=hline.style_solid)
// Fills
fill(rsiUpperBand, rsiUpperMidBand, color=color.new(color.green, 90), title="Extreme Overbought Zone")
fill(rsiUpperMidBand, midline, color=color.new(color.green, 95), title="Overbought Zone")
fill(midline, rsiLowerMidBand, color=color.new(color.red, 95), title="Oversold Zone")
fill(rsiLowerMidBand, rsiLowerBand, color=color.new(color.red, 90), title="Extreme Oversold Zone")
midLinePlot = plot(50, color = na, editable = false, display = display.none)
fill(rsiPlot, midLinePlot, 100, 70, top_color = color.new(color.green, 0), bottom_color = color.new(color.green, 100), title = "Overbought Gradient Fill")
fill(rsiPlot, midLinePlot, 30, 0, top_color = color.new(color.red, 100), bottom_color = color.new(color.red, 0), title = "Oversold Gradient Fill")
// Smoothing MA plots
smoothingStDev = isBB ? ta.stdev(rsi, maLengthInput) * bbMultInput : na
plot(smoothingMA, "RSI-based MA", color=color.yellow, display = enableMA ? display.all : display.none, editable = enableMA)
bbUpperBand = plot(smoothingMA + smoothingStDev, title = "Upper Bollinger Band", color=color.green, display = isBB ? display.all : display.none, editable = isBB)
bbLowerBand = plot(smoothingMA - smoothingStDev, title = "Lower Bollinger Band", color=color.green, display = isBB ? display.all : display.none, editable = isBB)
fill(bbUpperBand, bbLowerBand, color= isBB ? color.new(color.green, 90) : na, title="Bollinger Bands Background Fill", display = isBB ? display.all : display.none, editable = isBB)
// Divergence (unchanged)
lookbackRight = 5
lookbackLeft = 5
rangeUpper = 60
rangeLower = 5
bearColor = color.red
bullColor = color.green
textColor = color.white
noneColor = color.new(color.white, 100)
_inRange(cond) =>
bars = ta.barssince(cond)
rangeLower <= bars and bars <= rangeUpper
plFound = false
phFound = false
bullCond = false
bearCond = false
rsiLBR = rsi
if calculateDivergence
plFound := not na(ta.pivotlow(rsi, lookbackLeft, lookbackRight))
plFoundPrev = plFound
inRangeBull = _inRange(plFoundPrev)
rsiHL = rsiLBR > ta.valuewhen(plFound, rsiLBR, 1) and inRangeBull
lowLBR = low
priceLL = lowLBR < ta.valuewhen(plFound, lowLBR, 1)
bullCond := priceLL and rsiHL and plFound
phFound := not na(ta.pivothigh(rsi, lookbackLeft, lookbackRight))
phFoundPrev = phFound
inRangeBear = _inRange(phFoundPrev)
rsiLH = rsiLBR < ta.valuewhen(phFound, rsiLBR, 1) and inRangeBear
highLBR = high
priceHH = highLBR > ta.valuewhen(phFound, highLBR, 1)
bearCond := priceHH and rsiLH and phFound
plot(plFound ? rsiLBR : na, offset = -lookbackRight, title = "Regular Bullish", linewidth = 2, color = (bullCond ? bullColor : noneColor), display = display.pane, editable = calculateDivergence)
plotshape(bullCond ? rsiLBR : na, offset = -lookbackRight, title = "Regular Bullish Label", text = " Bull ", style = shape.labelup, location = location.absolute, color = bullColor, textcolor = textColor, display = display.pane, editable = calculateDivergence)
plot(phFound ? rsiLBR : na, offset = -lookbackRight, title = "Regular Bearish", linewidth = 2, color = (bearCond ? bearColor : noneColor), display = display.pane, editable = calculateDivergence)
plotshape(bearCond ? rsiLBR : na, offset = -lookbackRight, title = "Regular Bearish Label", text = " Bear ", style = shape.labeldown, location = location.absolute, color = bearColor, textcolor = textColor, display = display.pane, editable = calculateDivergence)
alertcondition(bullCond, title='Regular Bullish Divergence', message="Found a new Regular Bullish Divergence, `Pivot Lookback Right` number of bars to the left of the current bar.")
alertcondition(bearCond, title='Regular Bearish Divergence', message='Found a new Regular Bearish Divergence, `Pivot Lookback Right` number of bars to the left of the current bar.')
Pinbar DetectorFinding a pinbars on m5 timeframe. In order for the indicator to search for pinbars specifically on the M5 timeframe (5 minutes), you need to set this value in the tf parameter by default. In the current code, the timeframe is set via input.timeframe, and you can either change it manually in the indicator settings after adding it to the chart, or set M5 directly in the code.
Here's how to do it:
Change in code: In the line with input.timeframe, replace the default value "D" with "5" (in Pine Script, timeframes are designated as follows: "5" for 5 minutes, "15" for 15 minutes, "60" for 1 hour, etc.).
TREND FINDER BY MRS (SSL Hybrid + Delta Candles)Perfect for identifying trend direction, continuation signals, and exit points while visualizing real-time buying/selling pressure.
A sophisticated multi-timeframe trading system combining:
SSL Hybrid Trend Analysis (HMA/JMA/EMA baseline)
Volume Delta Visualization (colored candles)
ATR Volatility Bands (optional)
Key Features:
1. Smart Trend Detection
Custom Baseline MA: Choose between HMA, JMA (Jurik), or EMA with adjustable length
Trend-Colored Baseline:
🟢 Green = Uptrend (price above & baseline rising)
🔴 Red = Downtrend (price below & baseline falling)
🟠 Orange = Neutral/Transition phase
2. Volume Delta Candles
Colors candles based on lower timeframe volume imbalance:
🟢 Dark Green: Strong buying pressure (delta > 20%)
🌱 Light Green: Moderate buying (delta 5-20%)
🔴 Dark Red: Strong selling pressure (delta < -20%)
🌸 Light Red: Moderate selling (delta -5% to -20%)
⚪ Gray: Balanced volume
3. Professional Tools
ATR Bands: Visualize volatility with adjustable multiplier
Multi-Timeframe Analysis: Delta calculated from lower timeframe (default: 1min)
Alerts: Baseline crosses and extreme delta conditions
Recommended Settings:
Chart Type: Daily (for NNFX method)
Baseline: HMA/JMA (60 periods)
Delta TF: 1-5min for intraday volume accuracy
How Traders Use It:
Trend Traders: Follow colored baseline for direction
Swing Traders: Use delta extremes for reversals
Breakout Traders: Watch ATR band expansions
Published Notes:
TREND FINDER BY MRS (SSL Hybrid with Delta Candles)
By: Rajasekhar Muvvala
*"See the trend, read the volume, trade with confidence"*
Installation:
1. Add to TradingView via Pine Editor
2. Customize colors/thresholds in settings
3. Apply to daily charts for best results
Pro Tip:
Combine with:
- 200EMA for long-term bias
- Horizontal S/R levels
- Price action confirmation
This description highlights the indicator's unique value while making it accessible for both beginners and advanced traders. The markdown formatting ensures clean presentation when published on trading forums or journals. Would you like me to adjust any technical aspects or emphasize different features?
RSI + MFI Momentum Mapper - CoffeeKillerRSI + MFI Momentum Mapper - CoffeeKiller Indicator Guide
Welcome traders! This guide will walk you through the RSI + MFI Momentum Mapper indicator, an innovative market analysis tool developed by CoffeeKiller that combines two powerful oscillators to create a comprehensive momentum visualization system.
🔔 **Warning: This Is Not a Standard RSI or MFI Indicator** 🔔 This indicator combines and normalizes RSI and MFI data to create a unified momentum representation with boundary detection and peak signaling features.
Core Concept: Combined Momentum Analysis
The foundation of this indicator lies in merging the strengths of two complementary oscillators - Relative Strength Index (RSI) and Money Flow Index (MFI) - to provide a more robust momentum signal that accounts for both price action and volume.
Directional Columns: Momentum Strength
- Positive Green Columns: Bullish momentum
- Negative Red Columns: Bearish momentum
- Color intensity varies based on momentum strength
- Special coloring for new high/low boundaries
Marker Lines: Dynamic Support/Resistance
- High Marker Line (Magenta): Tracks the highest point reached during a bullish phase
- Low Marker Line (Cyan): Tracks the lowest point reached during a bearish phase
- Creates visual boundaries showing momentum extremes
Peak Detection System:
- Triangular markers identify significant local maxima and minima
- Background highlighting shows important momentum peaks
- Helps identify potential reversal points and momentum exhaustion
Reference Lines:
- Zero Line (Gray): Divides bullish from bearish momentum
- High Line (+1): Upper threshold for extremely bullish conditions
- Low Line (-1): Lower threshold for extremely bearish conditions
Core Components
1. Oscillator Normalization
- RSI and MFI values centered around zero
- Values scaled to create consistent visualization
- Normalized range typically between -1 and +1
- Combination of indicators for signal reliability
2. Boundary Tracking System
- Automatic detection of highest values in bullish phases
- Automatic detection of lowest values in bearish phases
- Step-line visualization of boundaries
- Color-coded for easy identification
3. Peak Detection System
- Identification of local maxima and minima
- Background highlighting of significant peaks
- Triangle markers for peak visualization
- Zero-line cross detection for trend changes
4. Signal Smoothing
- Signal line calculation via SMA
- Helps filter noise and identify trends
- Provides confirmation of momentum direction
Main Features
Oscillator Settings
- Customizable RSI length for sensitivity control
- Customizable MFI length for sensitivity control
- Normalized display for consistent visualization
- Signal smoothing for clearer readings
Visual Elements
- Color-coded columns showing momentum direction and strength
- Dynamic marker lines for momentum boundaries
- Peak triangles for significant turning points
- Background highlighting for peak identification
- Reference lines for momentum threshold levels
Signal Generation
- Zero-line crosses for trend change signals
- Boundary breaks for momentum strength
- Peak formation for potential reversals
- Color changes for momentum direction and acceleration
Customization Options
- RSI and MFI length parameters
- Marker line visibility and colors
- Peak marker color selection
- Peak background display options
Trading Applications
1. Trend Identification
- Directional line crossing above zero: bullish trend beginning
- Directional line crossing below zero: bearish trend beginning
- Column color: indicates momentum direction
- Column height: indicates momentum strength
2. Reversal Detection
- Peak triangles after extended trend: potential exhaustion
- Background highlighting: significant reversal points
- Directional line approaching marker lines: potential trend change
- Color shifts from bright to muted: decreasing momentum
3. Momentum Analysis
- Breaking above previous high boundary: accelerating bullish momentum
- Breaking below previous low boundary: accelerating bearish momentum
- Special coloring (magenta/cyan): boundary breaks indicating strength
- Approaching +1/-1 lines: extreme momentum conditions
4. Market Structure Assessment
- Consecutive higher peaks: strengthening bullish structure
- Consecutive lower troughs: strengthening bearish structure
- Peak comparisons: relative strength of momentum phases
- Boundary line steps: market structure levels
Optimization Guide
1. Oscillator Settings
- RSI Length: Default 14 provides balanced signals
- Lower values (7-10): More responsive, potentially noisier
- Higher values (20-30): Smoother, fewer false signals
- MFI Length: Default 14 provides balanced signals
- Lower values: More responsive to volume changes
- Higher values: Less sensitive to short-term volume spikes
2. Visual Customization
- Marker Line Colors: Adjust for visibility on your chart
- Peak Marker Color: Default yellow provides good contrast
- Enable/disable background highlights based on preference
- Consider chart background when selecting colors
3. Signal Interpretation
- Stronger signals: When directional line approaches +1/-1
- Confirmation: When peaks form after extended momentum
- Early warnings: When color intensity changes before direction
- Trend strength: Distance between zero line and current reading
4. Reference Line Usage
- Zero line: Primary trend divider
- +1/-1 lines: Extreme momentum thresholds
- Marker lines: Dynamic support/resistance levels
- Distance from reference: Momentum strength measure
Best Practices
1. Signal Confirmation
- Wait for zero-line crosses to confirm trend changes
- Look for peak formations to identify potential reversals
- Check for boundary breaks to confirm strong momentum
- Use with price action for entry/exit precision
2. Timeframe Selection
- Lower timeframes: more signals, potential noise
- Higher timeframes: cleaner signals, less frequent
- Multiple timeframes: confirm signals across time horizons
- Match to your trading style and holding period
3. Market Context
- Strong bullish phase: positive columns breaking above marker line
- Strong bearish phase: negative columns breaking below marker line
- Columns approaching zero: potential trend change
- Columns approaching +1/-1: extreme conditions, potential reversal
4. Combining with Other Indicators
- Use with trend indicators for confirmation
- Pair with other oscillators for divergence detection
- Combine with volume analysis for validation
- Consider support/resistance levels with boundary lines
Advanced Trading Strategies
1. Boundary Break Strategy
- Enter long when directional line breaks above previous high marker line
- Enter short when directional line breaks below previous low marker line
- Use zero-line as initial stop-loss reference
- Take profits at formation of opposing peaks
2. Peak Trading Strategy
- Identify significant peaks with triangular markers
- Look for consecutive lower peaks in bullish phases for shorting opportunities
- Look for consecutive higher troughs in bearish phases for buying opportunities
- Use zero-line crosses as confirmation
3. Extreme Reading Strategy
- Look for directional line approaching +1/-1 lines
- Watch for color changes and peak formations
- Enter counter-trend positions after confirmed peaks
- Use tight stops due to extreme momentum conditions
4. Column Color Strategy
- Enter long when columns turn bright green (increasing momentum)
- Enter short when columns turn bright red (increasing momentum)
- Exit when color intensity fades (decreasing momentum)
- Use marker lines as dynamic support/resistance
Practical Analysis Examples
Bullish Market Scenario
- Directional line crosses above zero line
- Green columns grow in height and intensity
- High marker line forms steps upward
- Peak triangles appear at local maxima
- Background highlights appear at significant momentum peaks
Bearish Market Scenario
- Directional line crosses below zero line
- Red columns grow in depth and intensity
- Low marker line forms steps downward
- Peak triangles appear at local minima
- Background highlights appear at significant momentum troughs
Consolidation Scenario
- Directional line oscillates around zero line
- Column colors alternate frequently
- Marker lines remain relatively flat
- Few or no new peak highlights appear
- Directional values remain small
Understanding Market Dynamics Through RSI + MFI Momentum Mapper
At its core, this indicator provides a unique lens to visualize market momentum by combining two complementary oscillators:
1. Combined Strength: By averaging RSI (price-based) and MFI (volume-based), the indicator provides a more comprehensive view of market momentum that considers both price action and buying/selling pressure.
2. Normalized Scale: The indicator normalizes values around zero, making it easier to identify bullish vs bearish conditions and the relative strength of momentum in either direction.
3. Dynamic Boundaries: The marker lines create a visual representation of the "high water marks" of momentum in both directions, helping to identify when markets are making new momentum extremes.
4. Exhaustion Signals: The peak detection system highlights moments where momentum has reached a local maximum or minimum, often precursors to reversals or consolidations.
Remember:
- Combine signals from directional line, marker lines, and peak formations
- Use appropriate timeframe settings for your trading style
- Customize the indicator to match your visual preferences
- Consider market conditions and correlate with price action
This indicator works best when:
- Used as part of a comprehensive trading system
- Combined with proper risk management
- Applied with an understanding of current market conditions
- Signals are confirmed by price action and other indicators
DISCLAIMER: This indicator and its signals are intended solely for educational and informational purposes. They do not constitute financial advice. Trading involves significant risk of loss. Always conduct your own analysis and consult with financial professionals before making trading decisions.
Fibonacci BB Strategy with RSI + 2% Exit📈 Fibonacci BB Strategy with RSI + 2% Profit Exit
This strategy combines a VWMA-based Bollinger Band system with RSI confirmation and a 2% profit-taking mechanism, offering a balanced blend of trend and momentum trading.
🔍 Key Features:
✅ VWMA-Based Bands: Uses a 200-period Volume Weighted Moving Average (VWMA) to create dynamic support and resistance bands with standard deviation. Helps capture trend direction with volume-weighted precision.
✅ Entry Signals:
Long Entry: When price crosses above the upper VWMA band.
Short Entry: When price crosses below the lower VWMA band.
✅ Exit Conditions:
Profit Target: Positions close automatically at a 2% profit (customizable).
RSI-Based Exit:
Longs close when RSI < 30 (oversold).
Shorts close when RSI > 70 (overbought).
✅ Built-in Risk Management: Avoids greed-based exits by locking in profits early or exiting on reversal signals.
⚙️ User Inputs:
VWMA length (default: 200)
Deviation multiplier for bands (default: 3.0)
RSI length (default: 14)
Profit target in % (default: 2%)
🧠 How to Use:
Works best in strong trending markets.
Can be combined with higher-timeframe trend filters or volume analysis.
Suitable for both swing trading and intraday strategies.