Horizontal Lines from ArrayMy Love
//@version=5
indicator("Horizontal Lines from Array", overlay=true)
// Mảng chứa các mức giá cần vẽ đường ngang
// Nhập chuỗi giá cách nhau bằng dấu phẩy
input_str = input.string("3380,3370", "Mức giá (phẩy giữa các giá)")
// Hàm tách chuỗi thành mảng (tối đa 10 phần tử)
split_str_to_float_array(str) =>
str_array = str.split(str, ",")
result = array.new_float()
for i = 0 to array.size(str_array) - 1
s = array.get(str_array, i)
f = str.tonumber(s)
if not na(f)
array.push(result, f)
result
levels = split_str_to_float_array(input_str)
// Lặp và vẽ các đường ngang
for i = 0 to array.size(levels) - 1
y = array.get(levels, i)
line.new( x1 = bar_index,y1 = y, x2 = bar_index + 1,y2 = y,color = color.blue,style = line.style_dashed,width = 1,extend=extend.both)
Bill Williams Indicators
Williams Percent Range proOverview
Williams Percent Range Pro is a powerful divergence detection tool based on the Williams %R oscillator.
It automatically identifies and plots regular and hidden divergences between price action and the %R oscillator, providing traders with early indications of potential trend reversals or trend continuations.
This indicator enhances the classic Williams %R by adding intelligent divergence detection logic, customizable visualization, and integrated alert conditions — making it a highly versatile tool for both manual and automated trading.
Features
Automatic Divergence Detection
Regular Divergence (signals trend reversals)
Hidden Divergence (signals trend continuations)
Customizable Settings
Period length, source price, color customization for each divergence type
Visual Enhancements
Overbought, Mid, and Oversold levels (-20, -50, -80)
Shaded background for easier visual interpretation
Pivot Detection
Identifies key swing points on the Williams %R line for divergence comparison
Integrated Alerts
Set up alerts for each type of divergence without coding
Lightweight and Optimized
Designed for fast loading and efficient operation on any timeframe
How It Works
Williams %R Calculation
The script calculates the Williams %R as follows:
%R = 100 × (Close - Highest High over Period) ÷ (Highest High - Lowest Low)
This results in a value that moves between -100 and 0, indicating overbought and oversold conditions.
Pivot Detection
The indicator uses pivot highs and pivot lows on the %R line to determine important swing points.
Pivot logic is based on comparing neighboring candles (5 bars to the left and 5 bars to the right by default).
Divergence Detection
1. Regular Divergence
Regular Bullish Divergence:
Price makes a Lower Low
Williams %R makes a Higher Low
→ Signals potential upward reversal
Regular Bearish Divergence:
Price makes a Higher High
Williams %R makes a Lower High
→ Signals potential downward reversal
2. Hidden Divergence
Hidden Bullish Divergence:
Price makes a Higher Low
Williams %R makes a Lower Low
→ Signals potential upward continuation
Hidden Bearish Divergence:
Price makes a Lower High
Williams %R makes a Higher High
→ Signals potential downward continuation
Each type of divergence is plotted with a specific label and customizable color on the indicator.
Input Parameters
Input Description
Length Period length for Williams %R calculation (default: 14)
Source Data source (default: Close)
Show Regular Divergence Enable/disable regular divergence detection
Show Hidden Divergence Enable/disable hidden divergence detection
Regular Bullish Color Color for regular bullish divergence labels
Regular Bearish Color Color for regular bearish divergence labels
Hidden Bullish Color Color for hidden bullish divergence labels
Hidden Bearish Color Color for hidden bearish divergence labels
Visual Elements
Horizontal Lines:
-20: Overbought zone
-50: Mid-level (dashed line)
-80: Oversold zone
Background Shading:
Fills between -20 and -80 for better visual focus on active trading zones.
Divergence Labels:
Bull = Regular Bullish Divergence
Bear = Regular Bearish Divergence
H Bull = Hidden Bullish Divergence
H Bear = Hidden Bearish Divergence
Each label appears exactly at the pivot points of the Williams %R line, offset slightly for clarity.
Alerts
You can create TradingView alerts based on the following conditions:
Regular Bullish Divergence Detected
Regular Bearish Divergence Detected
Hidden Bullish Divergence Detected
Hidden Bearish Divergence Detected
This allows fully automated trading setups or mobile push notifications.
Example alert message:
"Williams %R Regular Bullish Divergence Detected"
Usage Tips
Entry Strategy:
Combine divergence signals with trend confirmation indicators like EMA/SMA, MACD, or Volume.
Exit Strategy:
Monitor when price reaches key resistance/support zones or overbought/oversold levels on the %R.
Higher Accuracy:
Always confirm divergences with price action patterns such as breakouts, candlestick formations, or trendline breaks.
Conclusion
The Williams Percent Range Pro indicator brings powerful divergence detection and customization features to a classic momentum oscillator.
It provides clear visual and alert-based trading signals that help you anticipate major turning points or trend continuations in any market and timeframe.
Whether you are a swing trader, day trader, or scalper, this tool can be an essential addition to your technical analysis toolkit.
Theonator Bank Volume Entry & Exit v2best of the best im telling you liek this shit slapps the bank in the head
Iconic Traders SessionsIconicTraders Sessions. D.D. indicatior, markiert die highs and lows (Asia & London Session)
Williams Percent Range proWilliams Percent Range with Divergences (Williams %R Div)
Description:
This indicator enhances the traditional Williams %R oscillator by detecting both Regular Divergence and Hidden Divergence directly on the %R line. It helps traders spot potential trend reversals and trend continuations with high precision.
Key Features:
Williams %R calculation (standard, normalized between -100 and 0).
Pivot-based detection of divergences:
Regular Bullish Divergence: Price makes a lower low, but %R makes a higher low → potential upward reversal.
Regular Bearish Divergence: Price makes a higher high, but %R makes a lower high → potential downward reversal.
Hidden Bullish Divergence: Price makes a higher low, but %R makes a lower low → potential trend continuation upward.
Hidden Bearish Divergence: Price makes a lower high, but %R makes a higher high → potential trend continuation downward.
Customizable settings:
Enable/disable Regular and Hidden Divergences separately.
Customize colors for each divergence type.
Visual plotting:
Divergence signals are marked with labels (Bull, Bear, H Bull, H Bear) directly on the %R panel.
Built-in alert conditions:
Instant alerts when a Regular or Hidden Divergence is detected.
Usage Recommendation:
Regular Divergences are best used to anticipate trend reversals.
Hidden Divergences are useful for confirming trend continuations.
Combining divergence detection with key support/resistance levels, candlestick patterns, or moving averages can significantly enhance trading accuracy.
IconicTradersSweepsThe indicater marks out the session high and low, so u can see if a session get sweept. IconicTradersSweeps. D.D.
PsicoTraders PRO - Versão Final (Otimizada)## ENGLISH VERSION
# PsicoTraders PRO - Smart Money & Risk Management (Optimized)
## Description
PsicoTraders PRO is an advanced indicator that combines traditional technical analysis, Smart Money concepts, and quantitative risk management to identify high-probability trading opportunities. Developed for traders seeking a structured and disciplined approach, this indicator provides precise signals with integrated risk management.
**Developed by Silvio Deusdara**
## How the Visual Elements Work
### Main Visual Components
**1. Entry Signals**
- **Green Background**: Indicates confirmed buy signal when all conditions are met
- **Red Background**: Indicates confirmed sell signal when all conditions are met
- **Detailed Labels**: Appear on the chart showing complete information about each signal, including:
- Entry price
- Stop Loss
- Take Profit levels (TP1, TP2, TP3)
- Recommended position size
- Suggested leverage
- Current volatility regime
- Fibonacci and Order Block confirmation
**2. Order Blocks**
- **Transparent Green Boxes**: Represent Bullish Order Blocks - areas where institutions placed significant buy orders
- **Transparent Red Boxes**: Represent Bearish Order Blocks - areas where institutions placed significant sell orders
- These boxes remain visible for a defined period (default: 50 bars) and are areas of interest for entries
**3. Liquidity Zones**
- **Horizontal Blue Lines**: Mark liquidity zones where traders' stops are concentrated
- **Upper Line**: High liquidity zone - area where sellers' stops are positioned
- **Lower Line**: Low liquidity zone - area where buyers' stops are positioned
**4. Fibonacci Levels**
- **Yellow/Orange Circles**: Mark the 0.618 Fibonacci levels (the most important for reversals)
- **Yellow Level**: 0.618 Fibonacci for uptrend
- **Orange Level**: 0.618 Fibonacci for downtrend
**5. Pivots and Reversal Points**
- **Red Triangles**: Mark pivot highs - potential reversal points to the downside
- **Green Triangles**: Mark pivot lows - potential reversal points to the upside
**6. Long-Term Trend**
- **Blue Line**: Represents the 200-period moving average, indicating the long-term trend
- Price above the line = uptrend
- Price below the line = downtrend
**7. Performance Table**
- Located in the upper right corner of the chart
- **Trend**: Shows the current direction (Up/Down/Sideways) with color coding
- **Volatility**: Displays the current regime (High/Medium/Low) with color coding
- **RSI**: Current value with color coding (red for overbought, green for oversold)
- **ATR**: Current volatility value
- **Kelly %**: Optimal percentage of capital to risk based on Kelly formula
- **Vol Ratio**: Volatility as a percentage of price
- **Fib 0.618**: Indicates if price is near the 0.618 Fibonacci level
- **Order Block**: Indicates if there are active Order Blocks on the chart
## Setup Instructions
1. **Add the Indicator to Your Chart**
- After adding the indicator, you'll see the visual elements appear on your chart
2. **Adjust Risk Parameters**
- Set "Account Balance (USDT)" to your actual trading account size
- Set "Risk per Trade (USDT)" to your desired risk amount per trade
- Set "Maximum Account Risk (%)" to your risk tolerance (recommended: 5-10%)
- Set "Historical Win Rate" to your actual win rate (if unknown, start with 0.50)
3. **Adjust Filter Settings**
- Enable/disable filters based on your trading style:
- Trend Filter: Recommended ON for trend following
- Volatility Filter: Recommended ON for most markets
- Session Filter: ON for stocks/forex, OFF for crypto
- Macro Filter: Recommended ON for alignment with long-term trend
- Fibonacci Filter: Recommended ON for better quality signals
4. **Customize Visual Settings**
- Adjust colors for buy/sell signals and Order Blocks if needed
- Enable/disable performance table based on preference
5. **Set Up Alerts**
- Create alerts for Buy Signals, Sell Signals, and Trailing Stop hits
- Use the pre-formatted alert messages for complete trade information
## How to Interpret the Visual Signals
### Buy Signals (Long)
A valid buy signal occurs when:
1. The chart background turns green
2. A detailed label appears below the current candle
3. Price is near a bullish Order Block (green box)
4. The performance table shows an uptrend
5. Ideally, price is near the 0.618 Fibonacci level (yellow circle)
### Sell Signals (Short)
A valid sell signal occurs when:
1. The chart background turns red
2. A detailed label appears above the current candle
3. Price is near a bearish Order Block (red box)
4. The performance table shows a downtrend
5. Ideally, price is near the 0.618 Fibonacci level (orange circle)
### Visual Risk Management
- Labels show exactly where to place stop loss and take profits
- Recommended position size is automatically calculated
- Trailing stop is visualized when activated
- Liquidity zones help identify areas where price may reverse
## Benefits of the Indicator
- **Complete Approach**: Combines technical analysis, Smart Money, and risk management
- **High-Quality Signals**: Multiple filters reduce false signals
- **Integrated Risk Management**: Automatic position and stop loss calculations
- **Clear Visualization**: Intuitive visual elements facilitate interpretation
- **Adaptability**: Works in multiple markets and timeframes
- **Alert System**: Notifications for entries, trailing stops, and approaching liquidity zones
This indicator was developed for traders seeking a disciplined and evidence-based approach to the market, combining the best of traditional technical analysis with modern Smart Money concepts and quantitative risk management.
Williams Percent Range proOverview
Williams Percent Range Pro is a powerful divergence detection tool based on the Williams %R oscillator.
It automatically identifies and plots regular and hidden divergences between price action and the %R oscillator, providing traders with early indications of potential trend reversals or trend continuations.
This indicator enhances the classic Williams %R by adding intelligent divergence detection logic, customizable visualization, and integrated alert conditions — making it a highly versatile tool for both manual and automated trading.
Features
Automatic Divergence Detection
Regular Divergence (signals trend reversals)
Hidden Divergence (signals trend continuations)
Customizable Settings
Period length, source price, color customization for each divergence type
Visual Enhancements
Overbought, Mid, and Oversold levels (-20, -50, -80)
Shaded background for easier visual interpretation
Pivot Detection
Identifies key swing points on the Williams %R line for divergence comparison
Integrated Alerts
Set up alerts for each type of divergence without coding
Lightweight and Optimized
Designed for fast loading and efficient operation on any timeframe
How It Works
Williams %R Calculation
The script calculates the Williams %R as follows:
%R = 100 × (Close - Highest High over Period) ÷ (Highest High - Lowest Low)
This results in a value that moves between -100 and 0, indicating overbought and oversold conditions.
Pivot Detection
The indicator uses pivot highs and pivot lows on the %R line to determine important swing points.
Pivot logic is based on comparing neighboring candles (5 bars to the left and 5 bars to the right by default).
Divergence Detection
1. Regular Divergence
Regular Bullish Divergence:
Price makes a Lower Low
Williams %R makes a Higher Low
→ Signals potential upward reversal
Regular Bearish Divergence:
Price makes a Higher High
Williams %R makes a Lower High
→ Signals potential downward reversal
2. Hidden Divergence
Hidden Bullish Divergence:
Price makes a Higher Low
Williams %R makes a Lower Low
→ Signals potential upward continuation
Hidden Bearish Divergence:
Price makes a Lower High
Williams %R makes a Higher High
→ Signals potential downward continuation
Each type of divergence is plotted with a specific label and customizable color on the indicator.
Input Parameters
Input Description
Length Period length for Williams %R calculation (default: 14)
Source Data source (default: Close)
Show Regular Divergence Enable/disable regular divergence detection
Show Hidden Divergence Enable/disable hidden divergence detection
Regular Bullish Color Color for regular bullish divergence labels
Regular Bearish Color Color for regular bearish divergence labels
Hidden Bullish Color Color for hidden bullish divergence labels
Hidden Bearish Color Color for hidden bearish divergence labels
Visual Elements
Horizontal Lines:
-20: Overbought zone
-50: Mid-level (dashed line)
-80: Oversold zone
Background Shading:
Fills between -20 and -80 for better visual focus on active trading zones.
Divergence Labels:
Bull = Regular Bullish Divergence
Bear = Regular Bearish Divergence
H Bull = Hidden Bullish Divergence
H Bear = Hidden Bearish Divergence
Each label appears exactly at the pivot points of the Williams %R line, offset slightly for clarity.
Alerts
You can create TradingView alerts based on the following conditions:
Regular Bullish Divergence Detected
Regular Bearish Divergence Detected
Hidden Bullish Divergence Detected
Hidden Bearish Divergence Detected
This allows fully automated trading setups or mobile push notifications.
Example alert message:
"Williams %R Regular Bullish Divergence Detected"
Usage Tips
Entry Strategy:
Combine divergence signals with trend confirmation indicators like EMA/SMA, MACD, or Volume.
Exit Strategy:
Monitor when price reaches key resistance/support zones or overbought/oversold levels on the %R.
Higher Accuracy:
Always confirm divergences with price action patterns such as breakouts, candlestick formations, or trendline breaks.
Conclusion
The Williams Percent Range Pro indicator brings powerful divergence detection and customization features to a classic momentum oscillator.
It provides clear visual and alert-based trading signals that help you anticipate major turning points or trend continuations in any market and timeframe.
Whether you are a swing trader, day trader, or scalper, this tool can be an essential addition to your technical analysis toolkit.
Williams Percent Range proWilliams Percent Range with Divergences (Williams %R Div)
Description:
This indicator enhances the traditional Williams %R oscillator by detecting both Regular Divergence and Hidden Divergence directly on the %R line. It helps traders spot potential trend reversals and trend continuations with high precision.
Key Features:
Williams %R calculation (standard, normalized between -100 and 0).
Pivot-based detection of divergences:
Regular Bullish Divergence: Price makes a lower low, but %R makes a higher low → potential upward reversal.
Regular Bearish Divergence: Price makes a higher high, but %R makes a lower high → potential downward reversal.
Hidden Bullish Divergence: Price makes a higher low, but %R makes a lower low → potential trend continuation upward.
Hidden Bearish Divergence: Price makes a lower high, but %R makes a higher high → potential trend continuation downward.
Customizable settings:
Enable/disable Regular and Hidden Divergences separately.
Customize colors for each divergence type.
Visual plotting:
Divergence signals are marked with labels (Bull, Bear, H Bull, H Bear) directly on the %R panel.
Built-in alert conditions:
Instant alerts when a Regular or Hidden Divergence is detected.
Usage Recommendation:
Regular Divergences are best used to anticipate trend reversals.
Hidden Divergences are useful for confirming trend continuations.
Combining divergence detection with key support/resistance levels, candlestick patterns, or moving averages can significantly enhance trading accuracy.
GCM Supreme Trading System Pro (With Golden Zone)Okay, bro! Here are some notes on your "GCM Supreme Trading System Pro (Dashboard + RSI)" indicator based on the Pine Script code you provided. Think of this as a breakdown of its components, logic, and how you might use it, along with some things to consider.
GCM Supreme Trading System Pro (Dashboard + RSI) - Notes
Overall Concept:
This indicator aims to provide an "all-in-one" visual dashboard and signal system by combining several technical analysis concepts:
Short-Term Trend: Using a fast EMA.
Volatility/Channel: High/Low plot with fill.
Sentiment: Background color based on price vs. EMA.
Price Structure/Pattern: Highlighting potential AMD phases.
Key Price Level: Previous day's specific Fibonacci zone (Golden Zone).
Momentum: RSI Overbought/Oversold status.
Volume Analysis: Identifying volume spikes.
Risk Assessment: Based on ATR volatility.
Signal Generation: Based on EMA direction change confirmed by candle color.
Centralized Summary: A dashboard showing the status of key components.
Key Components & How They Work:
Trend EMA (Length: 3 by default):
What: A very fast Exponential Moving Average of the specified source (close by default).
How: Plots the EMA line. Colors the line green if the EMA is moving up, red if moving down, gray if flat.
Usage: Provides a very quick view of the immediate price direction and momentum.
High/Low Channel Lines & Fill:
What: Plots the current bar's high and low.
How: The area between the high and low is filled. The fill color changes based on whether the Trend EMA is moving up (green fill), down (red fill), or is neutral (gray fill).
Usage: Visualizes the recent price range/volatility and ties it to the immediate trend direction.
Sentiment Background:
What: Colors the chart background.
How: Background is lightly colored green if the close is above the Trend EMA, and red if the close is below the Trend EMA.
Usage: Reinforces the current short-term bias based on price's position relative to the fast EMA.
AMD Pattern Candles:
What: Highlights specific candle patterns often associated with Accumulation, Manipulation, and Distribution phases.
How:
Accumulation (Aqua): Previous candle was Red, current candle is Green (Red -> Green).
Manipulation (Yellow): Previous candle was Green, current candle is Red (Green -> Red).
Distribution (Fuchsia): Two consecutive Red candles where the candle before the first Red was Not Red (Not Red -> Red -> Red).
Usage: Helps visually spot potential shifts in market behavior according to the AMD concept.
Previous Day's Fib Golden Zone (0.55-0.66):
What: Calculates a specific Fibonacci zone (between 55% and 66%) based on the previous day's range (High-Low).
How: Plots a horizontal box on the chart covering the calculated zone level. Uses the previous day's range direction (Green/Red candle) to determine if the zone is calculated up from the low (Green day) or down from the high (Red day).
Usage: Identifies a potential key retracement or support/resistance zone from the previous day's price action that may be relevant for the current day.
RSI (Relative Strength Index):
What: A classic momentum oscillator.
How: Calculates the RSI value based on the specified length and source. The dashboard shows the current value and flags it as Overbought (> OB level), Oversold (< OS level), or Neutral.
Usage: Provides context on momentum extremes. High RSI suggests strong upward momentum (potentially overextended), low RSI suggests strong downward momentum (potentially oversold).
Volume Spike Confirmation:
What: Compares current volume to its Moving Average.
How: Calculates a simple moving average of volume. Identifies a "Spike" if the current volume is significantly higher (multiplied by a factor) than the MA.
Usage: Provides a contextual check for increased activity accompanying price moves. (Note: In the current script, this is calculated and shown on the dashboard but not directly used in the signal label logic, though it could be added).
Risk Assessment (ATR):
What: Uses the Average True Range.
How: Calculates the ATR for the specified length. Compares the current ATR to a longer-term average ATR. Flags "High Risk" if the current ATR is significantly higher than the average.
Usage: Gives an indication of current volatility relative to recent history, which can inform stop-loss placement or position sizing.
Signals (Buy/Sell Labels):
What: Plots "BUY" or "SELL" labels on the chart.
How:
BUY Signal: Triggers when the Trend EMA starts moving Up on the previous bar AND the current bar is Green (close > open).
SELL Signal: Triggers when the Trend EMA starts moving Down on the previous bar AND the current bar is Red (close < open).
Usage: These are your potential entry triggers. They indicate that the fast EMA trend has just changed direction and the current candle is confirming that move with its color.
Dashboard:
What: A 2x5 table displayed on the chart (bottom right by default).
How: Shows the current status of:
Trend (Bull/Bear/Neutral)
Volume (Spike/Normal)
Last Signal (🟢 BUY, 🔴 SELL, or None)
Risk (High/Normal based on ATR)
RSI (Overbought/Oversold/Neutral + Current Value)
Usage: Provides a quick, centralized summary of multiple indicator components without having to visually check every detail on the chart or separate panes.
How to Potentially Use It (Example Interpretation):
Look for a BUY signal (Green label) when:
The dashboard shows "🟢 BUY" as the Last Signal.
Consider additional confirmation: Is Volume status "Spike"? Is Risk "Normal"? Is RSI not "Overbought" (or perhaps just coming out of "Oversold" territory)? Is the price above/interacting positively with the Golden Zone?
Look for a SELL signal (Red label) when:
The dashboard shows "🔴 SELL" as the Last Signal.
Consider additional confirmation: Is Volume status "Spike"? Is Risk "Normal"? Is RSI not "Oversold" (or perhaps just coming out of "Overbought" territory)? Is the price below/interacting negatively with the Golden Zone?
Use the Sentiment Background and High/Low Channel Fill to quickly see the immediate trend and volatility context.
Watch AMD candles around key levels (like the Golden Zone or signal triggers) for potential pattern confirmation.
Check the Dashboard frequently for a summary of all these factors, even without a specific signal.
Strengths & Potential Benefits:
Comprehensive View: Integrates multiple popular trading concepts into a single indicator.
Visual Clarity: Uses colors, fills, labels, and a dashboard for easy interpretation.
Customizable: Inputs allow tuning the sensitivity of the EMA, Volume, ATR, and RSI to different assets/timeframes.
Dashboard Efficiency: Saves time by consolidating key status points.
Non-Repainting Signals: The buy/sell labels trigger and stay based on closed bar data.
Important Considerations & Limitations:
Fast EMA Sensitivity: An EMA length of 3 is very fast and prone to whipsaws, especially in choppy or ranging markets. Signals based solely on this could be frequent and unreliable in non-trending conditions.
Signal Logic: The core signal is only based on EMA direction change + candle color. While simple, it might miss opportunities or generate signals without broader market confirmation (like strong volume, favorable RSI position, or reaction at key levels). The dashboard provides these other factors as context, but they aren't required for the signal label in the current code.
Golden Zone Reliance: The previous day's Fib zone is just one potential level. It won't always be respected, and its relevance might vary significantly across different markets and timeframes.
AMD Patterns: The defined AMD patterns are specific. The market's "real" accumulation/manipulation/distribution might manifest in more complex ways.
Dashboard as Summary, Not Signal: Remember the dashboard shows the current status of all components on the last bar, but the BUY/SELL signal labels are based on a specific historical event (previous bar's EMA turn). You need to look at both: the label for the trigger, and the dashboard for the confluence of other factors right now.
Not a Standalone System: While called a "Trading System," no single indicator guarantees profitability. This tool provides signals and context, but requires a robust trading plan including stop losses, profit targets, position sizing, and potentially confluence with other analysis methods.
Timeframe Dependency: The ideal settings (EMA length, RSI length, etc.) will likely differ significantly between timeframes (e.g., 1-minute vs. 4-hour). Testing and optimization are crucial.
In Summary:
The "GCM Supreme Trading System Pro (Dashboard + RSI)" is a well-designed indicator that consolidates several useful analysis tools into a single view. Its strength lies in providing quick visual context and a clear signal trigger based on short-term trend shifts. However, like any indicator, it's not perfect. Its effectiveness will largely depend on the market conditions, the chosen settings, and how it's integrated into a comprehensive trading strategy, using the dashboard components as essential confirmation and risk assessment tools alongside the primary signal labels.
Scalper Signal PRO (EMA + RSI + Stoch)How to use it
Buy Signal:
. EMA 5 crosses above EMA 13
. Price is above EMA 50
. RSI near or just above 30
Sell Signal:
. EMA 5 crosses below EMA 13
. Price is below EMA 50
. RSI near or just below 30
Scalper Signal PRO (EMA + RSI + Stoch)//@version=5
indicator("Scalper Signal PRO (EMA + RSI + Stoch)", overlay=true)
// === INPUTS ===
emaFastLen = input.int(5, "EMA Fast")
emaSlowLen = input.int(13, "EMA Slow")
rsiLen = input.int(14, "RSI Length")
rsiBuy = input.int(30, "RSI Buy Level")
rsiSell = input.int(70, "RSI Sell Level")
kPeriod = input.int(5, "Stoch K")
dPeriod = input.int(3, "Stoch D")
slowing = input.int(3, "Stoch Smoothing")
// === SESSION TIME ===
sessionStart = timestamp ("GMT+8", year, month, dayofmonth, 8, 0)
sessionEnd = timestamp("GMT+8" ,year, month, dayofmonth, 18, 0)
withinSession = time >= sessionStart and time <= sessionEnd
// === LOGIC ===
emaFast = ta.ema(close, emaFastLen)
emaSlow = ta.ema(close, emaSlowLen)
emaBullish = emaFast > emaSlow and ta.crossover(emaFast, emaSlow)
emaBearish = emaFast < emaSlow and ta.crossunder(emaFast, emaSlow)
rsi = ta.rsi(close, rsiLen)
k = ta.sma(ta.stoch(close, high, low, kPeriod), slowing)
d = ta.sma(k, dPeriod)
buyCond = emaBullish and rsi < rsiBuy and k > d and withinSession
sellCond = emaBearish and rsi > rsiSell and k < d and withinSession
// === PLOTS ===
showSignals = input.bool(true, "Show Buy/Sell Signals?")
plotshape(showSignals and buyCond, location=location.belowbar, style=shape.labelup, color=color.green, text="BUY", title="Buy Signal")
plotshape(showSignals and sellCond, location=location.abovebar, style=shape.labeldown, color=color.red, text="SELL", title="Sell Signal")
plot(emaFast, "EMA Fast", color=color.orange)
plot(emaSlow, "EMA Slow", color=color.blue)
// === ALERTS ===
alertcondition(buyCond, title="Buy Alert", message="Scalper PRO Buy Signal")
alertcondition(sellCond, title="Sell Alert", message="Scalper PRO Sell Signal")
// === DASHBOARD ===
var table dash = table.new(position.top_right, 2, 5, frame_color=color.gray, frame_width=1)
bg = color.new(color.black, 85)
table.cell(dash, 0, 0, "Scalper PRO", bgcolor=bg, text_color=color.white, text_size=size.normal)
table.cell(dash, 0, 1, "Trend", bgcolor=bg)
table.cell(dash, 1, 1, emaFast > emaSlow ? "Bullish" : "Bearish", bgcolor=emaFast > emaSlow ? color.green : color.red, text_color=color.white)
table.cell(dash, 0, 2, "RSI", bgcolor=bg)
table.cell(dash, 1, 2, str.tostring(rsi, "#.0"), bgcolor=color.gray, text_color=color.white)
table.cell(dash, 0, 3, "Stoch K/D", bgcolor=bg)
table.cell(dash, 1, 3, str.tostring(k, "#.0") + "/" + str.tostring(d, "#.0"), bgcolor=color.navy, text_color=color.white)
table.cell(dash, 0, 4, "Session", bgcolor=bg)
table.cell(dash, 1, 4, withinSession ? "LIVE" : "OFF", bgcolor=withinSession ? color.green : color.red, text_color=color.white)
Scalper Signal PRO (EMA + RSI + Stoch)//@version=5
indicator("Scalper Signal PRO (EMA + RSI + Stoch)", overlay=true)
// === INPUTS ===
emaFastLen = input.int(5, "EMA Fast")
emaSlowLen = input.int(13, "EMA Slow")
rsiLen = input.int(14, "RSI Length")
rsiBuy = input.int(30, "RSI Buy Level")
rsiSell = input.int(70, "RSI Sell Level")
kPeriod = input.int(5, "Stoch K")
dPeriod = input.int(3, "Stoch D")
slowing = input.int(3, "Stoch Smoothing")
// === SESSION TIME ===
sessionStart = timestamp ("GMT+8", year, month, dayofmonth, 8, 0)
sessionEnd = timestamp("GMT+8" ,year, month, dayofmonth, 18, 0)
withinSession = time >= sessionStart and time <= sessionEnd
// === LOGIC ===
emaFast = ta.ema(close, emaFastLen)
emaSlow = ta.ema(close, emaSlowLen)
emaBullish = emaFast > emaSlow and ta.crossover(emaFast, emaSlow)
emaBearish = emaFast < emaSlow and ta.crossunder(emaFast, emaSlow)
rsi = ta.rsi(close, rsiLen)
k = ta.sma(ta.stoch(close, high, low, kPeriod), slowing)
d = ta.sma(k, dPeriod)
buyCond = emaBullish and rsi < rsiBuy and k > d and withinSession
sellCond = emaBearish and rsi > rsiSell and k < d and withinSession
// === PLOTS ===
showSignals = input.bool(true, "Show Buy/Sell Signals?")
plotshape(showSignals and buyCond, location=location.belowbar, style=shape.labelup, color=color.green, text="BUY", title="Buy Signal")
plotshape(showSignals and sellCond, location=location.abovebar, style=shape.labeldown, color=color.red, text="SELL", title="Sell Signal")
plot(emaFast, "EMA Fast", color=color.orange)
plot(emaSlow, "EMA Slow", color=color.blue)
// === ALERTS ===
alertcondition(buyCond, title="Buy Alert", message="Scalper PRO Buy Signal")
alertcondition(sellCond, title="Sell Alert", message="Scalper PRO Sell Signal")
// === DASHBOARD ===
var table dash = table.new(position.top_right, 2, 5, frame_color=color.gray, frame_width=1)
bg = color.new(color.black, 85)
table.cell(dash, 0, 0, "Scalper PRO", bgcolor=bg, text_color=color.white, text_size=size.normal)
table.cell(dash, 0, 1, "Trend", bgcolor=bg)
table.cell(dash, 1, 1, emaFast > emaSlow ? "Bullish" : "Bearish", bgcolor=emaFast > emaSlow ? color.green : color.red, text_color=color.white)
table.cell(dash, 0, 2, "RSI", bgcolor=bg)
table.cell(dash, 1, 2, str.tostring(rsi, "#.0"), bgcolor=color.gray, text_color=color.white)
table.cell(dash, 0, 3, "Stoch K/D", bgcolor=bg)
table.cell(dash, 1, 3, str.tostring(k, "#.0") + "/" + str.tostring(d, "#.0"), bgcolor=color.navy, text_color=color.white)
table.cell(dash, 0, 4, "Session", bgcolor=bg)
table.cell(dash, 1, 4, withinSession ? "LIVE" : "OFF", bgcolor=withinSession ? color.green : color.red, text_color=color.white)
[AO Pro] 震荡量能指标三合一报警系统📘" Triple-Combo Oscillator Alert System" User Guide (Ideal for Momentum Shifts)
🔍 Script Overview
The AO (Awesome Oscillator) is a histogram-based indicator designed to reflect changes in market momentum, making it useful for identifying shifts between short- and long-term trend strength. This script combines three classic AO patterns and triggers alerts automatically with one click.
✅ Three Key Features
1️⃣ Zero Line Crossover:
- Crosses above 0 = Bullish
- Drops below 0 = Bearish
→ Signals a momentum shift between bulls and bears.
2️⃣ Twin Peaks Structure:
- AO forms a High-Low-High or Low-High-Low sequence
→ Indicates potential tops or bottoms.
3️⃣ Saucer Setup:
- AO turns around slowly after a decline but remains in the negative/positive zone
→ Suggests a possible trend reversal.
🛠 How to Use
1. Add the script to your chart and adjust AO parameters (e.g., fast=5, slow=34).
2. Enable the alert module.
3. Set up Webhook notifications for automatic alerts.
📈 Recommended Strategy Combinations
| Scenario | Suggested Tools | Recommended Timeframes |
|------------------|------------------------|-------------------------|
| Trend Reversal | EMA / MACD | 1H / 4H |
| Structure Break | Bollinger Bands / Candlestick Patterns | 15min / 1H |
| Top/Bottom Detection | RSI / OBV | 5min / 15min |
🧠 Pro Tips
- Twin peak patterns often appear alongside RSI divergences.
- Saucer reversals are powerful, ideal for dip-buying strategies.
- Works best when combined with volume indicators (e.g., CMF, OBV).
NIKHIL ROY INDICATOR + Reversal Trap Entry/@version=5
indicator("NIKHIL ROY INDICATOR + Reversal Trap Entry", overlay=true)
// === SETTINGS ===
res_tf = "15"
lookback = 50
// === PREVIOUS 15min CANDLE ===
prevHigh = request.security(syminfo.tickerid, res_tf, high )
prevLow = request.security(syminfo.tickerid, res_tf, low )
prevOpen = request.security(syminfo.tickerid, res_tf, open )
prevClose = request.security(syminfo.tickerid, res_tf, close )
// Draw previous 15m candle (body and wick)
plot(prevHigh, "Prev High", color=color.gray, linewidth=1)
plot(prevLow, "Prev Low", color=color.gray, linewidth=1)
bgcolor((timeframe.isintraday and timeframe.period == "15") ? na : color.new(color.gray, 90))
// === SUPPORT & RESISTANCE ===
var float support = na
var float resistance = na
pivotLow = ta.pivotlow(low, 5, 5)
pivotHigh = ta.pivothigh(high, 5, 5)
if not na(pivotLow)
support := pivotLow
if not na(pivotHigh)
resistance := pivotHigh
plot(support, "Support", color=color.green, linewidth=2, style=plot.style_linebr)
plot(resistance, "Resistance", color=color.red, linewidth=2, style=plot.style_linebr)
// === SWING BREAK DETECTION ===
swingHighBreak = high > resistance and high <= resistance
swingLowBreak = low < support and low >= support
// === BREAKOUT FAILURE ===
breakoutFailure = swingHighBreak and close < resistance
breakdownFailure = swingLowBreak and close > support
// === RETEST AFTER WEAKNESS ===
retestSell = close < resistance and high > resistance and close < open
retestBuy = close > support and low < support and close > open
// === SIGNALS ===
// SELL on resistance retest + weakness
sellSignal = retestSell
// SELL if breakout fails
trapSell = breakoutFailure
// BUY on support retest + strength
buySignal = retestBuy
// BUY if breakdown fails
trapBuy = breakdownFailure
// === PLOT SIGNALS ===
plotshape(sellSignal, title="Sell Weakness", location=location.abovebar, color=color.red, style=shape.arrowdown, size=size.large, text="SELL")
plotshape(trapSell, title="Trap Sell", location=location.abovebar, color=color.red, style=shape.arrowdown, size=size.large, text="TRAP SELL")
plotshape(buySignal, title="Buy Strength", location=location.belowbar, color=color.green, style=shape.arrowup, size=size.large, text="BUY")
plotshape(trapBuy, title="Trap Buy", location=location.belowbar, color=color.green, style=shape.arrowup, size=size.large, text="TRAP BUY")
Scalping Súper Oscilador by Rouro [Actualizado]This scalping strategy is designed to detect overbought and oversold zones using a custom Super Oscillator that combines five classic indicators: RSI, Stochastic, CCI, ROC, and Williams %R, with adjustable thresholds.
⚙️ How does it work? Entry signal: Buy: when the oscillator rises from the oversold zone (-0.8) and the candlestick is bullish. Sell: when the oscillator goes down from the overbought zone (0.8) and the candlestick is bearish. Time filter: possibility to operate only in a configurable time slot (e.g. from 10:00 to 12:00 local time). Dynamic SL/TP: Stop Loss is calculated using the low/high of the last X candles, and the Take Profit according to a configurable Risk/Reward Ratio. One operation per signal, with no overlaps.
🧠 Visuals and Panels: Visual oscillator with smooth EMA. Indicator traffic light that shows the individual status (green, red or grey) on the screen. Real-time statistics table: Backtest start date.
🧩 Full customization:
Periods and levels for each indicator.
Oscillator top/bottom level.
Schedule settings.
Option to show or hide the oscillator baseline.
CryptoQuebec Suite// This source code is subject to the terms of the Mozilla Public License 2.0 at mozilla.org
// Crypto Quebec & StefB.
//@version=6
indicator("CryptoQuebec Suite", overlay = true, max_labels_count = 500, max_lines_count = 500, max_boxes_count = 500, max_bars_back = 500)
//strategy("UT BOT Amélioré pour le Day Trading Crypto", overlay=true, initial_capital=1000, default_qty_type=strategy.percent_of_equity, default_qty_value=100)
// Version 2.0 order block ajustable colors
// Version 2.1 draw swing High/low
// Version 2.2 Changed the wording of "Area of interest" for "Premium Zone" and "Discount Zone"
// Version 2.3 Added the price to the auto fib levels.
// Version 2.4 Correction. Added 3 digits after the dot of the auto fib. This was lost when the price has been added.
// Version 2.4.01 Added few fib levels. (0, -0.272, -0.414, -0.618).
// Version 2.4.02 Added few fib levels. (1, 1.272, 1.414, 1.618).
// Version 2.4.03 Made a small change in the label of 240L, 240H, DL and DH. Change 240 for 4h and H/L for Lo/Hi
// Version 2.4.04 Added digits after the dot for more price precision into the Fib levels.
// Version 2.4.05 Added Entry long/short indicator base on EMA. Also added the trailing stop line.
// Version 2.4.06 Added Trail Stop enable/disable option. Moved the Buy/Sell label farther from the candles.
// Version 2.4.07 Added Trend info table with active trading session
// Version 2.4.08 Small adjustment in the trend table and FIB lines more visible.
// Version 2.4.09 Changed the indicator name for CryptoQuebe Suite.
//---------------------------------------------------------------------------------------------------------------------
//CONSTANTS & STRINGS & INPUTS
//---------------------------------------------------------------------------------------------------------------------
BULLISH = +1
BEARISH = -1
showHighLowSwingsTooltip = 'Highlight most recent strong and weak high/low points on the chart'
bullC = input.color(defval = #14D990, title = "Bull Color", group = "Smart Money Concepts", inline = "7")
bearC = input.color(defval = #F24968, title = "Bear Color", group = "Smart Money Concepts", inline = "7")
showInt = input.bool(defval = true, title = "Show Internals", group = "Smart Money Concepts")
intSens = input.int(3, "Internals Sensitivity", options = , group = "Smart Money Concepts", inline = "20")
intStru = input.string(defval = "All", title = "Internal Structure", options = , inline = "30", group = "Smart Money Concepts")
showExt = input.bool(defval = true, title = "Show Externals" ,group = "Smart Money Concepts")
extSens = input.int(25, "Externals Sensitivity", options = ,group = "Smart Money Concepts", inline = "21")
extStru = input.string(defval = "All", title = "External Structure", options = , inline = "31", group = "Smart Money Concepts")
showOB = input.bool(defval = true, title = "Show Order Blocks" ,group = "Swing Blocks")
//----------------------------------------------
//showHighLowSwingsInput = input(true, 'Show Strong/Weak High/Low', group = "Smart Money Concepts", tooltip = showHighLowSwingsTooltip)
BullOBColor = input.color(color.new(#3179f5, 80), 'Internal Bullish OB',group = "Swing Blocks")
BearOBColor = input.color(color.new(#f77c80, 80), 'Internal Bearish OB',group = "Swing Blocks")
//---------------------------------------------------------------------------
showLast = input.int(defval = 10, title = "Swing Order Blocks", minval = 0, group = "Swing Blocks")
showHHLH = input.bool(defval = true, title = "Show HH/LH", group = "Swing Blocks")
showHLLL = input.bool(defval = true, title = "Show LH/LL", group = "Swing Blocks")
showAOE = input.bool(defval = true, title = "Show Premium/Discount", group = "Swing Blocks")
//showAOE = input.bool(defval = true, title = "Show Area of Interest", group = "Swing Blocks")
show1D = input.bool(defval = true, title = "Show Previous Day High", group = "High/Low")
show1DLab = input.bool(defval = true, title = "Show 1 Day Labels", group = "High/Low")
show4H = input.bool(defval = true, title = "Show 4 Hour High", group = "High/Low")
show4hLab = input.bool(defval = true, title = "Show 4 Hour Labels", group = "High/Low")
showFVG = input.bool(defval = true, title = "Show Fair Value Gaps", group = "FVG")
contract = input.bool(defval = false, title = "Contract Violated FVG", group = "FVG")
closeOnly = input.bool(defval = false, title = "Show Closest Up/Down FVG Only", group = "FVG")
fvgcol = input.color(defval = #F2B807, title = "FVG Color", group = "FVG")
fvgtra = input.int(defval = 80, minval = 0, maxval = 100, title = "FVG Transparency", group = "FVG")
showFibs = input.bool(defval = true, title = "Show Auto Fibs", group = "Auto Fibs")
// extSensFibs = input.int(25, "Fibs Sensitivity", options = , group = "Auto Fibs", inline = "22")
show0_618 = input.bool(defval = true, title = "", inline = "1", group = "Auto Fibs")
show0_414 = input.bool(defval = true, title = "", inline = "2", group = "Auto Fibs")
show0_272 = input.bool(defval = true, title = "", inline = "3", group = "Auto Fibs")
show0 = input.bool(defval = true, title = "", inline = "4", group = "Auto Fibs")
show236 = input.bool(defval = true, title = "", inline = "5", group = "Auto Fibs")
show382 = input.bool(defval = true, title = "", inline = "6", group = "Auto Fibs")
show5 = input.bool(defval = true, title = "", inline = "7", group = "Auto Fibs")
show618 = input.bool(defval = true, title = "", inline = "8", group = "Auto Fibs")
show65 = input.bool(defval = true, title = "", inline = "9", group = "Auto Fibs")
show786 = input.bool(defval = true, title = "", inline = "10", group = "Auto Fibs")
show1 = input.bool(defval = true, title = "", inline = "11", group = "Auto Fibs")
show1_272 = input.bool(defval = true, title = "", inline = "12", group = "Auto Fibs")
show1_414 = input.bool(defval = true, title = "", inline = "13", group = "Auto Fibs")
show1_618 = input.bool(defval = true, title = "", inline = "14", group = "Auto Fibs")
fib1 = input.float(defval = -0.618, title = "", minval = -0.618, step = 0.01, inline = "1", group = "Auto Fibs")
fib2 = input.float(defval = -0.414, title = "", minval = -0.618, step = 0.01, inline = "2", group = "Auto Fibs")
fib3 = input.float(defval = -0.272, title = "", minval = -0.618, step = 0.01, inline = "3", group = "Auto Fibs")
fib4 = input.float(defval = 0, title = "", minval = 0, step = 0.01, inline = "4", group = "Auto Fibs")
fib5 = input.float(defval = .236, title = "", minval = 0, step = 0.01, inline = "5", group = "Auto Fibs")
fib6 = input.float(defval = .382, title = "", minval = 0, step = 0.01, inline = "6", group = "Auto Fibs")
fib7 = input.float(defval = .5, title = "", minval = 0, step = 0.01, inline = "7", group = "Auto Fibs")
fib8 = input.float(defval = .618, title = "", minval = 0, step = 0.01, inline = "8", group = "Auto Fibs")
fib9 = input.float(defval = .65, title = "", minval = 0, step = 0.01, inline = "9", group = "Auto Fibs")
fib10 = input.float(defval = .786, title = "", minval = 0, step = 0.01, inline = "10", group = "Auto Fibs")
fib11 = input.float(defval = 1, title = "", minval = 0, step = 0.01, inline = "11", group = "Auto Fibs")
fib12 = input.float(defval = 1.272, title = "", minval = 0, step = 0.01, inline = "12", group = "Auto Fibs")
fib13 = input.float(defval = 1.414, title = "", minval = 0, step = 0.01, inline = "13", group = "Auto Fibs")
fib14 = input.float(defval = 1.618, title = "", minval = 0, step = 0.01, inline = "14", group = "Auto Fibs")
fib1col = input.color(title = "", defval = color.orange, inline = "1", group = "Auto Fibs")
fib2col = input.color(title = "", defval = color.orange, inline = "2", group = "Auto Fibs")
fib3col = input.color(title = "", defval = color.orange, inline = "3", group = "Auto Fibs")
fib4col = input.color(title = "", defval = color.gray, inline = "4", group = "Auto Fibs")
fib5col = input.color(title = "", defval = color.white, inline = "5", group = "Auto Fibs")
fib6col = input.color(title = "", defval = color.white, inline = "6", group = "Auto Fibs")
fib7col = input.color(title = "", defval = color.red, inline = "7", group = "Auto Fibs")
fib8col = input.color(title = "", defval = color.green, inline = "8", group = "Auto Fibs")
fib9col = input.color(title = "", defval = color.green, inline = "9", group = "Auto Fibs")
fib10col = input.color(title = "", defval = color.white, inline = "10", group = "Auto Fibs")
fib11col = input.color(title = "", defval = color.gray, inline = "11", group = "Auto Fibs")
fib12col = input.color(title = "", defval = color.orange, inline = "12", group = "Auto Fibs")
fib13col = input.color(title = "", defval = color.orange, inline = "13", group = "Auto Fibs")
fib14col = input.color(title = "", defval = color.orange, inline = "14", group = "Auto Fibs")
//---------------------------------------------------------------------------------------------------------------------
//DATA STRUCTURES & VARIABLES
//---------------------------------------------------------------------------------------------------------------------
// @type UDT representing last swing extremes (top & bottom)
// @field top last top swing price
// @field bottom last bottom swing price
// @field barTime last swing bar time
// @field barIndex last swing bar index
// @field lastTopTime last top swing time
// @field lastBottomTime last bottom swing time
type trailingExtremes
float top
float bottom
int barTime
int barIndex
int lastTopTime
int lastBottomTime
// @type UDT representing trend bias
// @field bias BULLISH or BEARISH
type trend
int bias
var bigData = map.new()
// @variable swing trend bias
var trend swingTrend = trend.new(0)
// @variable last trailing swing high and low
var trailingExtremes trailing = trailingExtremes.new()
// @variable color for swing bullish structures
var swingBullishColor = color.green //styleInput == MONOCHROME ? MONO_BULLISH : swingBullColorInput
// @variable color for swing bearish structures
var swingBearishColor = color.red //styleInput == MONOCHROME ? MONO_BEARISH : swingBearColorInput
if bigData.size() == 0
bigData.put("moving", 0)
bigData.put("upaxis", 0.0)
bigData.put("upaxis2", 0)
bigData.put("dnaxis", 0.0)
bigData.put("dnaxis2", 0)
bigData.put("upside", 1)
bigData.put("downside", 1)
= request.security(syminfo.tickerid, "1D", [high , low , high, low, time , time])
var highArr = array.new_float(), var lowArr = array.new_float()
var timeArr = array.new_int (), var volArr = array.new_float()
var closeArr = array.new_float(), var openArr = array.new_float()
highArr.unshift(high), lowArr.unshift(low)
timeArr.unshift(time), volArr.unshift(volume)
closeArr.unshift(close), openArr.unshift(open)
type rollingTF
float highTF = 0
float lowTF = 1e8
int highTFt = 0
int lowTFt = 0
float volTF = 0
map rTFdraw
map rTFlabel
// Convert time period in text
f_convert_tf_to_text(tf) =>
tf == "240" ? "H4" : tf == "1D" ? "D" : tf == "60" ? "1h" : tf == "15" ? "15m" : tf
// Create the labels fo each level
offset = 10 // Ajustez cette valeur selon le décalage souhaité
// Ajust the label position in case of overide
f_adjust_label_position(x, offset) =>
x + offset
// @function tfDraw
// @param tfDiff Specifies the timeframe difference for the high/low calculations.
// @param showRollingLab Indicates whether to display rolling labels for timeframes.
// @param tf Specifies the timeframe as a string.
// @param showLevels Determines if the high/low levels for the timeframe should be shown.
// @returns A tuple with the total volume (TFhrdata.volTF) and the rolling volume array (volRolling).
method tfDraw(int tfDiff, bool showRollingLab, string tf, bool showLevels) =>
TFhrdata = rollingTF.new(), var volRolling = array.new()
if highArr.size() > tfDiff
for i = 0 to tfDiff
if showLevels and barstate.islast
getHigh = highArr.get(i), getLow = lowArr.get(i),
getTime = timeArr.get(i)
TFhrdata.highTF := math.max(TFhrdata.highTF, getHigh)
TFhrdata.lowTF := math.min(TFhrdata.lowTF , getLow )
if TFhrdata.highTF == getHigh
TFhrdata.highTFt := timeArr.get(i)
if TFhrdata.lowTF == getLow
TFhrdata.lowTFt := timeArr.get(i)
TFhrdata.volTF += volArr.get(i)
volRolling.push(TFhrdata.volTF)
var lineDraw = rollingTF.new(rTFdraw = map.new(), rTFlabel = map.new())
if showLevels
switch lineDraw.rTFdraw.size() == 0
true => lineDraw.rTFdraw.put("High", line.new(TFhrdata.highTFt, TFhrdata.highTF, time, TFhrdata.highTF,
xloc = xloc.bar_time, color = color.aqua)),
lineDraw.rTFdraw.put("Low" , line.new(TFhrdata.lowTFt , TFhrdata.lowTF , time, TFhrdata.lowTF ,
xloc = xloc.bar_time, color = color.aqua))
=> lineDraw.rTFdraw.get("High").set_xy1(TFhrdata.highTFt, TFhrdata.highTF),
lineDraw.rTFdraw.get("High").set_xy2(time, TFhrdata.highTF),
lineDraw.rTFdraw.get("Low").set_xy1(TFhrdata.lowTFt, TFhrdata.lowTF),
lineDraw.rTFdraw.get("Low").set_xy2(time, TFhrdata.lowTF)
if showRollingLab
switch lineDraw.rTFlabel.size() == 0
true => lineDraw.rTFlabel.put("High", label.new(f_adjust_label_position(bar_index, offset), TFhrdata.highTF, xloc = xloc.bar_time, textcolor = color.aqua, text = f_convert_tf_to_text(tf) + " Hi", style = label.style_label_left, size = size.normal, color = #00000000)),
lineDraw.rTFlabel.put("Low", label.new(f_adjust_label_position(bar_index, offset), TFhrdata.lowTF, xloc = xloc.bar_time, textcolor = color.aqua, text = f_convert_tf_to_text(tf) + " Lo", style = label.style_label_left, size = size.normal, color = #00000000))
=> lineDraw.rTFlabel.get("High") .set_xy(time, TFhrdata.highTF),
lineDraw.rTFlabel.get("Low") .set_xy(time, TFhrdata.lowTF)
// @function tfDrawLower
// @param showRollingLab Indicates whether to display rolling labels for lower timeframes.
// @param tf Specifies the lower timeframe as a string.
// @param showLevels Determines if the high/low levels for the lower timeframe should be shown.
// @returns (volume and volume array)
tfDrawLower(bool showRollingLab, simple string tf, bool showLevels) =>
simple int end = switch tf
"240" => 240
"1D" => 1440
= request.security_lower_tf(syminfo.tickerid, "1", )
var oArr = array.new_float()
var hArr = array.new_float()
var lArr = array.new_float()
var cArr = array.new_float()
var vArr = array.new_float()
var tArr = array.new_int()
TFhrdata = rollingTF.new(), var volRolling = array.new()
if h.size() > 0
for i = 0 to h.size() - 1
oArr.push(o.get(i))
hArr.push(h.get(i))
lArr.push(l.get(i))
cArr.push(c.get(i))
vArr.push(v.get(i))
tArr.push(t.get(i))
if hArr.size() > end
oArr.shift()
hArr.shift()
lArr.shift()
cArr.shift()
vArr.shift()
tArr.shift()
for i = 0 to hArr.size() - 1
if showLevels
getHigh = hArr.get(i), getLow = lArr.get(i),
getTime = tArr.get(i)
TFhrdata.highTF := math.max(TFhrdata.highTF, getHigh)
TFhrdata.lowTF := math.min(TFhrdata.lowTF , getLow)
if TFhrdata.highTF == getHigh
TFhrdata.highTFt := tArr.get(i)
if TFhrdata.lowTF == getLow
TFhrdata.lowTFt := tArr.get(i)
TFhrdata.volTF += vArr.get(i)
volRolling.push(TFhrdata.volTF)
var lineDraw = rollingTF.new(rTFdraw = map.new(), rTFlabel = map.new())
if showLevels
switch lineDraw.rTFdraw.size() == 0
true => lineDraw.rTFdraw.put("High", line.new(TFhrdata.highTFt, TFhrdata.highTF, time, TFhrdata.highTF,
xloc = xloc.bar_time, color = color.aqua)),
lineDraw.rTFdraw.put("Low" , line.new(TFhrdata.lowTFt , TFhrdata.lowTF , time, TFhrdata.lowTF ,
xloc = xloc.bar_time, color = color.aqua))
=> lineDraw.rTFdraw.get("High").set_xy1(TFhrdata.highTFt, TFhrdata.highTF),
lineDraw.rTFdraw.get("High").set_xy2(time, TFhrdata.highTF),
lineDraw.rTFdraw.get("Low").set_xy1(TFhrdata.lowTFt, TFhrdata.lowTF),
lineDraw.rTFdraw.get("Low").set_xy2(time, TFhrdata.lowTF)
if showRollingLab
switch lineDraw.rTFlabel.size() == 0
true => lineDraw.rTFlabel.put("High", label.new(f_adjust_label_position(bar_index, 0), TFhrdata.highTF, xloc = xloc.bar_time, textcolor = color.aqua, text = f_convert_tf_to_text(tf) + " Hi", style = label.style_label_left, size = size.normal, color = #00000000)),
lineDraw.rTFlabel.put("Low" , label.new(f_adjust_label_position(bar_index, 0), TFhrdata.lowTF, xloc = xloc.bar_time, textcolor = color.aqua, text = f_convert_tf_to_text(tf) + " Lo", style = label.style_label_left, size = size.normal, color = #00000000))
=> lineDraw.rTFlabel.get("High") .set_xy(time, TFhrdata.highTF),
lineDraw.rTFlabel.get("Low") .set_xy(time, TFhrdata.lowTF)
var r4hrbars = math.floor(timeframe.in_seconds("240") / timeframe.in_seconds(timeframe.period))
var rDbars = math.floor(timeframe.in_seconds("1D") / timeframe.in_seconds(timeframe.period))
= switch
timeframe.in_seconds() <= 60 => r4hrbars.tfDraw(show4hLab, "240", show4H)
=> tfDrawLower(show4hLab, "240", show4H)
= switch
timeframe.in_seconds() <= 60 => rDbars.tfDraw(show1DLab, "1D", show1D)
=> tfDrawLower(show1DLab, "1D", show1D)
// @function calculatePivots
// @param length Specifies the lookback length for high/low pivot calculations.
// @returns A tuple with top and bottom swing values.
calculatePivots(length)=>
var int intraCalc = 0
if bar_index > length + 1
up = highArr.slice(0, length).max()
dn = lowArr .slice(0, length).min()
cHi = highArr.get(length)
cLo = lowArr .get(length)
intraCalc := switch
cHi > up => 0
cLo < dn => 1
=> intraCalc
topSwing = switch
intraCalc == 0 and intraCalc != 0 => cHi
=> 0
botSwing = switch
intraCalc == 1 and intraCalc != 1 => cLo
=> 0
= calculatePivots(extSens)
= calculatePivots(intSens)
var label upLabel = array.new_label(1)
var label dnLabel = array.new_label(1)
var box highBlock = array.new_box()
var box lowBlock = array.new_box()
drawChar(x, y, str, col, down) =>
style = switch down
true => label.style_label_down
=> label.style_label_up
line.new (int(x), y, bar_index, y, color = col, style = line.style_dashed)
label.new(math.round(math.avg(x, bar_index)), y, str, color = #00000000, textcolor = col, style = style, size = size.small)
// @function drawStructureExt
// @returns Counter indicating the structure direction: 1 for bullish, -1 for bearish, 0 for neutral.
drawStructureExt() =>
var int counter = 0
if bigUpper != 0
bigData.put("upside", 1)
x1 = bar_index - extSens
txt = switch bigUpper > bigData.get("upaxis")
true => 'HH'
=> 'LH'
if showHHLH
upLabel.set(0, label.new(x1, bigUpper, txt,
color = color.new(color.white, 100),
textcolor = bearC,
style = label.style_label_down,
size = size.small
))
if showOB
highBlock.push(box.new(x1, bigUpper, last_bar_index + 5, bigUpper * .998, border_color = BearOBColor, bgcolor = BearOBColor))
bigData.put("upaxis" , bigUpper)
bigData.put("upaxis2", x1)
counter := 1
if bigLower != 0
bigData.put("downside", 1)
x1 = bar_index - extSens
txt = switch bigLower < bigData.get("dnaxis")
true => "LL"
=> "HL"
if showHLLL == true
dnLabel.set(0, label.new(x1, bigLower, txt, color = #ffffff00,
textcolor = bullC,
style = label.style_label_up,
size = size.small
))
if showOB
lowBlock.push(box.new(x1, bigLower, last_bar_index + 5, bigLower * 1.002, border_color = BullOBColor, bgcolor = BullOBColor))
//border_color = color.new(color.blue, 60),//75),
//bgcolor = color.new(color.blue, 70)//95)
//))
bigData.put("dnaxis" , bigLower)
bigData.put("dnaxis2", x1)
counter := -1
if showExt
if ta.crossover(close, bigData.get("upaxis"))
if bigData.get("upside") != 0
str = switch bigData.get("moving") < 0
true => extStru != "BoS" ? 'CHoCH' : ""
=> extStru != 'CHoCH' ? 'BoS' : ""
if extStru == "All" or str.contains(extStru, str)
drawChar(bigData.get("upaxis2"), bigData.get("upaxis"), str, bullC, true)
bigData.put("upside", 0)
bigData.put("moving", 1)
if ta.crossunder(close, bigData.get("dnaxis"))
if bigData.get("downside") != 0
str = switch bigData.get("moving") > 0
true => extStru != "BoS" ? 'CHoCH' : ""
=> extStru != 'CHoCH' ? 'BoS' : ""
if extStru == "All" or str.contains(extStru, str)
drawChar(bigData.get("dnaxis2"), bigData.get("dnaxis"), str, bearC, false)
bigData.put("downside", 0)
bigData.put("moving", -1)
counter
counter = drawStructureExt()
// @function updateBox
// @param id Array of boxes to update based on the bar index.
// @returns void
method updateBox(array id) =>
if id.size() > 0
for i = 0 to id.size() - 1
id.get(i).set_right(last_bar_index + 5)
method cleanseLevel(array id, bool isHighBlock) =>
if id.size() > 0
for i = id.size() - 1 to 0
condition = switch isHighBlock
true => close >= id.get(i).get_top()
=> close <= id.get(i).get_bottom()
if condition
id.remove(i).delete()
if id.size() > showLast and showLast != 0
for i = id.size() - showLast to 0
id.remove(i).delete()
highBlock.cleanseLevel(true)
lowBlock .cleanseLevel(false)
if barstate.islast
highBlock.updateBox()
lowBlock .updateBox()
// @function updateMain
// @param id Line object for updating based on price structure pivots.
// @returns void
// @description Updates the main line indicator to match the latest high/low price levels.
method updateMain(line id) =>
hi = 0.0
lo = 1e8
if showFibs
= calculatePivots(25)
var int counterFibs = 0
if bigUpperFibs != 0
counterFibs := 1
if bigLowerFibs != 0
counterFibs := -1
if counterFibs == 1
hi := 0.0
id.set_xy1(int(bigData.get("upaxis2")), bigData.get("upaxis"))
for i = 0 to bar_index - int(bigData.get("dnaxis2"))
getLow = lowArr.get(i)
lo := math.min(getLow, lo)
if lo == getLow
id.set_xy2(bar_index - i, lo)
else if counterFibs == -1
lo := 1e8
id.set_xy1(int(bigData.get("dnaxis2")), bigData.get("dnaxis"))
for i = 0 to bar_index - bigData.get("upaxis2")
getHigh = highArr.get(i)
hi := math.max(highArr.get(i), hi)
if hi == getHigh
id.set_xy2(bar_index - i, hi)
if id.get_x2() < id.get_x1()
x2 = id.get_x2(), x1 = id.get_x1()
y2 = id.get_y2(), y1 = id.get_y1(),
id.set_xy2(x1, y1),
id.set_xy1(x2, y2)
switch id.get_y2() < id.get_y1()
true => id.set_color(#F24968)
=> id.set_color(#14D990)
0
var main = line.new(dnLabel.first().get_x(), dnLabel.first().get_y(), upLabel.first().get_x(), upLabel.first().get_y(),
style = line.style_dashed,
width = 2
)
main.updateMain()
//-----------------------------------FIB----------------------------------------------------------
// @function quickLine
// @param getX2 The x-coordinate for the endpoint of the line.
// @param y The y-coordinate for the line’s position.
// @param color The color of the line to be drawn.
// @returns void
// @description Draws a horizontal line on the chart with specific attributes.
quickLine(getX2, y, color) =>
line.new(getX2, y, bar_index + 5, y, color = color.new(color, 50))
// @function quickLabel
// @param y The y-coordinate for the label’s position.
// @param txt Text content of the label.
// @param color The text color of the label.
// @returns void
// @description Places a label with given text and color at a specified y-coordinate.
quickLabel(y, txt, color) =>
label.new(bar_index + 5, y, text = str.tostring(txt), color = #00000000, style = label.style_label_left, textcolor = color)
// @function drawFibs
// @returns void
// @description Draws Fibonacci retracement levels based on recent price action.
drawFibs() =>
if barstate.islast
var fibLine = array.new(14)
var fibLab = array.new(14)
if fibLine.size() > 0
for i = 0 to fibLine.size() - 1
fibLine .get(i).delete()
fibLab .get(i).delete()
if showFibs
getY2 = main.get_y2(), sub = main.get_y1() - getY2,
getX1 = main.get_x1(), getX2 = main.get_x2()
for i = 0 to fibLine.size() - 1
mod = i % fibLine.size() - 1
= switch mod
0 =>
1 =>
2 =>
3 =>
4 =>
5 =>
6 =>
7 =>
8 =>
9 =>
10 =>
11 =>
12 =>
13 =>
fibLine.set(i, quickLine (getX2, y, col))
// Combine text level and price
priceLabel = str.tostring(y, "#.#####")
combinedText = txt + " (" + priceLabel + ")" // Prix entre parenthèses
fibLab.set(i, quickLabel(y, combinedText, col))
drawFibs()
// @function drawStructureInternals
// @returns void
// @description Draws internal structures for smaller price swings based on user-defined settings.
drawStructureInternals() =>
if showInt
var keyValues = map.new()
if keyValues.size() == 0
keyValues.put("movingSmall", 0)
if smallUpper != 0
keyValues.put("upsideSmall", 1)
keyValues.put("upaxisSmall", smallUpper)
keyValues.put("upaxis2Small", bar_index - intSens)
if smallLower != 0
keyValues.put("downsideSmall", 1)
keyValues.put("dnaxisSmall", smallLower)
keyValues.put("dnaxis2Small", bar_index - intSens)
if ta.crossover(close, keyValues.get("upaxisSmall"))
if keyValues.get("upsideSmall") != 0
str = switch
keyValues.get("movingSmall") < 0 => intStru != "BoS" ? 'I-CHoCH' : ""
=> intStru != "CHoCH" ? 'I-BoS' : ""
if intStru == "All" or str.contains(str, intStru)
drawChar(keyValues.get("upaxis2Small"), keyValues.get("upaxisSmall"), str, bullC, true)
keyValues.put("upsideSmall", 0)
keyValues.put("movingSmall", 1)
if ta.crossunder(close, keyValues.get("dnaxisSmall"))
if keyValues.get("downsideSmall") != 0
str = switch
keyValues.get("movingSmall") > 0 => intStru != "BoS" ? 'I-CHoCH' : ""
=> intStru != "CHoCH" ? 'I-BoS' : ""
if intStru == "All" or str.contains(str, intStru)
drawChar(keyValues.get("dnaxis2Small"), keyValues.get("dnaxisSmall"), str, bearC, false)
keyValues.put("downsideSmall", 0)
keyValues.put("movingSmall", -1)
drawStructureInternals()
// @function drawAOE
// @returns void
// @description Draws the Premium and Discount Zones on the chart based on recent highs and lows.
drawAOE() =>
atr = ta.atr(14)
if showAOE
if closeArr.size() > 50
aoi = closeArr.slice(0, 50)
aoi2 = openArr .slice(0, 50)
maxaoiH = math.max(aoi.max(), aoi2.max())
minaoiL = math.min(aoi.min(), aoi2.min())
var aoeLevels = map.new()
if aoeLevels.size() == 0
aoeLevels.put("High",
box.new(bar_index , maxaoiH * 1.01, bar_index + 5, maxaoiH,
border_color = #00000000,
bgcolor = color.new(#F24968, 90),
text = "Premium Zone", //"Area of Interest" ,
text_size = size.normal,//.small,
text_color = color.new(#F24968, 33)
))
aoeLevels.put("Low",
box.new(bar_index , minaoiL, bar_index + 5, minaoiL * .99,
border_color = #00000000,
bgcolor = color.new(#14D990, 90),
text = "Discount Zone", //"Area of Interest" ,
text_size = size.normal,//size.small,
text_color = color.new(#14D990, 33)
))
getHighBox = aoeLevels.get("High")
if close <= getHighBox.get_top() * 1.01
getHighBox.set_lefttop (bar_index , maxaoiH + atr)
getHighBox.set_rightbottom (bar_index + 5, maxaoiH)
getHighBox.set_text ("Premium Zone") //"Area of Interest")
else
getHighBox.set_lefttop (bar_index + 5, maxaoiH + atr)
getHighBox.set_rightbottom (bar_index + 5, maxaoiH + atr)
getHighBox.set_text ("")
getLowBox = aoeLevels.get("Low")
if close >= getLowBox.get_bottom() * .99
getLowBox.set_lefttop (bar_index , minaoiL)
getLowBox.set_rightbottom (bar_index + 5, minaoiL - atr)
getLowBox.set_text ("Discount Zone") //"Area of Interest")
else
getLowBox.set_lefttop (bar_index + 5, minaoiL)
getLowBox.set_rightbottom (bar_index + 5, - atr)
getLowBox.set_text ("")
drawAOE()
var table tab2 = table.new(position.top_right, 13, 13, bgcolor = #20222C, border_color = #363843, frame_color = #363843, border_width = 1, frame_width = 1)
nyHour = hour (timenow, "America/New_York")
nyMinute = minute(timenow, "America/New_York")
// @function fvg
// @param direction Determines the direction for fair value gap (FVG) detection: positive for up, negative for down.
// @returns An array of FVG boxes in the specified direction.
// @description Identifies fair value gaps (FVGs) and stores them in an array of boxes for visual representation.
fvg(direction) =>
var fvgMat = matrix.new(5), var fvgDrawings = array.new()
fvgMat.add_col(0, array.from(math.sign(close - open), close, high, low, time))
if fvgMat.columns() > 3
fvgMat.remove_col(fvgMat.columns() - 1)
if fvgMat.row(0).sum() == direction
getDir = math.sign(direction)
= switch getDir
-1 =>
=>
col = switch closeOnly
true => #00000000
=> color.new(fvgcol, fvgtra)
fvgDrawings.push(
box.new(int(fvgMat.get(4, 1)),y, last_bar_time, y1, xloc = xloc.bar_time,
border_color = col, bgcolor = col)
)
fvgDrawings
if showFVG
fvgDn = fvg(-3)
fvgUp = fvg(3)
if fvgDn.size() > 0
for i = fvgDn.size() - 1 to 0
getfvg = fvgDn.get(i)
if high >= getfvg.get_top()
getfvg.delete()
fvgDn.remove(i)
else if contract
if high > getfvg.get_bottom()
getfvg.set_bottom(high)
if fvgUp.size() > 0
for i = fvgUp.size() - 1 to 0
getfvg = fvgUp.get(i)
if low <= getfvg.get_bottom()
getfvg.delete()
fvgUp.remove(i)
else if contract
if low < getfvg.get_top()
getfvg.set_top(low)
if closeOnly and barstate.islast
minDist = matrix.new(1, 2, 20e20)
if fvgDn.size() > 0
for i = fvgDn.size() - 1 to 0
getBottom = fvgDn.get(i).get_bottom()
minDist.set(0, 1, math.min(minDist.get(0, 1), math.abs(close - getBottom)))
if math.abs(close - getBottom) == minDist.get(0, 1)
minDist.set(0, 0, i)
fvgDn.get(i).set_right(fvgDn.get(i).get_left())
fvgDn.get(int(minDist.get(0, 0))).set_bgcolor(color.new(fvgcol, fvgtra))
fvgDn.get(int(minDist.get(0, 0))).set_border_color(color.new(fvgcol, fvgtra))
fvgDn.get(int(minDist.get(0, 0))).set_right(last_bar_time)
minDist.set(0, 0, 0)
minDist.set(0, 1, 20e20)
if fvgUp.size() > 0
for i = fvgUp.size() - 1 to 0
getTop = fvgUp.get(i).get_top()
minDist.set(0, 1, math.min(minDist.get(0, 1), math.abs(close - getTop)))
if math.abs(close - getTop) == minDist.get(0, 1)
minDist.set(0, 0, i)
fvgUp.get(i).set_right(fvgUp.get(i).get_left())
fvgUp.get(int(minDist.get(0, 0))).set_bgcolor(color.new(fvgcol, fvgtra))
fvgUp.get(int(minDist.get(0, 0))).set_border_color(color.new(fvgcol, fvgtra))
fvgUp.get(int(minDist.get(0, 0))).set_right(last_bar_time)
// @function calculateTimeDifference
// @param timestamp1 The starting timestamp for time difference calculation.
// @param timestamp2 The ending timestamp for time difference calculation.
// @returns A tuple containing hours and minutes as integers.
// @description Calculates the time difference between two timestamps, outputting hours and minutes.
//calculateTimeDifference(timestamp1, timestamp2) =>
// timeDifference = timestamp2 - timestamp1
// hours = math.floor(timeDifference / 3600000)
// minutes = math.floor((timeDifference % 3600000) / 60000)
//
//dayAdjustment = (hour(timenow, "America/New_York") < 2) ? dayofmonth(timenow) + 1 : dayofmonth(timenow)
//dayAdjustment2 = nyHour >= 20 or nyHour < 2 ? dayofmonth(timenow) + 1 : dayofmonth(timenow)
// @function timeIsInRange
// @param startHour The start hour of the time range.
// @param startMinute The start minute of the time range.
// @param endHour The end hour of the time range.
// @param endMinute The end minute of the time range.
// @returns Boolean indicating if the current time is within the specified range.
// @description Checks if the current time falls within a specified range based on New York timezone.
//timeIsInRange(startHour, startMinute, endHour, endMinute) =>
// (nyHour > startHour or (nyHour == startHour and nyMinute >= startMinute)) and (nyHour < endHour or (nyHour == endHour and nyMinute <= endMinute))
// = switch
// timeIsInRange(9, 30, 16, 0) =>
// timeIsInRange(20, 0, 2 , 0) =>
// timeIsInRange(3, 0, 11, 30) =>
// =>
// = calculateTimeDifference(timenow, timetilchange)
//timetilchange2 = switch
// timeIsInRange(9, 30, 16, 0) => timestamp("America/New_York", year(timenow), month(timenow), dayofmonth(timenow), 20, 0, 0)
// timeIsInRange(20, 0, 2 , 0) => timestamp("America/New_York", year(timenow), month(timenow), dayofmonth(timenow), 3, 0, 0)
// timeIsInRange(3, 0, 11, 30) => timestamp("America/New_York", year(timenow), month(timenow), dayofmonth(timenow), 9, 30, 0)
// => na
//if na(timetilchange2)
// timetilchange2 := switch
// nyHour < 9 or (nyHour == 9 and nyMinute < 30) => timestamp("America/New_York", year(timenow), month(timenow), dayofmonth(timenow), 9, 30, 0)
// nyHour < 20 or (nyHour >= 16 and nyHour < 20) => timestamp("America/New_York", year(timenow), month(timenow), dayofmonth(timenow), 20, 0, 0)
// nyHour < 3 or (nyHour >= 2 and nyHour < 3) => timestamp("America/New_York", year(timenow), month(timenow), dayofmonth(timenow), 3, 0, 0)
// => na
// = calculateTimeDifference(timenow, timetilchange2)
//method getActivity(array id, float id2) =>
// if id.size() > 0
// volPerc1 = id.percentile_nearest_rank(10)
// volPerc2 = id.percentile_nearest_rank(33)
// volPerc3 = id.percentile_nearest_rank(50)
// volPerc4 = id.percentile_nearest_rank(66)
// volPerc5 = id.percentile_nearest_rank(90)
// log.warning(str.tostring(volPerc1) + " " + str.tostring(volPerc2) + " " + str.tostring(volPerc3) + " " + str.tostring(volPerc4) + " " + str.tostring(volPerc5))
// activity = switch
// id2 <= volPerc1 => "Very Low"
// id2 <= volPerc2 => "Low"
// id2 <= volPerc3 => "Average"
// id2 <= volPerc4 => "High"
// => "Very High"
// activity
//if barstate.islast
// hr4Act = vol4hrArr.getActivity(vol4hr)
// D1Act = vol1DArr .getActivity(vol1D)
// str = str.tostring(timetilchange)
// ch = str.substring(str, str.pos(str, ".") + 1, str.length(str))
// nu = str.tonumber(ch) * 6
// nu2 = str.substring(str.tostring(nu), 0, 2)
// table.cell(tab2, 0, 2, text = "Session:" , text_color = color.white, text_halign = text.align_left)
// table.cell(tab2, 0, 3, text = "Session Close:" , text_color = color.white, text_halign = text.align_left)
// table.cell(tab2, 0, 4, text = "Next Session:" , text_color = color.white, text_halign = text.align_left)
// table.cell(tab2, 0, 5, text = "Next Session Open:" , text_color = color.white, text_halign = text.align_left)
// table.cell(tab2, 0, 6, text = "4-Hr Volume:" , text_color = color.white, text_halign = text.align_left)
// table.cell(tab2, 0, 7, text = "24-Hr Volume:" , text_color = color.white, text_halign = text.align_left)
// table.cell(tab2, 1, 2, text = stringCol , text_color = color.white)
// table.cell(tab2, 1, 3, text = stringCol != "Dead Zone" ? str.tostring(hours)+ "h" + str.tostring(minutes) + "m": "Dead Zone", text_color = color.white)
// table.cell(tab2, 1, 4, text =stringCol2, text_color = color.white)
// table.cell(tab2, 1, 5, text = str.tostring(hours2) + "h:" + str.tostring(minutes2) + "m", text_color = color.white)
// table.cell(tab2, 1, 6, text = hr4Act, text_color = color.white)
// table.cell(tab2, 1, 7, text = D1Act, text_color = color.white)
nyHour2 = hour (time, "America/New_York")
nyMinute2 = minute(time, "America/New_York")
// @function timeIsInRange2
// @param startHour The starting hour for checking the time range.
// @param startMinute The starting minute within the hour.
// @param endHour The ending hour for checking the time range.
// @param endMinute The ending minute within the hour.
// @returns Boolean indicating if the current time is within the specified range.
// @description Checks if the current chart time falls within a specified time range.
timeIsInRange2(startHour, startMinute, endHour, endMinute) =>
if endHour >= startHour
(nyHour2 > startHour or (nyHour2 == startHour and nyMinute2 >= startMinute)) and
(nyHour2 < endHour or (nyHour2 == endHour and nyMinute2 <= endMinute))
else
(nyHour2 > startHour or (nyHour2 == startHour and nyMinute2 >= startMinute)) or
(nyHour2 < endHour or (nyHour2 == endHour and nyMinute2 <= endMinute))
nyCol = input.color(defval = #f24968, title = "NY Color")
asCol = input.color(defval = #14D990, title = "Asia Color")
loCol = input.color(defval = #F2B807, title = "London Color")
tra = input.int(defval = 98, minval = 0, maxval = 100, title = "Transparency")
bgcolor(timeIsInRange2(9, 30, 16, 0) ? color.new(nyCol, tra) : na)
bgcolor(timeIsInRange2(20, 0, 2 , 0) ? color.new(asCol, tra) : na)
bgcolor(timeIsInRange2(3, 0, 11, 30) ? color.new(loCol, tra) : na)
//---------------------------------------Entry/Exit-------------------------------------------------------
// "Entry/Exit signal"
Entry_exit_ena = input.bool(defval = true, title = "Entry/Exit Signal" ,group = "Entry/exit Signal")
a = input.float(1.5, title="Key Value. 'This changes the sensitivity'", group = "Entry/exit Signal")
c = input.int(7, title="ATR Period", group = "Entry/exit Signal")
ma_length = input.int(50, minval=1, title="Période de la Moyenne Mobile", group = "Entry/exit Signal")
Trail_Stop_ENA = input.bool(defval = true, title = "Trail Stop" ,group = "Entry/exit Signal")
Trail_stop_col = input.color(title = "Trailing stop color", defval = color.yellow, group = "Entry/exit Signal")
//if Entry_exit_ena
// Paramètres de la Moyenne Mobile (Filtre de Tendance)
// Calculs de base
xATR = ta.atr(c)
nLoss = a * xATR
src = close
// Calcul de l'UT BOT Trailing Stop
var float xATRTrailingStop = 0.0
xATRTrailingStop := if src > nz(xATRTrailingStop ) and src > nz(xATRTrailingStop )
math.max(nz(xATRTrailingStop ), src - nLoss)
else if src < nz(xATRTrailingStop ) and src < nz(xATRTrailingStop )
math.min(nz(xATRTrailingStop ), src + nLoss)
else if src > nz(xATRTrailingStop )
src - nLoss
else
src + nLoss
// Calcul de la Moyenne Mobile
ma = ta.ema(close, ma_length)
// Condition de tendance
is_uptrend = close > ma
is_downtrend = close < ma
// Signaux d'achat et de vente selon le trend
buy = ta.crossover(src, xATRTrailingStop) and is_uptrend
sell = ta.crossunder(src, xATRTrailingStop) and is_downtrend
// Tracé de l'UT BOT Trailing Stop
plot(Trail_Stop_ENA ? xATRTrailingStop : na, color=buy ? color.green : sell ? color.red : Trail_stop_col, linewidth=2, title="Trailing Stop Style")
// Indication des signaux sur le graphique
if buy and Entry_exit_ena
label.new(bar_index, low, text='Buy', style=label.style_label_up, yloc=yloc.belowbar ,color=color.green, textcolor=color.white, size=size.small)
if sell and Entry_exit_ena
label.new(bar_index, high, text='Sell', style=label.style_label_down, yloc=yloc.abovebar, color=color.red, textcolor=color.white, size=size.small)
alertcondition(buy, "Buy/Long", "Buy Long")
alertcondition(sell, "Sell/Short", "Sell/Short")
// ----------------------------------------Trend table-----------------------------------------------
// Paramètres utilisateur
afficher_tableau = input.bool(true, "Afficher le tableau", group="Trend Table")
periode_ema = input.int(200, minval=1, title="Période EMA pour les tendances", group="Trend Table")
periode_ema_btc = input.int(200, minval=1, title="Période EMA pour la tendance BTC", group="Trend Table")
// Configuration des périodes de tendance avec un menu déroulant lisible
periode1 = input.string("15m", "Période de tendance 1", options= , group="Trend Table")
periode2 = input.string("1h", "Période de tendance 2", options= , group="Trend Table")
periode3 = input.string("4h", "Période de tendance 3", options= , group="Trend Table")
periode4 = input.string("Day", "Période de tendance 4", options= , group="Trend Table")
// Période de tendance pour le BTC
btc_periode_tendance = input.string("4h", "Période de tendance BTC", options= , group="Trend Table")
// Couleurs pour les tendances
color_haussier = color.green
color_baissier = color.red
// Couleurs de fond alternées pour les lignes (définies globalement)
bg_color_odd = color.new(color.gray, 90) // Gris très clair pour les lignes impaires
bg_color_even = color.new(color.gray, 70) // Gris clair pour les lignes paires
// Fonction de mapping des périodes lisibles en valeurs temporelles standard
f_mapper_periode(timeframe_lisible) =>
switch timeframe_lisible
"5m" => "5"
"15m" => "15"
"1h" => "60"
"4h" => "240"
"8h" => "480"
"12h" => "720"
"Day" => "D"
=> timeframe_lisible // Cas par défaut si aucune correspondance n'est trouvée
// Mapper les périodes sélectionnées
periode1_mapped = f_mapper_periode(periode1)
periode2_mapped = f_mapper_periode(periode2)
periode3_mapped = f_mapper_periode(periode3)
periode4_mapped = f_mapper_periode(periode4)
btc_periode_tendance_mapped = f_mapper_periode(btc_periode_tendance)
// Fonction pour déterminer la session actuelle en utilisant l'heure du graphique (UTC-5)
f_session_actuelle() =>
heure = hour(time)
minute_ = minute(time)
heure_mod = heure * 60 + minute_
sessions_actives = ""
// Définir les plages horaires des sessions en UTC-5
// Session Asie (19:00 - 04:00)
if (heure_mod >= (19 * 60) or heure_mod < (4 * 60))
sessions_actives := sessions_actives + "Asie, "
// Session Londres (03:00 - 12:00)
if (heure_mod >= (3 * 60) and heure_mod < (12 * 60))
sessions_actives := sessions_actives + "Londres, "
// Session New York (08:00 - 17:00)
if (heure_mod >= (8 * 60) and heure_mod < (17 * 60))
sessions_actives := sessions_actives + "NY, "
// Nettoyer la chaîne de caractères pour enlever la virgule finale
if (str.endswith(sessions_actives, ", "))
sessions_actives := str.substring(sessions_actives, 0, str.length(sessions_actives) - 2)
// Si aucune session n'est active
sessions_actives := sessions_actives == "" ? "Hors session" : sessions_actives
sessions_actives
session_actuelle = f_session_actuelle()
// Fonction pour calculer la tendance basée sur l'EMA sans lookahead
f_tendance(symbole, timeframe_tendance, periode_ema) =>
= request.security(symbole, timeframe_tendance, , barmerge.gaps_off, barmerge.lookahead_off)
tendance = cours > ema_valeur ? "Haussier" : "Baissier"
tendance
// Calcul de la tendance du BTC
tendance_btc = f_tendance("BINANCE:BTCUSDT", btc_periode_tendance_mapped, periode_ema_btc)
// Calcul des tendances pour les périodes spécifiées
tendance_periode1 = f_tendance(syminfo.tickerid, periode1_mapped, periode_ema)
tendance_periode2 = f_tendance(syminfo.tickerid, periode2_mapped, periode_ema)
tendance_periode3 = f_tendance(syminfo.tickerid, periode3_mapped, periode_ema)
tendance_periode4 = f_tendance(syminfo.tickerid, periode4_mapped, periode_ema)
// Fonction pour obtenir le nom du ticker actuel
f_ticker_actuel() =>
syminfo.ticker
// Obtenir le ticker actuel
ticker_actuel = f_ticker_actuel()
// Affichage du tableau
if afficher_tableau
// Création du tableau
var table mon_tableau = table.new(position=position.top_right, columns=2, rows=7, bgcolor=color.new(color.black, 0), frame_color=color.new(color.gray, 0), frame_width=1)
if barstate.isfirst
// Première colonne (libellés)
table.cell(table_id=mon_tableau, row=0, column=0, text="Session actuelle:", text_color=color.white, bgcolor=bg_color_even)
table.cell(table_id=mon_tableau, row=1, column=0, text="Tendance:", text_color=color.white, bgcolor=bg_color_odd, text_halign=text.align_right)
table.cell(table_id=mon_tableau, row=6, column=0, text="BTC (" + btc_periode_tendance + "):", text_color=color.white, text_halign=text.align_right, bgcolor=bg_color_even)
table.cell(table_id=mon_tableau, row=2, column=0, text= ticker_actuel + " (" + periode1 + "):", text_color=color.white, bgcolor=bg_color_odd)
table.cell(table_id=mon_tableau, row=3, column=0, text="(" + periode2 + "):", text_color=color.white, text_halign=text.align_right, bgcolor=bg_color_even)
table.cell(table_id=mon_tableau, row=4, column=0, text="(" + periode3 + "):", text_color=color.white, text_halign=text.align_right, bgcolor=bg_color_odd)
table.cell(table_id=mon_tableau, row=5, column=0, text="(" + periode4 + "):", text_color=color.white, text_halign=text.align_right, bgcolor=bg_color_even)
// Définir les couleurs de fond pour les cellules de tendance
trend_btc_color = tendance_btc == "Haussier" ? color.green : color.red
trend_periode1_color = tendance_periode1 == "Haussier" ? color.green : color.red
trend_periode2_color = tendance_periode2 == "Haussier" ? color.green : color.red
trend_periode3_color = tendance_periode3 == "Haussier" ? color.green : color.red
trend_periode4_color = tendance_periode4 == "Haussier" ? color.green : color.red
// Mise à jour des valeurs avec les couleurs appropriées
table.cell(table_id=mon_tableau, row=0, column=1, text=session_actuelle, text_color=color.yellow, bgcolor=bg_color_even)
table.cell(table_id=mon_tableau, row=1, column=1, text="", bgcolor=bg_color_odd)
table.cell(table_id=mon_tableau, row=6, column=1, text=tendance_btc, text_color=color.white, bgcolor=trend_btc_color)
table.cell(table_id=mon_tableau, row=2, column=1, text=tendance_periode1, text_color=color.white, bgcolor=trend_periode1_color)
table.cell(table_id=mon_tableau, row=3, column=1, text=tendance_periode2, text_color=color.white, bgcolor=trend_periode2_color)
table.cell(table_id=mon_tableau, row=4, column=1, text=tendance_periode3, text_color=color.white, bgcolor=trend_periode3_color)
table.cell(table_id=mon_tableau, row=5, column=1, text=tendance_periode4, text_color=color.white, bgcolor=trend_periode4_color)
// Optionnel : Ajouter une étiquette de débogage pour vérifier la session actuelle
// label.new(bar_index, high, text="Session: " + session_actuelle, style=label.style_label_down, color=color.blue, textcolor=color.white, size=size.small, yloc=yloc.abovebar)
PHAI GIAU NHAT VN)positive and negative are recreated each bar using nz(... ) to keep the old value if no new signal is present.
The line p_mom ? true : nz(positive , false) ensures the variable keeps the correct state across bars.
Clearly displays "UP" and "DOWN" signals.
PHAI GIAU NHAT VN)
positive and negative are recreated each bar using nz(... ) to keep the old value if no new signal is present.
The line p_mom ? true : nz(positive , false) ensures the variable keeps the correct state across bars.
Clearly displays "UP" and "DOWN" signals.
