开始

Pine实用程序

WASDE DatesOverview WASDE Dates — a small, focused event indicator that displays confirmed USDA WASDE release dates for 2025 on the chart and marks each release day. The indicator is designed to be a lightweight timing tool for traders who want clean visual reminders and optional alerts around USDA WASDE publications. Features • Shows official WASDE release dates for 2025 in a compact chart table. • Draws on-chart markers and a dotted vertical line on WASDE release days. • Two alert conditions you can enable in TradingView: "WASDE Day Alert" and "WASDE 24h Reminder". • Simple table position control (Top/Bottom, Left/Right) in the indicator settings. • Minimal, self-contained code — no external data feeds or permissions required. How to use 1. Apply the indicator to any chart and timeframe. 2. Use the indicator settings to choose table position. 3. Enable Alerts (if desired) via TradingView Alerts → choose “WASDE Day Alert” or “WASDE 24h Reminder”. 4. This version contains 2025 confirmed dates only — verify dates for live trading and enable alerts as needed. Design & rationale This indicator is intentionally not a technical trading signal. It is an event scheduler focused on clarity and low overhead: combine it with your existing setup to avoid being surprised by WASDE publications and to quickly inspect price action around these event dates. Limitations & disclaimer • This script shows **confirmed 2025** WASDE dates only. It does not provide trading advice or entry/exit signals. Use at your own risk. • Double-check official USDA publishing times before executing trades. • No external links or contact information are included in this description to comply with TradingView publishing rules. Feature outlook (V2) Planned V2 (future release): enhanced countdown (days → hours/minutes), optional inclusion of estimated 2026 dates marked as (TBC), and an invite-only/protected advanced version with reaction overlays (T+1/T+3) and extended alert options. V2 will be announced on this script page when ready. Changelog v1 — public release: 2025 confirmed dates, release markers, alerts, table position control.
Pine Script®指标
由DerAndi72提供
KD The ScalperWe have to take the trade when all three EMAs are pointing in the same direction (no criss-cross, no up/down, sideways). All 3 EMAs should be cleanly separated from each other with strong spacing between them; they are not tangled, sideways, or messy. This is our first filter before entering the trade. Are the EMAs stacked neatly, and is the price outside of the 25 EMA? If price pulls back and closes near or below the 25 or 50 EMA and breaks the 100 EMA, we don't trade. Use the 100 EMA as a safety net and refrain from trading if the price touches or falls below the 100 EMA. 1. Confirm the trend- All 3 EMAs must align, and they must spread 2. Watch price pull back to the 25th or the 50 EMA 3. Wait for the price to bounce - And re-approach the 25 EMA Why is this powerful? Removes 80% of the low-probability Trades It keeps you out of choppy markets Avoids Reversal Traps Anchors us to momentum We take the entry when the price moves up again and touches the 25 EMA from below, and then when it breaks above the 25 EMA, or even better, when a lovely green bullish candle forms. A bullish candle indicates good momentum. When a bullish candle closes in green, it means the momentum has increased significantly. This is when we enter a long trade, with the stop-loss just below the 50 EMA and the profit target being 1.5 times the stop-loss. The same rule applies to the bearish trade.
Pine Script®策略
由krish16887提供
1
RCT RSI Pro FusionDescription for "RCT RSI Pro Fusion" Description: The RCT RSI Pro Fusion is an advanced indicator for TradingView, developed by Carlos Mauricio Vizcarra for the Rafael Cepeda Trader community. It combines the power of the standard Relative Strength Index (RSI) with additional elements to provide a more comprehensive market view. Key Features: RSI and SMA: Displays the standard RSI line along with its Simple Moving Average (SMA) applied directly to the RSI values, allowing analysis of its trend and momentum. Clear Overbought/Oversold Zones: Uses dotted horizontal lines at the 20 (oversold) and 80 (overbought) levels, easily visible over any panel background, facilitating the identification of extreme price conditions. Divergence Detection: Incorporates a system to identify and visualize regular and hidden bullish and bearish divergences between the price and the RSI, providing potential trend reversal signals. Intuitive Visualization: Divergences are marked with symbols ('R' for regular, 'H' for hidden) and dotted lines connecting them, enhancing visual interpretation. Alerts: Includes alert conditions for when different types of divergences are detected. Customizable: Allows adjustment of RSI length, price source, RSI SMA period, and divergence visualization options. In summary, the RCT RSI Pro Fusion is an all-in-one tool that fuses RSI analysis, its moving average, and divergence detection, all presented with clear and customizable visualization, ideal for traders looking to deepen their technical analysis.
Pine Script®指标
由CARLOSVIZCARRA17提供
PongExperience PONG! The classic arcade game, now on your charts! With this indicator, you can finally achieve your lifelong dream of beating the Markets. . . at PONG! Pong is jam-packed with features! Such as: 2 Paddles A moving dot Floating numbers The idea of a net This indicator is solely a visualization, it serves simply as an exercise to depict what is capable through PineScript. It can be used to re-skin other indicators or data, but on its own, is not intended as a market indicator. With that out of the way... > PONG The Pong indicator is a recreation of the classic arcade game Pong developed to pit the markets against the cold hard logic of a CPU player. Given the lack of interaction that is capable, the game is not played in the typical sense, by a player and computer or 2 players. This version of Pong uses the chart price movements to control the "Market" Paddle, and it is contrasted by a (not AI) "CPU" Paddle, which is controlled by its own set of logic. > Market Paddle The Market Paddle is controlled by a data source which can be input by the user. By default (Auto Mode), the Market Paddle is controlled through a fixed length Donchian channel range, pinning the range high to 100 and range low to 0. As seen below. This can be altered to use data from different symbols or indicators, and can optionally be smoothed using multiple types of Moving Averages. In the chart below, you can see how the RSI indicator is imported and smoothed to control the Market Paddle. Note: The Market Paddle follows the moving average. If not desired, simply set the "Smoothing" input to "NONE". > CPU Paddle In simple terms, the CPU Paddle is a handicapped Aimbot. Its logic is, more or less, "move directly towards the ball's vertical location". If it were allowed to have full range of the screen, it would be impossible for it to lose a point. Due to this, we must slow it down to "play fair"... as fair as that may be. The CPU Paddle is allowed to move at a rate specified by a certain Percent of its vertical width. By default, this is set to 2%. Each update, the CPU Paddle can advance up or down 2% of its vertical width. The directional movement is determined based on the angle of the ball, and it's current position relative to the CPU Paddle's position. Given that it is not a direct follow, it may at times seem more... "human". When a point is scored, the CPU paddle maintains its position, similar to the original Pong game, the paddles were controlled solely by the raw output of the controllers and did not reset. > Ball At the start of each point, the ball begins at the center of the screen and moves in a randomly determined angle at its base speed. The direction is determined by the player who scored the last point. The loser of the last point "serves" the ball. Given the circumstances, serving is a gigantic advantage. So the loser serving is just another place where the Market is given an advantage. The ball's base speed is 1, it will move 1 (horizontal) bar on each update of the script. This speed can "technically" increase to infinity over time, if given the perfect rally. This is due to the hit logic as described below. Note: The minimum ball speed is also 1. > Bonk Math When the ball hits a paddle, essentially 3 outcomes can occur, each resulting in the ball's direction being changed from positive to negative. Action A: Its angle is doubled, and its speed is doubled. Action B: Its angle is reversed, and its speed is decreased if it is going faster than base speed. Action C: Its angle is preserved, and its speed is preserved. "Basic Bounce" Each paddle is segmented into 3 zones, with the higher and lower tips (20%) of the paddles producing special actions. The central 60% of each paddle produces a basic bounce. The special actions are determined by the trajectory of the ball and location on the paddle. > Custom Mode As stated above, the script loads in "Auto Mode" by default. While this works fine to simply watch the gameplay, the Custom Mode unlocks the ability to visualize countless possibilities of indicators and analyses playing Pong! In the chart below, we have set up the game to use the NYSE TICK Index as our Market Player. The NYSE TICK Index shows the number of NYSE stocks trading on an uptick minus those on a downtick. Its values fluctuate throughout the day, typically ranging between +1000 and -1000. Therefore, we have set up Pong to use Ticker USI:TICK and set the Upper Boundary to 1000 and Lower Boundary to -1000. With this method, the paddle is directly controlled by the overall (NYSE) market behaviors. As seen in a chart earlier, you can also take advantage of the Custom Mode to overlay Pong onto traditional oscillators for use anywhere! > Styles This version of Pong comes stocked with 5 colorways to suit your chart vibes! > Pro Tips & Additional Information - This game has sound! For the full experience, set alerts for this indicator and a notification sound will play on each hit!* *Due to server processing, the notification sounds are not precisely played at each hit. :( - In auto mode, decreasing the length used will give an advantage to the market, as its actions become more sporadic over this window. - The CPU logic system actually allows the market to have a "technical" edge, since the Market Paddle is not bound to any speed, and is solely controlled by the raw market movements/data input. - This type of visualization only works on live charts, charts without updates will not see any movement. - Indicator sources can only be imported from other indicators on the same chart. - The base screen resolution is 159 bars wide, with the height determined by the boundaries. - When using a symbol and an outside source, be mindful that the script is attempting to pull the source from the input symbol. Data can appear wonky when not considering the interactions of these inputs. There are many small interesting details that can't be seen through the description. For example, the mid-line is made from a box. This is because a line object would not appear on top of the box used for the screen. For those keen eye'd coders, feel free to poke around in the source code to make the game truly custom. Just remember: The market may never be fair, but now at least it can play Pong! Enjoy!
Pine Script®指标
由SamRecio提供
1
Apex Edge Sentinel - Stop Loss HUDApex Edge – ATR Sentinel Stop Loss HUD The Apex Edge – ATR Sentinel is a complete stop-loss intelligence system built as a clean, always-on HUD. It delivers institutional-level risk guidance by calculating and displaying live ATR-based stop levels for both long and short trades at multiple risk tolerances. Forget cluttered charts and repainting lines — Sentinel gives you a clear stop-loss reference panel that updates dynamically with every bar. ✅ Features • Triple ATR Multipliers User-defined (e.g. x1.5 / x2.0 / x2.5). Compare tight, medium, and wide stops instantly. • Dual-Side SL Levels Both Long and Short safe stop prices displayed side by side. No more guessing trend bias. • ATR Transparency HUD shows ATR(length) so you always know the calculation basis. Default = 14, adjustable to your style. • ATR Regime Meter Detects volatility conditions (LOW / NORMAL / HIGH) by comparing ATR to its SMA. Helps you avoid over-tight stops in high-volatility markets. • Tick-Aware Rounding Stop levels auto-rounded to the instrument’s tick size (Gold = 0.10, FX = 0.0001, indices = whole points). Custom HUD Design • Location: Top/Bottom, Left/Right • Sizes: Compact / Medium / Large (desktop or mobile) • Opacity control (25% default Apex styling) How to Use 1. Load Sentinel on your chart. 2. Check the HUD: • ATR(14): 2.6 → base volatility measure. • x1.5 / x2.0 / x2.5 → instant SL levels for both long & short trades. 3. Before entering a trade → decide which multiplier matches your style (tight scalper vs wider swing). 4. Manually place your SL at the level displayed in the HUD. Sentinel works as both: • A pre-trade check (is ATR stop too wide for my RR?). • A live risk compass (updated stop levels every bar). Why Apex Sentinel? Most ATR stop indicators clutter charts with lagging lines or repainting trails. Sentinel strips it back to what matters: • The numbers. • The risk levels. • The context. It’s a pure stop-loss HUD, designed for serious traders who want clarity, discipline, and instant reference points across any market or timeframe. Notes • This is a HUD-only system (no automatic SL line). Traders manually apply the SL level shown in the panel. • Defaults: ATR(14), multipliers 1.5 / 2.0 / 2.5. Adjust to your trading style. • Best used on intraday pairs like XAUUSD, EURUSD, indices, but works universally. Apex Edge Philosophy: Clean. Smart. Institutional. No clutter. No gimmicks. Just precision tools for modern markets.
Pine Script®指标
由ApexEdge提供
Apex Edge – HTF Overlay Candles“Trade your 5m chart with the eyes of the 1H — Apex Edge brings higher-timeframe structure and liquidity sweeps directly onto your execution chart.” Apex Edge – HTF Overlay Candles The Apex Edge – HTF Overlay Candles indicator overlays higher-timeframe (HTF) candles directly onto your lower-timeframe chart. Instead of flipping between timeframes, you see HTF structure “breathe” live on your execution chart. What It Does • HTF Body Boxes → open/close zones drawn as semi-transparent rectangles. • HTF Wick Boxes → high/low extremes projected as envelopes around each body. • Midpoint Line → a dynamic equilibrium line that flips bias as price trades above or below. • Sweep Arrows → one-time markers showing the first liquidity raid at HTF highs or lows. Under the Hood This isn’t just a visual overlay — it’s engineered for accuracy and performance in PineScript. 1. HTF Data Retrieval • Uses request.security() to import open, high, low, close, time from any selected HTF. • lookahead=barmerge.lookahead_off ensures OHLC values update bar by bar as the HTF candle builds. • When the HTF bar closes, boxes and midpoint lock to historical values — matching the native HTF chart exactly. 2. Box Construction • Body box: built from HTF open → close. • Wick box: built from HTF high → low. • Boxes extend dynamically across each HTF period, updating in real time, then freeze at close. 3. Midpoint Logic • (htfOpen + htfClose) / 2 calculates intrabar midpoint. • Line drawn edge-to-edge across the active HTF body. • Style, width, color, and opacity are user-controlled. 4. Sweep Detection • Flags (sweepedHigh / sweepedLow) prevent clutter: only the first tap per side per HTF candle is marked. • Lower-timeframe price breaking the HTF high/low triggers the sweep arrow. • Arrows are offset above/below wick envelopes for clean visuals. 5. Customisation • Every layer (body, wick, midpoint, arrows) has independent color + opacity settings. • Arrow size, arrow color, and transparency are adjustable. • Default HTF = 1H (perfect for 5m/15m traders) but can be switched to 30m, 4H, Daily, etc. Why It’s Useful • HTF intent + LTF execution without chart hopping. • Liquidity mapping: see where liquidity is swept in real time. • Bias clarity: midpoint line defines HTF equilibrium. • Clean signals: only the first sweep prints — no spam. What Makes It Different Most MTF overlays just plot candles or single lines. This tool: • Splits body vs wick zones for institutional precision. • Updates live intrabar (no repainting). • Highlights liquidity sweeps clearly. • Built for readability and professional use — not another retail signal toy. Cheat-Sheet Playbook 1️⃣ Structure Bias • Above midpoint line = bullish intent. • Below midpoint line = bearish intent. • Chop around midpoint = no clear direction. 2️⃣ Liquidity Sweeps • ▲ Green up arrow below wick box = sell-side liquidity taken → watch for longs. • ▼ Red down arrow above wick box = buy-side liquidity taken → watch for shorts. • First sweep is the cleanest. 3️⃣ Trade Logic • Body box = where institutions transact. • Wick box = liquidity traps. • Midpoint = bias filter. • Best setups occur when sweep + midpoint flip align. 4️⃣ Example (5m + 1H Overlay) 1. ▲ Green up arrow prints below HTF wick. 2. Price reclaims the body box. 3. Midpoint flips to support. 4. Enter long → stop below sweep → targets = midpoint first, opposite wick second. In short: • Boxes = structure • Wicks = liquidity pools • Midpoint = bias line • Arrows = liquidity sweeps This is your SMC edge on one chart — HTF structure and liquidity fused directly into your execution timeframe.
Pine Script®指标
由ApexEdge提供
Apex Edge – Wolfe Wave HunterApex Edge – Wolfe Wave Hunter The modern Wolfe Wave, rebuilt for the algo era This isn’t just another Wolfe Wave indicator. Classic Wolfe detection is rigid, outdated, and rarely tradable. Apex Edge – Wolfe Wave Hunter re-engineers the pattern into a modern, SMC-driven model that adapts to today’s liquidity-dominated markets. It’s not about drawing pretty shapes – it’s about extracting precision entries with asymmetric risk-to-reward potential. 🔎 What it does Automatic Wolfe Wave Detection Identifies bullish and bearish Wolfe Wave structures using pivot-based logic, symmetry filters, and slope tolerances. Channel Glow Zones Highlights the Wolfe channel and projects it forward into the future (bars are user-defined). This allows you to see the full potential of the trade before price even begins its move. Stop Loss (SL) & Entry Arrow At the completion of Wave 5, the algo prints a Stop Loss line and a tiny entry arrow (green for bullish, red for bearish). but the colours can be changed in user settings. This is the “execution point” — where the Wolfe setup becomes tradable. Target Projection Lines TP1 (EPA): Derived from the traditional 1–4 line projection. TP2 (1.272 Fib): Optional secondary profit target. TP3 (1.618 Fib): Optional extended target for large runners. All TP lines extend into the future, so you can track them as price evolves. Volume Confirmation (optional) A relative volume filter ensures Wave 5 is formed with meaningful market participation before a setup is confirmed. Alerts (ready out of the box) Custom alerts can be fired whenever a bullish or bearish Wolfe Wave is confirmed. No need to babysit the charts — let the script notify you. ⚙️ Customisation & User Control Every trader’s market and style is different. That’s why Wolfe Wave Hunter is fully customisable: Arrow Colours & Size Works on both light and dark charts. Choose your own bullish/bearish entry arrow colours for maximum visibility. Tolerance Levels Adjust symmetry and slope tolerance to refine how strict the channel rules are. Tighter settings = fewer but cleaner zones. Looser settings = more frequent setups, but with slightly lower structural quality. Channel Glow Projection Define how many bars forward the channel is drawn. This controls how far into the future your Wolfe zones are extended. Stop Loss Line Length Keep the SL visible without it extending infinitely across your chart. Take Profit Line Colors Each TP projection can be styled to your preference, allowing you to clearly separate TP1, TP2, and TP3. This isn’t a one-size-fits-all tool. You can shape Wolfe detection logic to match the pairs, timeframes, and market conditions you trade most. 🚀 Why it’s different Classic Wolfe waves are rare — this script adapts the model into something practical and tradeable in modern markets. Liquidity-aligned — many setups align with structural sweeps of Wave 3 liquidity before driving into profit. Entry built-in — most Wolfe scripts only draw the structure. Wolfe Wave Hunter gives you a precise entry point, SL, and projected TPs. Backtest-friendly — you’ll quickly discover which assets respect Wolfe waves and which don’t, creating your own high-probability Wolfe watchlist. ⚠️ Limitations & Disclaimer Not all markets respect Wolfe Waves. Some FX pairs, metals, and indices respect the structure beautifully; others do not. Backtest and create your own shortlist. No guaranteed sweeps. Many entries occur after a liquidity sweep of Wave 3, but not all. The algo is designed to detect Wolfe completion, not enforce textbook liquidity rules. Probabilistic, not predictive. Wolfe setups don’t win every time. Always use risk management. High-RR focus. This is not a high-frequency tool. It’s designed for precision, asymmetric setups where risk is small and reward potential is large. ✅ The Bottom Line Apex Edge – Wolfe Wave Hunter is a modern reimagination of the Wolfe Wave. It blends structural geometry, liquidity dynamics, and algo-driven execution into a single tool that: Detects the pattern automatically Provides SL, entry, and TP levels Offers alerts for hands-off trading Allows deep customisation for different markets When it hits, it delivers outstanding risk-to-reward. Backtest, refine your tolerances, and build your watchlist of assets where Wolfe structures consistently pay. This isn’t just Wolfe detection — it’s Wolfe trading, rebuilt for the modern trader. Developer Notes - As always with the Apex Edge Brand, user feedback and recommendations will always be respected. Simply drop us a message with your comments and we will endeavour to address your needs in future version updates.
Pine Script®指标
由ApexEdge提供
2
SMA Cross 5/50 with Trend Filter & Risk Management by JuggiDThe basic SMA (5/50) crossover strategy can be enhanced to improve profitability by adding filters and risk management. For example, a long entry is triggered only when the fast SMA (5) crosses above the slow SMA (50) **and** the price is above the SMA (200), ensuring trades align with the major trend. Similarly, a short entry requires the crossover confirmation plus the price staying below the SMA (200). To reduce false signals and protect capital, stop-loss and take-profit levels can be set automatically (e.g., 2% loss, 5% gain), while additional confirmation tools such as volume spikes, RSI above 50, or MACD momentum can be applied to validate stronger signals. This approach helps avoid whipsaws in sideways markets and allows trades to capture larger moves while minimizing downside risk.
Pine Script®策略
由MeowTools提供
Weekly Session BreakThis indicator plots a vertical line at the end of the trading week (Friday) to mark the weekly session break. It is designed to be used on intraday charts (sub-1 hour timeframes). The line's appearance is fully customizable via the Inputs tab, allowing you to change its color, style (solid, dotted, or dashed), and thickness. Key Features: End-of-Week Marker: Accurately draws a vertical line on the last bar of the trading week. Timeframe Specific: Lines are only visible on intraday charts (1-minute to 59-minute timeframes) to prevent clutter on higher timeframes. Customizable: Adjust the line's color, style, and thickness from the Inputs menu.
Pine Script®指标
由emini_watch提供
FiniteStateMachine🟩 OVERVIEW A flexible framework for creating, testing and implementing a Finite State Machine (FSM) in your script. FSMs use rules to control how states change in response to events. This is the first Finite State Machine library on TradingView and it's quite a different way to think about your script's logic. Advantages of using this vs hardcoding all your logic include: • Explicit logic : You can see all rules easily side-by-side. • Validation : Tables show your rules and validation results right on the chart. • Dual approach : Simple matrix for straightforward transitions; map implementation for concurrent scenarios. You can combine them for complex needs. • Type safety : Shows how to use enums for robustness while maintaining string compatibility. • Real-world examples : Includes both conceptual (traffic lights) and practical (trading strategy) demonstrations. • Priority control : Explicit control over which rules take precedence when multiple conditions are met. • Wildcard system : Flexible pattern matching for states and events. The library seems complex, but it's not really. Your conditions, events, and their potential interactions are complex. The FSM makes them all explicit, which is some work. However, like all "good" pain in life, this is front-loaded, and *saves* pain later, in the form of unintended interactions and bugs that are very hard to find and fix. 🟩 SIMPLE FSM (MATRIX-BASED) The simple FSM uses a matrix to define transition rules with the structure: state > event > state. We look up the current state, check if the event in that row matches, and if it does, output the resulting state. Each row in the matrix defines one rule, and the first matching row, counting from the top down, is applied. A limitation of this method is that you can supply only ONE event. You can design layered rules using widlcards. Use an empty string "" or the special string "ANY" for any state or event wildcard. The matrix FSM is foruse where you have clear, sequential state transitions triggered by single events. Think traffic lights, or any logic where only one thing can happen at a time. The demo for this FSM is of traffic lights. 🟩 CONCURRENT FSM (MAP-BASED) The map FSM uses a more complex structure where each state is a key in the map, and its value is an array of event rules. Each rule maps a named condition to an output (event or next state). This FSM can handle multiple conditions simultaneously. Rules added first have higher priority. Adding more rules to existing states combines the entries in the map (if you use the supplied helper function) rather than overwriting them. This FSM is for more complex scenarios where multiple conditions can be true simultaneously, and you need to control which takes precedence. Like trading strategies, or any system with concurrent conditions. The demo for this FSM is a trading strategy. 🟩 HOW TO USE Pine Script libraries contain reusable code for importing into indicators. You do not need to copy any code out of here. Just import the library and call the function you want. For example, for version 1 of this library, import it like this: import SimpleCryptoLife/FiniteStateMachine/1 See the EXAMPLE USAGE sections within the library for examples of calling the functions. For more information on libraries and incorporating them into your scripts, see the Libraries section of the Pine Script User Manual. 🟩 TECHNICAL IMPLEMENTATION Both FSM implementations support wildcards using blank strings "" or the special string "ANY". Wildcards match in this priority order: • Exact state + exact event match • Exact state + empty event (event wildcard) • Empty state + exact event (state wildcard) • Empty state + empty event (full wildcard) When multiple rules match the same state + event combination, the FIRST rule encountered takes priority. In the matrix FSM, this means row order determines priority. In the map FSM, it's the order you add rules to each state. The library uses user-defined types for the map FSM: • o_eventRule : Maps a condition name to an output • o_eventRuleWrapper : Wraps an array of rules (since maps can't contain arrays directly) Everything uses strings for maximum library compatibility, though the examples show how to use enums for type safety by converting them to strings. Unlike normal maps where adding a duplicate key overwrites the value, this library's `m_addRuleToEventMap()` method *combines* rules, making it intuitive to build rule sets without breaking them. 🟩 VALIDATION & ERROR HANDLING The library includes comprehensive validation functions that catch common FSM design errors: Error detection: • Empty next states • Invalid states not in the states array • Duplicate rules • Conflicting transitions • Unreachable states (no entry/exit rules) Warning detection: • Redundant wildcards • Empty states/events (potential unintended wildcards) • Duplicate conditions within states You can display validation results in tables on the chart, with tooltips providing detailed explanations. The helper functions to display the tables are exported so you can call them from your own script. 🟩 PRACTICAL EXAMPLES The library includes four comprehensive demos: Traffic Light Demo (Simple FSM) : Uses the matrix FSM to cycle through traffic light states (red → red+amber → green → amber → red) with timer events. Includes pseudo-random "break" events and repair logic to demonstrate wildcards and priority handling. Trading Strategy Demo (Concurrent FSM) : Implements a realistic long-only trading strategy using BOTH FSM types: • Map FSM converts multiple technical conditions (EMA crosses, gaps, fractals, RSI) into prioritised events • Matrix FSM handles state transitions (idle → setup → entry → position → exit → re-entry) • Includes position management, stop losses, and re-entry logic Error Demonstrations : Both FSM types include error demos with intentionally malformed rules to showcase the validation system's capabilities. 🟩 BRING ON THE FUNCTIONS f_printFSMMatrix(_mat_rules, _a_states, _tablePosition)   Prints a table of states and rules to the specified position on the chart. Works only with the matrix-based FSM.   Parameters:      _mat_rules (matrix)      _a_states (array)      _tablePosition (simple string)   Returns: The table of states and rules. method m_loadMatrixRulesFromText(_mat_rules, _rulesText)   Loads rules into a rules matrix from a multiline string where each line is of the form "current state | event | next state" (ignores empty lines and trims whitespace). This is the most human-readable way to define rules because it's a visually aligned, table-like format.   Namespace types: matrix   Parameters:      _mat_rules (matrix)      _rulesText (string)   Returns: No explicit return. The matrix is modified as a side-effect. method m_addRuleToMatrix(_mat_rules, _currentState, _event, _nextState)   Adds a single rule to the rules matrix. This can also be quite readble if you use short variable names and careful spacing.   Namespace types: matrix   Parameters:      _mat_rules (matrix)      _currentState (string)      _event (string)      _nextState (string)   Returns: No explicit return. The matrix is modified as a side-effect. method m_validateRulesMatrix(_mat_rules, _a_states, _showTable, _tablePosition)   Validates a rules matrix and a states array to check that they are well formed. Works only with the matrix-based FSM. Checks: matrix has exactly 3 columns; no empty next states; all states defined in array; no duplicate states; no duplicate rules; all states have entry/exit rules; no conflicting transitions; no redundant wildcards. To avoid slowing down the script unnecessarily, call this method once (perhaps using `barstate.isfirst`), when the rules and states are ready.   Namespace types: matrix   Parameters:      _mat_rules (matrix)      _a_states (array)      _showTable (bool)      _tablePosition (simple string)   Returns: `true` if the rules and states are valid; `false` if errors or warnings exist. method m_getStateFromMatrix(_mat_rules, _currentState, _event, _strictInput, _strictTransitions)   Returns the next state based on the current state and event, or `na` if no matching transition is found. Empty (not na) entries are treated as wildcards if `strictInput` is false. Priority: exact match > event wildcard > state wildcard > full wildcard.   Namespace types: matrix   Parameters:      _mat_rules (matrix)      _currentState (string)      _event (string)      _strictInput (bool)      _strictTransitions (bool)   Returns: The next state or `na`. method m_addRuleToEventMap(_map_eventRules, _state, _condName, _output)   Adds a single event rule to the event rules map. If the state key already exists, appends the new rule to the existing array (if different). If the state key doesn't exist, creates a new entry.   Namespace types: map   Parameters:      _map_eventRules (map)      _state (string)      _condName (string)      _output (string)   Returns: No explicit return. The map is modified as a side-effect. method m_addEventRulesToMapFromText(_map_eventRules, _configText)   Loads event rules from a multiline text string into a map structure. Format: "state | condName > output | condName > output | ..." . Pairs are ordered by priority. You can have multiple rules on the same line for one state. Supports wildcards: Use an empty string ("") or the special string "ANY" for state or condName to create wildcard rules. Examples: " | condName > output" (state wildcard), "state | > output" (condition wildcard), " | > output" (full wildcard). Splits lines by , extracts state as key, creates/appends to array with new o_eventRule(condName, output). Call once, e.g., on barstate.isfirst for best performance.   Namespace types: map   Parameters:      _map_eventRules (map)      _configText (string)   Returns: No explicit return. The map is modified as a side-effect. f_printFSMMap(_map_eventRules, _a_states, _tablePosition)   Prints a table of map-based event rules to the specified position on the chart.   Parameters:      _map_eventRules (map)      _a_states (array)      _tablePosition (simple string)   Returns: The table of map-based event rules. method m_validateEventRulesMap(_map_eventRules, _a_states, _a_validEvents, _showTable, _tablePosition)   Validates an event rules map to check that it's well formed. Checks: map is not empty; wrappers contain non-empty arrays; no duplicate condition names per state; no empty fields in o_eventRule objects; optionally validates outputs against matrix events. NOTE: Both "" and "ANY" are treated identically as wildcards for both states and conditions. To avoid slowing down the script unnecessarily, call this method once (perhaps using `barstate.isfirst`), when the map is ready.   Namespace types: map   Parameters:      _map_eventRules (map)      _a_states (array)      _a_validEvents (array)      _showTable (bool)      _tablePosition (simple string)   Returns: `true` if the event rules map is valid; `false` if errors or warnings exist. method m_getEventFromConditionsMap(_currentState, _a_activeConditions, _map_eventRules)   Returns a single event or state string based on the current state and active conditions. Uses a map of event rules where rules are pre-sorted by implicit priority via load order. Supports wildcards using empty string ("") or "ANY" for flexible rule matching. Priority: exact match > condition wildcard > state wildcard > full wildcard.   Namespace types: series string, simple string, input string, const string   Parameters:      _currentState (string)      _a_activeConditions (array)      _map_eventRules (map)   Returns: The output string (event or state) for the first matching condition, or na if no match found. o_eventRule   o_eventRule defines a condition-to-output mapping for the concurrent FSM.   Fields:      condName (series string) : The name of the condition to check.      output (series string) : The output (event or state) when the condition is true. o_eventRuleWrapper   o_eventRuleWrapper wraps an array of o_eventRule for use as map values (maps cannot contain collections directly).   Fields:      a_rules (array) : Array of o_eventRule objects for a specific state.
Pine Script®库
由SimpleCryptoLife提供
2
Daily + 4H MACD & RSI Screeneri used this script for my swing trading entry. //@version=5 indicator("Daily + 4H MACD & RSI Screener", overlay=false) // settings rsiLength = input.int(14, "RSI Length") rsiLevel = input.int(50, "RSI Threshold") macdFast = input.int(12, "MACD Fast") macdSlow = input.int(26, "MACD Slow") macdSignal = input.int(9, "MACD Signal") // ---- daily timeframe ---- dailyRsi = request.security(syminfo.tickerid, "D", ta.rsi(close, rsiLength)) = request.security(syminfo.tickerid, "D", ta.macd(close, macdFast, macdSlow, macdSignal)) dailyRsiPass = dailyRsi < rsiLevel dailyMacdPass = dailyMacd < 0 dailyCondition = dailyRsiPass and dailyMacdPass // ---- 4H timeframe ---- h4Rsi = request.security(syminfo.tickerid, "240", ta.rsi(close, rsiLength)) = request.security(syminfo.tickerid, "240", ta.macd(close, macdFast, macdSlow, macdSignal)) h4RsiPass = h4Rsi < rsiLevel h4MacdPass = h4Macd < 0 h4Condition = h4RsiPass and h4MacdPass // ---- combined condition ---- finalCondition = dailyCondition and h4Condition // plot signals plotshape(finalCondition, style=shape.triangledown, location=location.top, color=color.red, size=size.large, title="Signal") bgcolor(finalCondition ? color.new(color.red, 85) : na) // ---- table (3 columns x 4 rows) ---- var table statusTable = table.new(position=position.top_right, columns=3, rows=4, border_width=1) // headers table.cell(statusTable, 0, 0, "Timeframe", text_color=color.white, bgcolor=color.new(color.black, 0)) table.cell(statusTable, 1, 0, "RSI", text_color=color.white, bgcolor=color.new(color.black, 0)) table.cell(statusTable, 2, 0, "MACD", text_color=color.white, bgcolor=color.new(color.black, 0)) // daily row table.cell(statusTable, 0, 1, "Daily", text_color=color.white, bgcolor=color.new(color.black, 0)) table.cell(statusTable, 1, 1, str.tostring(dailyRsi, "#.##"), text_color=color.white, bgcolor=dailyRsiPass ? color.new(color.green, 60) : color.new(color.red, 60)) table.cell(statusTable, 2, 1, str.tostring(dailyMacd, "#.##"), text_color=color.white, bgcolor=dailyMacdPass ? color.new(color.green, 60) : color.new(color.red, 60)) // 4H row table.cell(statusTable, 0, 2, "4H", text_color=color.white, bgcolor=color.new(color.black, 0)) table.cell(statusTable, 1, 2, str.tostring(h4Rsi, "#.##"), text_color=color.white, bgcolor=h4RsiPass ? color.new(color.green, 60) : color.new(color.red, 60)) table.cell(statusTable, 2, 2, str.tostring(h4Macd, "#.##"), text_color=color.white, bgcolor=h4MacdPass ? color.new(color.green, 60) : color.new(color.red, 60)) // status row (simulate colspan by using two adjacent cells with the same bgcolor) table.cell(statusTable, 0, 3, "Status", text_color=color.white, bgcolor=color.new(color.black, 0)) statusText = finalCondition ? "match" : "no match" statusBg = finalCondition ? color.new(color.green, 0) : color.new(color.red, 0) table.cell(statusTable, 1, 3, statusText, text_color=color.white, bgcolor=statusBg, text_size=size.large) table.cell(statusTable, 2, 3, "", text_color=color.white, bgcolor=statusBg)
Pine Script®指标
由speakjustly提供
Highlight 10-11 AM NY//@version=5 indicator("Highlight 10-11 AM NY", overlay=true) // Inputs for flexibility startHour = input.int(10, "Start Hour (NY time)") endHour = input.int(11, "End Hour (NY time)") // Check if the current bar is within the session (uses chart time zone) inSession = (hour(time, syminfo.timezone) >= startHour) and (hour(time, syminfo.timezone) < endHour) // Highlight background bgcolor(inSession ? color.new(color.yellow, 85) : na)
Pine Script®指标
由warriorsamongstmen提供
Market Order Risk CalculatorObviously the Long/Short Position tool does this, but when you are scalping, 10 - 15 seconds matters. What matters more than that is defined risk, you dont want your losses being scattered, 300 here 145 there, you want consistent risk to have consistent data. What this does is when you are framing a trade, it provides a hands off tool that tells you exactly how many contracts to enter with, that way if you have bracket orders on, your stop will be exactly where you want it to be without going over your defined risk.
Pine Script®指标
由kamron_lashley提供
Futures Tick & Point Value [BoredYeti]Futures Tick & Point Value This utility displays tick size, dollars per tick, and (optionally) a per-point row for the current futures contract. Features • Hardcoded $/tick map for common CME/NYMEX/CBOT/COMEX contracts • Automatic fallback using pointvalue * mintick for any other symbol • Table settings: adjustable position, text size, customizable colors • Optional “Per Point” row showing ticks and $/point Notes • Contract specs can vary by broker/exchange and may change over time. Always confirm with official specifications. • Educational tool only; not financial advice.
Pine Script®指标
由BoredYeti提供
Intelligent Currency Breakout ChannelIndicator: Intelligent Currency Breakout Channel This document provides a detailed explanation of the "Intelligent Currency Breakout Channel" indicator for TradingView. 1. Overview The Intelligent Currency Breakout Channel is an advanced technical analysis tool designed to identify periods of price consolidation and signal potential breakouts. It automatically draws channels around ranging price action and utilizes sophisticated volume analysis to provide deeper insights into market sentiment. The indicator also includes a built-in logarithmic regression screener to help traders align their breakout signals with the broader market trend. 2. Key Features Automatic Channel Detection: The indicator identifies periods of low volatility and automatically draws a containing channel (box) around the price action. Breakout Signals: It generates clear visual alerts (▲ for bullish, ▼ for bearish) when the price closes decisively outside of a channel. In-Depth Volume Analysis: Within each channel, the indicator plots volume as candlestick-like bars, offering three distinct modes: Total Volume, Buy/Sell Comparison, and Volume Delta. This helps traders gauge the strength and conviction behind price movements. Real-time Sentiment Gauge: When a channel is active, a dynamic color-graded gauge appears on the right side of the chart. It visualizes the current volume delta momentum relative to its recent range, offering an at-a-glance sentiment reading. Integrated Trend Screener: A secondary analysis tool based on logarithmic regression is included to determine the underlying trend direction (Up, Down, or Neutral), which can be used to filter breakout signals. Fully Customizable: Users can extensively customize all parameters, from calculation lengths and breakout sensitivity to the visual appearance of every component. 3. How to Use Channel Formation: Watch for the indicator to draw a new channel. This signifies that the market is in a consolidation or ranging phase. The formation of a channel itself can be an alertable event. Volume Interpretation: Observe the volume bars inside the channel. An increase in volume as the price approaches the channel's upper or lower boundary can foreshadow a potential breakout. Use the Volume Display Mode to analyze if buying pressure (Comparison, Delta) or selling pressure is building. Breakout Confirmation: A bullish breakout signal (▲) appears when the price closes above the channel's upper boundary. A bearish breakout signal (▼) appears when the price closes below the lower boundary. For higher-quality signals, enable the Strong Closes Only option. Trend Confirmation (Screener): Use the screener's plot and background color to confirm the broader trend. For instance, you might choose to only take bullish breakout signals when the screener indicates an uptrend (green background) and bearish signals when it indicates a downtrend (red background). Sentiment Gauge: The pointer on the gauge indicates current momentum. A pointer in the upper (green) section suggests bullish pressure, while a pointer in the lower (red) section suggests bearish pressure. This can provide additional confluence for a trade decision. 4. Settings and Inputs Main Settings Overlap Channels: If enabled, allows multiple channels to be drawn on the chart simultaneously, even if they overlap. When disabled, a new channel will only form if it doesn't intersect with an existing one. Strong Closes Only: If enabled, a breakout is only triggered if the midpoint of the candle's body (average of open and close) is outside the channel. This helps filter out false signals caused by long wicks. If disabled, any close outside the channel triggers a breakout. Normalization Length: The lookback period (in bars) used for price normalization. A higher value creates a more stable normalization but may be slower to react to recent price changes. Box Detection Length: The lookback period used to detect the channel formation pattern. A lower value will result in more frequent channels but may be more sensitive to noise. A higher value will result in fewer, but potentially more significant, channels. Volume Analysis Show Volume Analysis: Toggles the visibility of the candlestick-like volume bars inside the channel. Volume Display Mode: Volume: Displays total volume as symmetrical bars around the channel's midline. Comparison: Shows buying volume (green) above the midline and selling volume (red) below it. Delta: Shows the net difference between buying and selling volume. Positive delta is shown above the midline, and negative delta is shown below. Volume Delta Timeframe Source: The timeframe from which to source volume data for calculations. Using a lower timeframe can provide a more granular view of volume dynamics. Volume Scaling: A multiplier that adjusts the vertical size of the volume bars relative to the channel's height. Appearance Volume Text Size: Sets the size of the volume data text displayed in the corners of the channel. Options: Tiny, Small, Medium, Large. Bullish Color: The primary color for all bullish visual elements, including breakout signals and positive volume bars. Bearish Color: The primary color for all bearish visual elements, including breakout signals and negative volume bars. Screener Settings Lookback Period: The number of bars used for the logarithmic regression calculation to determine the trend. Screener Type: Log Regression Channel: The signal is based on the slope of the entire regression channel over the lookback period. An upward sloping channel is bullish (1), and a downward sloping one is bearish (-1). Logarithmic Regression: The signal is based on the most recent value of the regression line compared to its value 3 bars ago. This provides a more responsive measure of the immediate trend. 5. Alerts You can set up the following alerts through the TradingView alerts panel: New Channel Formed: Triggers when a new price consolidation channel is detected and drawn on the chart. Bullish Breakout: Triggers when the price breaks out and closes above the upper boundary of a channel. Bearish Breakout: Triggers when the price breaks out and closes below the lower boundary of a channel. Is In Channel: Triggers on every bar that the price is currently trading inside an active channel. Signal UP: Triggers when the Screener's signal turns bullish (1). Signal DOWN: Triggers when the Screener's signal turns bearish (-1).
Pine Script®指标
由imtpcsuva提供